From 899e2cc670d4d773deeef10804142adec182610f Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Mon, 21 Jul 2025 00:05:07 -0500 Subject: [PATCH 01/28] added a list of paintables to RenderableLayer. Added API to fetch renderable layer by name. Expanded the size of the example map and fixed the move effect to better highlight this module's features. --- .../flame_tiled/example/assets/tiles/map.tmx | 51 +++++++++++++++---- packages/flame_tiled/example/lib/main.dart | 27 +++++----- .../src/renderable_layers/group_layer.dart | 3 ++ .../src/renderable_layers/image_layer.dart | 6 ++- .../src/renderable_layers/object_layer.dart | 7 ++- .../renderable_layers/renderable_layer.dart | 18 ++++++- .../tile_layers/tile_layer.dart | 4 ++ .../lib/src/renderable_tile_map.dart | 6 +++ 8 files changed, 96 insertions(+), 26 deletions(-) diff --git a/packages/flame_tiled/example/assets/tiles/map.tmx b/packages/flame_tiled/example/assets/tiles/map.tmx index ea5fb14f351..1fae79cffef 100644 --- a/packages/flame_tiled/example/assets/tiles/map.tmx +++ b/packages/flame_tiled/example/assets/tiles/map.tmx @@ -1,5 +1,5 @@ - + @@ -9,24 +9,24 @@ - + - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQQAAAEIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGEAAABiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACHAAAAiAAAAIkAAACKAAAAiwAAAIwAAACBAAAAggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApwAAAKgAAACpAAAAqgAAAKsAAACsAAAAoQAAAKIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMEAAADCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChAAAAogAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwQAAAMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGEAAABiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABHAQAASAEAAEkBAABKAQAASwEAAEwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBAAAAggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZwEAAGgBAABpAQAAagEAAGsBAABsAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoQAAAKIAAAAAAAAASAEAAEgBAABIAQAASAEAAEgBAABIAQAASAEAAEgBAABIAQAASAEAAEgBAABIAQAASAEAAEgBAABIAQAATAEAAAAAAAAAAAAAAAAAAIcBAACIAQAAiQEAAIoBAACLAQAAjAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMEAAADCAAAAAAAAAGsBAABqAQAAawEAAGoBAABrAQAAagEAAGsBAABqAQAAawEAAGoBAABrAQAAagEAAGsBAABqAQAAawEAAGwBAAAAAAAAAAAAAAAAAACnAQAAqAEAAKkBAACqAQAAqwEAAKwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhAAAAYgAAAAAAAACLAQAAigEAAIsBAACKAQAAiwEAAIoBAACLAQAAigEAAIsBAACKAQAAiwEAAIoBAACLAQAAigEAAIsBAABsAQAAAAAAAAAAAAAAAAAAZwEAAGgBAABpAQAAagEAAGsBAABsAQAAAAAAAAAAAACHAAAAiAAAAIkAAACKAAAAiwAAAIwAAAAAAAAAAAAAAAAAAAAAAAAAgQAAAIIAAAAAAAAAawEAAGoBAABrAQAAagEAAGsBAABqAQAAawEAAGoBAABrAQAAagEAAGsBAABqAQAAawEAAGoBAABrAQAAbAEAAAAAAAAAAAAAAAAAAIcBAACIAQAAiQEAAIoBAACLAQAAjAEAAAAAAAAAAAAApwAAAKgAAACpAAAAqgAAAKsAAACsAAAAAAAAAAAAAAAAAAAAAAAAAKEAAACiAAAAAAAAAIsBAACKAQAAiwEAAIoBAACLAQAAigEAAIsBAACKAQAAiwEAAIoBAACLAQAAigEAAIsBAACKAQAAiwEAAGwBAAAAAAAAAAAAAAAAAACnAQAAqAEAAKkBAACqAQAAqwEAAKwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADBAAAAwgAAAAAAAACnAAAAqAAAAKkAAACoAAAAqQAAAKoAAACrAAAAqAAAAKkAAACqAAAAqwAAAKgAAACpAAAAqgAAAKsAAACsAAAAAAAAAAAAAAAAAAAAZwEAAGgBAABpAQAAagEAAGsBAABsAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYQAAAGIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIcBAACIAQAAiQEAAIoBAACLAQAAjAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIEAAACCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACnAQAAqAEAAKkBAACqAQAAqwEAAKwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChAAAAogAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZwEAAGgBAABpAQAAagEAAGsBAABsAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwQAAAMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvAwAAMAMAAPUCAAD2AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIcBAACIAQAAiQEAAIoBAACLAQAAjAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOEAAADiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADHAwAAyAMAAMkDAADKAwAAywMAAMwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACnAQAAqAEAAKkBAACqAQAAqwEAAKwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcDAAAIAwAACQMAAAoDAAALAwAADAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5wMAAOgDAADpAwAA6gMAAOsDAADsAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApwAAAKgAAACpAAAAqgAAAKsAAACsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnAwAAKAMAACkDAAAqAwAAKwMAACwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcEAAAIBAAACQQAAAoEAAALBAAADAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnBAAAKAQAACkEAAAqBAAAKwQAACwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANMCAADUAgAAAAAAAAAAAAAAAAAA0QIAANICAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5wMAAOgDAADpAwAA6gMAAOsDAADsAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADzAgAA9AIAAAAAAAAAAAAAAAAAAPECAADyAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcEAAAIBAAACQQAAAoEAAALBAAADAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDAwAAhAMAAIUDAACGAwAAyAMAAMkDAADKAwAAywMAAMgDAADJAwAAygMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnBAAAKAQAACkEAAAqBAAAKwQAACwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAowMAAKQDAAClAwAApgMAAOgDAADpAwAA6gMAAOsDAADoAwAA6QMAAOoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5wMAAOgDAADpAwAA6gMAAOsDAADsAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM8CAADQAgAAgwMAAIQDAACFAwAAhgMAAMMDAADoAwAA6QMAAOoDAADpAwAA6gMAAOkDAADqAwAA6QMAAOoDAAAKBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcEAAAIBAAACQQAAAoEAAALBAAADAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADvAgAA8AIAAKMDAACkAwAApQMAAKYDAADoAwAA6QMAAOoDAADrAwAACQQAAAoEAAAJBAAACgQAAAkEAAAKBAAA6QMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnBAAAKAQAACkEAAAqBAAAKwQAACwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMcDAADIAwAAyQMAAMoDAADDAwAA6AMAAOkDAADqAwAA6QMAAOoDAADpAwAA6gMAACkEAAAqBAAA6QMAAOoDAADpAwAA6gMAAAkEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5wMAAOgDAADpAwAA6gMAAOsDAADsAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADnAwAA6AMAAOkDAADqAwAA4wMAAAgEAADpAwAA6gMAAAkEAAAKBAAACQQAAAoEAAAJBAAACgQAAAkEAAAKBAAACQQAAAoEAAApBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcEAAAIBAAACQQAAAoEAAALBAAADAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwQAAAgEAAAJBAAACgQAAOkDAADqAwAACQQAAAoEAAApBAAAKgQAACkEAAAqBAAAKQQAACoEAADpAwAA6gMAAOkDAADqAwAA6QMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnBAAAKAQAACkEAAAqBAAAKwQAACwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACcEAAAoBAAAKQQAACoEAAAJBAAACgQAACkEAAAqBAAACAQAAAkEAADpAwAA6gMAAOkDAADqAwAACQQAAAoEAAAJBAAACgQAAOkDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5wMAAOgDAADpAwAA6gMAAOsDAADsAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADnAwAA6AMAAOkDAADqAwAAKQQAACoEAADpAwAA6gMAAOkDAADqAwAACQQAAAoEAAAJBAAACgQAAOkDAADqAwAAKQQAACoEAAAJBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcEAAAIBAAACQQAAAoEAAALBAAADAQAAEMDAABEAwAAQwMAAEQDAABDAwAARAMAAEMDAABEAwAABwQAAAgEAAAJBAAACgQAAOkDAADqAwAACQQAAAoEAAAJBAAACgQAACkEAAAqBAAAKQQAACoEAAAJBAAACgQAAOkDAADqAwAAKQQAAA== + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBAAAAQgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGEAAABiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhwAAAIgAAACJAAAAigAAAIsAAACMAAAAgQAAAIIAAACMAACAiwAAgIoAAICJAACAiAAAgIcAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACnAAAAqAAAAKkAAACqAAAAqwAAAKwAAAChAAAAogAAAKwAAICrAACAqgAAgKkAAICoAACApwAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMEAAADCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoQAAAKIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADBAAAAwgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGEAAABiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARwEAAEgBAABJAQAASgEAAEsBAABMAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgQAAAIIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMAQCASwEAgEoBAIBJAQCASAEAgEcBAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABnAQAAaAEAAGkBAABqAQAAawEAAGwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChAAAAogAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGwBAIBrAQCAagEAgGkBAIBoAQCAZwEAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASAEAAEgBAABIAQAASAEAAEgBAABIAQAASAEAAEgBAABIAQAASAEAAEgBAABIAQAASAEAAEgBAABIAQAATAEAAAAAAAAAAAAAAAAAAIcBAACIAQAAiQEAAIoBAACLAQAAjAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMEAAADCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjAEAgIsBAICKAQCAiQEAgIgBAICHAQCAAAAAAAAAAAAAAAAATAEAgEgBAIBIAQCASAEAgEgBAIBIAQCASAEAgEgBAIBIAQCASAEAgEgBAIBIAQCASAEAgEgBAIBIAQCASAEAgAAAAAAAAAAAAAAAAAAAAABrAQAAagEAAGsBAABqAQAAawEAAGoBAABrAQAAagEAAGsBAABqAQAAawEAAGoBAABrAQAAagEAAGsBAABsAQAAAAAAAAAAAAAAAAAApwEAAKgBAACpAQAAqgEAAKsBAACsAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYQAAAGIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACsAQCAqwEAgKoBAICpAQCAqAEAgKcBAIAAAAAAAAAAAAAAAABsAQCAawEAgGoBAIBrAQCAagEAgGsBAIBqAQCAawEAgGoBAIBrAQCAagEAgGsBAIBqAQCAawEAgGoBAIBrAQCAAAAAAAAAAAAAAAAAAAAAAIsBAACKAQAAiwEAAIoBAACLAQAAigEAAIsBAACKAQAAiwEAAIoBAACLAQAAigEAAIsBAACKAQAAiwEAAGwBAAAAAAAAAAAAAAAAAABnAQAAaAEAAGkBAABqAQAAawEAAGwBAAAAAAAAAAAAAIcAAACIAAAAiQAAAIoAAACLAAAAjAAAAAAAAAAAAAAAAAAAAAAAAACBAAAAggAAAAAAAAAAAAAAAAAAAAAAAABIAQAASAEAAEgBAIBIAQCASAEAgEgBAIAAAAAAAAAAAGwBAIBrAQCAagEAgGkBAIBoAQCAZwEAgAAAAAAAAAAAAAAAAGwBAICLAQCAigEAgIsBAICKAQCAiwEAgIoBAICLAQCAigEAgIsBAICKAQCAiwEAgIoBAICLAQCAigEAgIsBAIAAAAAAAAAAAAAAAAAAAAAAawEAAGoBAABrAQAAagEAAGsBAABqAQAAawEAAGoBAABrAQAAagEAAGsBAABqAQAAawEAAGoBAABrAQAAbAEAAAAAAAAAAAAAAAAAAIcBAACIAQAAiQEAAIoBAACLAQAAjAEAAAAAAAAAAAAApwAAAKgAAACpAAAAqgAAAKsAAACsAAAAAAAAAAAAAAAAAAAAAAAAAKEAAACiAAAAAAAAAAAAAAAAAAAAAAAAAGsBAABqAQAAagEAgGsBAIBqAQCAawEAgAAAAAAAAAAAjAEAgIsBAICKAQCAiQEAgIgBAICHAQCAAAAAAAAAAAAAAAAAbAEAgGsBAIBqAQCAawEAgGoBAIBrAQCAagEAgGsBAIBqAQCAawEAgGoBAIBrAQCAagEAgGsBAIBqAQCAawEAgAAAAAAAAAAAAAAAAAAAAACLAQAAigEAAIsBAACKAQAAiwEAAIoBAACLAQAAigEAAIsBAACKAQAAiwEAAIoBAACLAQAAigEAAIsBAABsAQAAAAAAAAAAAAAAAAAApwEAAKgBAACpAQAAqgEAAKsBAACsAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwQAAAMIAAAAAAAAAAAAAAAAAAAAAAAAAiwEAAIoBAACKAQCAiwEAgIoBAICLAQCAAAAAAAAAAACsAQCAqwEAgKoBAICpAQCAqAEAgKcBAIAAAAAAAAAAAAAAAABsAQCAiwEAgIoBAICLAQCAigEAgIsBAICKAQCAiwEAgIoBAICLAQCAigEAgIsBAICKAQCAiwEAgIoBAICLAQCAAAAAAAAAAAAAAAAAAAAAAKcAAACoAAAAqQAAAKgAAACpAAAAqgAAAKsAAACoAAAAqQAAAKoAAACrAAAAqAAAAKkAAACqAAAAqwAAAKwAAAAAAAAAAAAAAAAAAABnAQAAaAEAAGkBAABqAQAAawEAAGwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhAAAAYgAAAAAAAAAAAAAAAAAAAAAAAABrAQAAagEAAGoBAIBrAQCAagEAgGsBAIAAAAAAAAAAAGwBAIBrAQCAagEAgGkBAIBoAQCAZwEAgAAAAAAAAAAAAAAAAKwAAICrAACAqgAAgKkAAICoAACAqwAAgKoAAICpAACAqAAAgKsAAICqAACAqQAAgKgAAICpAACAqAAAgKcAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIcBAACIAQAAiQEAAIoBAACLAQAAjAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIEAAACCAAAAAAAAAAAAAAAAAAAAAAAAAIsBAACKAQAAigEAgIsBAICKAQCAiwEAgAAAAAAAAAAAjAEAgIsBAICKAQCAiQEAgIgBAICHAQCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApwEAAKgBAACpAQAAqgEAAKsBAACsAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoQAAAKIAAAAAAAAAAAAAAAAAAAAAAAAApwAAAKgAAACoAACAqQAAgKgAAICnAACAAAAAAAAAAACsAQCAqwEAgKoBAICpAQCAqAEAgKcBAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABnAQAAaAEAAGkBAABqAQAAawEAAGwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADBAAAAwgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGwBAIBrAQCAagEAgGkBAIBoAQCAZwEAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvAwAAMAMAAPUCAAD2AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIcBAACIAQAAiQEAAIoBAACLAQAAjAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOEAAADiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjAEAgIsBAICKAQCAiQEAgIgBAICHAQCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9QIAAPYCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxwMAAMgDAADJAwAAygMAAMsDAADMAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApwEAAKgBAACpAQAAqgEAAKsBAACsAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAwAACAMAAAkDAAAKAwAACwMAAAsDAAAKAwCACQMAgAgDAIAHAwCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACsAQCAqwEAgKoBAICpAQCAqAEAgKcBAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzAMAgMsDAIDKAwCAyQMAgMgDAIDHAwCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADnAwAA6AMAAOkDAADqAwAA6wMAAOwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACnAAAAqAAAAKkAAACqAAAAqwAAAKwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACcDAAAoAwAAKQMAACoDAAArAwAAKwMAACoDAIApAwCAKAMAgCcDAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKwAAICrAACAqgAAgKkAAICoAACApwAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADsAwCA6wMAgOoDAIDpAwCA6AMAgOcDAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcEAAAIBAAACQQAAAoEAAALBAAADAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEAIALBACACgQAgAkEAIAIBACABwQAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJwQAACgEAAApBAAAKgQAACsEAAAsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADTAgAA1AIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAQAgCsEAIAqBACAKQQAgCgEAIAnBACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADnAwAA6AMAAOkDAADqAwAA6wMAAOwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPMCAAD0AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9QIAAPUCAAD2AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADsAwCA6wMAgOoDAIDpAwCA6AMAgOcDAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcEAAAIBAAACQQAAAoEAAALBAAADAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDAwAAhAMAAIUDAACGAwAAyAMAAMkDAADKAwAAywMAAMgDAADJAwAAygMAAMoDAIDJAwCAyAMAgMsDAIDKAwCAyQMAgMgDAICGAwCAhQMAgIQDAICDAwCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEAIALBACACgQAgAkEAIAIBACABwQAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJwQAACgEAAApBAAAKgQAACsEAAAsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKMDAACkAwAApQMAAKYDAADoAwAA6QMAAOoDAADrAwAA6AMAAOkDAADqAwAA6gMAgOkDAIDoAwCA6wMAgOoDAIDpAwCA6AMAgKYDAIClAwCApAMAgKMDAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAQAgCsEAIAqBACAKQQAgCgEAIAnBACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADnAwAA6AMAAOkDAADqAwAA6wMAAOwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzwIAANACAACDAwAAhAMAAIUDAACGAwAAwwMAAOgDAADpAwAA6gMAAOkDAADqAwAA6QMAAOoDAADpAwAA6gMAAAoEAAAKBACA6gMAgOkDAIDqAwCA6QMAgOoDAIDpAwCA6gMAgOkDAIDoAwCAwwMAgIYDAICFAwCAhAMAgIMDAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADsAwCA6wMAgOoDAIDpAwCA6AMAgOcDAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcEAAAIBAAACQQAAAoEAAALBAAADAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADvAgAA8AIAAKMDAACkAwAApQMAAKYDAADoAwAA6QMAAOoDAADrAwAACQQAAAoEAAAJBAAACgQAAAkEAAAKBAAA6QMAAOkDAIAKBACACQQAgAoEAIAJBACACgQAgAkEAIDrAwCA6gMAgOkDAIDoAwCApgMAgKUDAICkAwCAowMAgAAAAAAvAwAAMAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEAIALBACACgQAgAkEAIAIBACABwQAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJwQAACgEAAApBAAAKgQAACsEAAAsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADHAwAAyAMAAMkDAADKAwAAwwMAAOgDAADpAwAA6gMAAOkDAADqAwAA6QMAAOoDAAApBAAAKgQAAOkDAADqAwAA6QMAAOoDAAAJBAAACQQAgOoDAIDpAwCA6gMAgOkDAIAqBACAKQQAgOoDAIDpAwCA6gMAgOkDAIDqAwCA6QMAgOgDAIDDAwCAygMAgMkDAIDIAwCAxwMAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAQAgCsEAIAqBACAKQQAgCgEAIAnBACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADnAwAA6AMAAOkDAADqAwAA6wMAAOwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOcDAADoAwAA6QMAAOoDAADjAwAACAQAAOkDAADqAwAACQQAAAoEAAAJBAAACgQAAAkEAAAKBAAACQQAAAoEAAAJBAAACgQAACkEAAApBACACgQAgAkEAIAKBACACQQAgAoEAIAJBACACgQAgAkEAIAKBACACQQAgOoDAIDpAwCACAQAgOMDAIDqAwCA6QMAgOgDAIDnAwCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADsAwCA6wMAgOoDAIDpAwCA6AMAgOcDAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcEAAAIBAAACQQAAAoEAAALBAAADAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwQAAAgEAAAJBAAACgQAAOkDAADqAwAACQQAAAoEAAApBAAAKgQAACkEAAAqBAAAKQQAACoEAADpAwAA6gMAAOkDAADqAwAA6QMAAOkDAIDqAwCA6QMAgOoDAIDpAwCAKgQAgCkEAIAqBACAKQQAgCoEAIApBACACgQAgAkEAIDqAwCA6QMAgAoEAIAJBACACAQAgAcEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEAIALBACACgQAgAkEAIAIBACABwQAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJwQAACgEAAApBAAAKgQAACsEAAAsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnBAAAKAQAACkEAAAqBAAACQQAAAoEAAApBAAAKgQAAAgEAAAJBAAA6QMAAOoDAADpAwAA6gMAAAkEAAAKBAAACQQAAAoEAADpAwAA6QMAgAoEAIAJBACACgQAgAkEAIDqAwCA6QMAgOoDAIDpAwCACQQAgAgEAIAqBACAKQQAgAoEAIAJBACAKgQAgCkEAIAoBACAJwQAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAQAgCsEAIAqBACAKQQAgCgEAIAnBACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADnAwAA6AMAAOkDAADqAwAA6wMAAOwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOcDAADoAwAA6QMAAOoDAAApBAAAKgQAAOkDAADqAwAA6QMAAOoDAAAJBAAACgQAAAkEAAAKBAAA6QMAAOoDAAApBAAAKgQAAAkEAAAJBACAKgQAgCkEAIDqAwCA6QMAgAoEAIAJBACACgQAgAkEAIDqAwCA6QMAgOoDAIDpAwCAKgQAgCkEAIDqAwCA6QMAgOgDAIDnAwCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADsAwCA6wMAgOoDAIDpAwCA6AMAgOcDAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcEAAAIBAAACQQAAAoEAAALBAAADAQAAEMDAABEAwAAQwMAAEQDAABDAwAARAMAAEMDAABEAwAABwQAAAgEAAAJBAAACgQAAOkDAADqAwAACQQAAAoEAAAJBAAACgQAACkEAAAqBAAAKQQAACoEAAAJBAAACgQAAOkDAADqAwAAKQQAACkEAIDqAwCA6QMAgAoEAIAJBACAKgQAgCkEAIAqBACAKQQAgAoEAIAJBACACgQAgAkEAIDqAwCA6QMAgAoEAIAJBACACAQAgAcEAIBEAwCAQwMAgEQDAIBDAwCARAMAgEMDAIBEAwCAQwMAgAwEAIALBACACgQAgAkEAIAIBACABwQAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA== - + - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG8AAABwAAAAdQAAAHYAAACzAAAAtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFEAAABSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABxAAAAcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK8AAACwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA== + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG8AAABwAAAAdQAAAHYAAACzAAAAtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArwAAALAAAAB1AAAAdgAAAHUAAAB2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABRAAAAUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHEAAAByAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdQAAAHYAAAAAAAAAAAAAAAAAAAB1AAAAdgAAAAAAAAAAAAAAAAAAAHUAAAB2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJUAAACWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACvAAAAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtQAAALYAAAAAAAAAAAAAAHUAAAB2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA== - + - + @@ -35,14 +35,47 @@ - + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/packages/flame_tiled/example/lib/main.dart b/packages/flame_tiled/example/lib/main.dart index 639cab92aed..8af0140be2a 100644 --- a/packages/flame_tiled/example/lib/main.dart +++ b/packages/flame_tiled/example/lib/main.dart @@ -27,7 +27,7 @@ class TiledGame extends FlameGame { ..anchor = Anchor.topLeft ..add( MoveToEffect( - Vector2(1000, 0), + Vector2(320, 180), EffectController( duration: 10, alternate: true, @@ -43,23 +43,26 @@ class TiledGame extends FlameGame { mapComponent.tileMap.getLayer('AnimatedCoins'); final coins = await Flame.images.load('coins.png'); + // Add sprites behind the ground decoration layer. + final groundLayer = mapComponent.tileMap.getRenderableLayer('Ground'); + // We are 100% sure that an object layer named `AnimatedCoins` // exists in the example `map.tmx`. for (final object in objectGroup!.objects) { - world.add( - SpriteAnimationComponent( - size: Vector2.all(20.0), - position: Vector2(object.x, object.y), - animation: SpriteAnimation.fromFrameData( - coins, - SpriteAnimationData.sequenced( - amount: 8, - stepTime: 0.15, - textureSize: Vector2.all(20), - ), + final sprite = SpriteAnimationComponent( + size: Vector2.all(20.0), + anchor: Anchor.center, + position: Vector2(object.x, object.y), + animation: SpriteAnimation.fromFrameData( + coins, + SpriteAnimationData.sequenced( + amount: 8, + stepTime: 0.15, + textureSize: Vector2.all(20), ), ), ); + groundLayer?.add(sprite); } } } diff --git a/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart index e754fdede91..ce1d28369d9 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart @@ -39,6 +39,7 @@ class GroupLayer extends RenderableLayer { for (final child in children) { child.render(canvas, camera); } + super.render(canvas, camera); } @override @@ -46,5 +47,7 @@ class GroupLayer extends RenderableLayer { for (final child in children) { child.update(dt); } + + super.update(dt); } } diff --git a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart index 16f8e9cf3f0..6e42a20b7e7 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart @@ -56,6 +56,8 @@ class FlameImageLayer extends RenderableLayer { ); canvas.restore(); + + super.render(canvas, camera); } void _resizePaintArea(CameraComponent? camera) { @@ -131,5 +133,7 @@ class FlameImageLayer extends RenderableLayer { void refreshCache() {} @override - void update(double dt) {} + void update(double dt) { + super.update(dt); + } } diff --git a/packages/flame_tiled/lib/src/renderable_layers/object_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/object_layer.dart index d2328280a18..9c5aaa3f0a3 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/object_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/object_layer.dart @@ -18,7 +18,8 @@ class ObjectLayer extends RenderableLayer { @override void render(Canvas canvas, CameraComponent? camera) { - // nothing to do + // Nothing to do besides call super. + super.render(canvas, camera); } // ignore non-renderable layers when looping over the layers to render @@ -47,5 +48,7 @@ class ObjectLayer extends RenderableLayer { void refreshCache() {} @override - void update(double dt) {} + void update(double dt) { + super.update(dt); + } } diff --git a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart index c78176aacd9..e02d421ef73 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart @@ -17,6 +17,7 @@ abstract class RenderableLayer { final T layer; final Vector2 destTileSize; final TiledMap map; + final List> paintables = []; /// The parent [Group] layer (if it exists) final GroupLayer? parent; @@ -96,13 +97,26 @@ abstract class RenderableLayer { bool get visible => layer.visible; - void render(Canvas canvas, CameraComponent? camera); + @mustCallSuper + void render(Canvas canvas, CameraComponent? camera) { + for (final p in paintables) { + p.renderTree(canvas); + } + } void handleResize(Vector2 canvasSize); void refreshCache(); - void update(double dt); + @mustCallSuper + void update(double dt) { + for (final p in paintables) { + p.updateTree(dt); + } + } + + void add(HasPaint paintable) => paintables.add(paintable); + bool remove(HasPaint paintable) => paintables.remove(paintable); double get scaleX => destTileSize.x / map.tileWidth; double get scaleY => destTileSize.y / map.tileHeight; diff --git a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart index f1d1b168c82..acbfd1d15c7 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart @@ -124,6 +124,8 @@ abstract class FlameTileLayer extends RenderableLayer { for (final animation in animations) { animation.update(dt); } + + super.update(dt); } @override @@ -139,6 +141,8 @@ abstract class FlameTileLayer extends RenderableLayer { } tiledAtlas.batch!.render(canvas, paint: _layerPaint); canvas.restore(); + + super.render(canvas, camera); } @override diff --git a/packages/flame_tiled/lib/src/renderable_tile_map.dart b/packages/flame_tiled/lib/src/renderable_tile_map.dart index 426038d9f20..ae84ff7937d 100644 --- a/packages/flame_tiled/lib/src/renderable_tile_map.dart +++ b/packages/flame_tiled/lib/src/renderable_tile_map.dart @@ -426,6 +426,12 @@ class RenderableTiledMap { } } + RenderableLayer? getRenderableLayer(String name) { + final int idx = renderableLayers.indexWhere((e) => e.layer.name == name); + if (idx == -1) return null; + return renderableLayers[idx]; + } + void update(double dt) { // First, update animation frames. for (final frame in animationFrames.values) { From e8d92fc77f52a3184a4895c6a3eab86b30801983 Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Mon, 21 Jul 2025 00:10:01 -0500 Subject: [PATCH 02/28] fix lint --- packages/flame_tiled/example/lib/main.dart | 23 ++++++++++--------- .../src/renderable_layers/image_layer.dart | 5 ---- .../src/renderable_layers/object_layer.dart | 5 ---- .../renderable_layers/renderable_layer.dart | 6 ----- .../lib/src/renderable_tile_map.dart | 12 ++++++---- 5 files changed, 19 insertions(+), 32 deletions(-) diff --git a/packages/flame_tiled/example/lib/main.dart b/packages/flame_tiled/example/lib/main.dart index 8af0140be2a..4dbcd24452b 100644 --- a/packages/flame_tiled/example/lib/main.dart +++ b/packages/flame_tiled/example/lib/main.dart @@ -49,20 +49,21 @@ class TiledGame extends FlameGame { // We are 100% sure that an object layer named `AnimatedCoins` // exists in the example `map.tmx`. for (final object in objectGroup!.objects) { - final sprite = SpriteAnimationComponent( - size: Vector2.all(20.0), - anchor: Anchor.center, - position: Vector2(object.x, object.y), - animation: SpriteAnimation.fromFrameData( - coins, - SpriteAnimationData.sequenced( - amount: 8, - stepTime: 0.15, - textureSize: Vector2.all(20), + groundLayer?.add( + SpriteAnimationComponent( + size: Vector2.all(20.0), + anchor: Anchor.center, + position: Vector2(object.x, object.y), + animation: SpriteAnimation.fromFrameData( + coins, + SpriteAnimationData.sequenced( + amount: 8, + stepTime: 0.15, + textureSize: Vector2.all(20), + ), ), ), ); - groundLayer?.add(sprite); } } } diff --git a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart index 6e42a20b7e7..a562b21ef49 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart @@ -131,9 +131,4 @@ class FlameImageLayer extends RenderableLayer { @override void refreshCache() {} - - @override - void update(double dt) { - super.update(dt); - } } diff --git a/packages/flame_tiled/lib/src/renderable_layers/object_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/object_layer.dart index 9c5aaa3f0a3..a4a9ff620c4 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/object_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/object_layer.dart @@ -46,9 +46,4 @@ class ObjectLayer extends RenderableLayer { @override void refreshCache() {} - - @override - void update(double dt) { - super.update(dt); - } } diff --git a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart index e02d421ef73..438088a1dd1 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart @@ -171,15 +171,9 @@ class UnsupportedLayer extends RenderableLayer { required super.destTileSize, }); - @override - void render(Canvas canvas, CameraComponent? camera) {} - @override void handleResize(Vector2 canvasSize) {} @override void refreshCache() {} - - @override - void update(double dt) {} } diff --git a/packages/flame_tiled/lib/src/renderable_tile_map.dart b/packages/flame_tiled/lib/src/renderable_tile_map.dart index ae84ff7937d..85adeac090a 100644 --- a/packages/flame_tiled/lib/src/renderable_tile_map.dart +++ b/packages/flame_tiled/lib/src/renderable_tile_map.dart @@ -426,11 +426,13 @@ class RenderableTiledMap { } } - RenderableLayer? getRenderableLayer(String name) { - final int idx = renderableLayers.indexWhere((e) => e.layer.name == name); - if (idx == -1) return null; - return renderableLayers[idx]; - } + /// Returns a [RenderableLayer] with given [name] from all the layers + /// of this map. If no such layer is found, null is returned. + RenderableLayer? getRenderableLayer(String name) => + switch (renderableLayers.indexWhere((e) => e.layer.name == name)) { + -1 => null, + final int idx => renderableLayers[idx], + }; void update(double dt) { // First, update animation frames. From 25d6ae614062a7729c77bd51eaaa6f1538f79486 Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Mon, 21 Jul 2025 01:48:53 -0500 Subject: [PATCH 03/28] make RenderableLayer export in lib --- packages/flame_tiled/lib/flame_tiled.dart | 1 + .../flame_tiled/lib/src/renderable_layers/renderable_layer.dart | 1 - 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/flame_tiled/lib/flame_tiled.dart b/packages/flame_tiled/lib/flame_tiled.dart index 42813d3421b..09d9c12ea27 100644 --- a/packages/flame_tiled/lib/flame_tiled.dart +++ b/packages/flame_tiled/lib/flame_tiled.dart @@ -5,6 +5,7 @@ export 'package:tiled/tiled.dart'; export 'src/extensions.dart'; export 'src/flame_tsx_provider.dart'; export 'src/renderable_tile_map.dart'; +export 'src/renderable_layers/renderable_layer.dart'; export 'src/simple_flips.dart'; export 'src/tile_atlas.dart'; export 'src/tiled_component.dart'; diff --git a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart index 438088a1dd1..34f51c7f361 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart @@ -12,7 +12,6 @@ import 'package:flame_tiled/src/tile_atlas.dart'; import 'package:meta/meta.dart'; import 'package:tiled/tiled.dart'; -@internal abstract class RenderableLayer { final T layer; final Vector2 destTileSize; From e5a950fd48e36e8e7ba9ce59653fbfdfa1d2e6de Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Mon, 21 Jul 2025 16:41:38 -0500 Subject: [PATCH 04/28] converted RenderableLayer and all inherited classes into proper flame Components --- .../src/renderable_layers/group_layer.dart | 30 +++---- .../src/renderable_layers/image_layer.dart | 11 +-- .../src/renderable_layers/object_layer.dart | 16 ++-- .../renderable_layers/renderable_layer.dart | 80 ++++++++++--------- .../tile_layers/hexagonal_tile_layer.dart | 1 + .../tile_layers/isometric_tile_layer.dart | 1 + .../tile_layers/orthogonal_tile_layer.dart | 1 + .../tile_layers/staggered_tile_layer.dart | 1 + .../tile_layers/tile_layer.dart | 21 +++-- .../lib/src/renderable_tile_map.dart | 68 +++++++++------- .../flame_tiled/lib/src/tiled_component.dart | 28 +------ 11 files changed, 120 insertions(+), 138 deletions(-) diff --git a/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart index ce1d28369d9..497294094ac 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart @@ -1,4 +1,3 @@ -import 'package:flame/components.dart'; import 'package:flame/extensions.dart'; import 'package:flame_tiled/src/renderable_layers/renderable_layer.dart'; import 'package:meta/meta.dart'; @@ -6,15 +5,10 @@ import 'package:tiled/tiled.dart'; @internal class GroupLayer extends RenderableLayer { - /// The child layers of this [Group] to be rendered recursively. - /// - /// NOTE: This is set externally instead of via constructor params because - /// there are cyclic dependencies when loading the renderable layers. - late final List children; - GroupLayer({ required super.layer, required super.parent, + required super.camera, required super.map, required super.destTileSize, super.filterQuality, @@ -22,32 +16,26 @@ class GroupLayer extends RenderableLayer { @override void refreshCache() { - for (final child in children) { - child.refreshCache(); + final sublayers = children.whereType(); + for (final sub in sublayers) { + sub.refreshCache(); } } @override - void handleResize(Vector2 canvasSize) { + void renderTree(Canvas canvas) { + super.render(canvas); for (final child in children) { - child.handleResize(canvasSize); + child.render(canvas); } } @override - void render(Canvas canvas, CameraComponent? camera) { - for (final child in children) { - child.render(canvas, camera); - } - super.render(canvas, camera); - } + void updateTree(double dt) { + super.update(dt); - @override - void update(double dt) { for (final child in children) { child.update(dt); } - - super.update(dt); } } diff --git a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart index a562b21ef49..d0618b92d51 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart @@ -20,6 +20,7 @@ class FlameImageLayer extends RenderableLayer { FlameImageLayer({ required super.layer, required super.parent, + required super.camera, required super.map, required super.destTileSize, required Image image, @@ -29,18 +30,19 @@ class FlameImageLayer extends RenderableLayer { } @override - void handleResize(Vector2 canvasSize) { + void onGameResize(Vector2 canvasSize) { + super.onGameResize(canvasSize); _canvasSize.setFrom(canvasSize); } @override - void render(Canvas canvas, CameraComponent? camera) { + void render(Canvas canvas) { canvas.save(); canvas.translate(offsetX, offsetY); if (camera != null) { - applyParallaxOffset(canvas, camera); + applyParallaxOffset(canvas, camera!); } _resizePaintArea(camera); @@ -56,8 +58,6 @@ class FlameImageLayer extends RenderableLayer { ); canvas.restore(); - - super.render(canvas, camera); } void _resizePaintArea(CameraComponent? camera) { @@ -122,6 +122,7 @@ class FlameImageLayer extends RenderableLayer { return FlameImageLayer( layer: layer, parent: parent, + camera: camera, map: map, destTileSize: destTileSize, filterQuality: filterQuality, diff --git a/packages/flame_tiled/lib/src/renderable_layers/object_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/object_layer.dart index a4a9ff620c4..1733d1aa299 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/object_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/object_layer.dart @@ -1,7 +1,6 @@ import 'dart:ui'; import 'package:flame/components.dart'; -import 'package:flame/extensions.dart'; import 'package:flame_tiled/src/renderable_layers/renderable_layer.dart'; import 'package:meta/meta.dart'; import 'package:tiled/tiled.dart'; @@ -11,39 +10,34 @@ class ObjectLayer extends RenderableLayer { ObjectLayer({ required super.layer, required super.parent, + required super.camera, required super.map, required super.destTileSize, super.filterQuality, }); - @override - void render(Canvas canvas, CameraComponent? camera) { - // Nothing to do besides call super. - super.render(canvas, camera); - } - // ignore non-renderable layers when looping over the layers to render @override bool get visible => false; static Future load( ObjectGroup layer, + Component? parent, + CameraComponent? camera, TiledMap map, Vector2 destTileSize, FilterQuality? filterQuality, ) async { return ObjectLayer( layer: layer, - parent: null, + parent: parent, + camera: camera, map: map, destTileSize: destTileSize, filterQuality: filterQuality, ); } - @override - void handleResize(Vector2 canvasSize) {} - @override void refreshCache() {} } diff --git a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart index 34f51c7f361..b8fa44cf71e 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart @@ -12,25 +12,26 @@ import 'package:flame_tiled/src/tile_atlas.dart'; import 'package:meta/meta.dart'; import 'package:tiled/tiled.dart'; -abstract class RenderableLayer { +abstract class RenderableLayer extends PositionComponent + with HasPaint> { final T layer; final Vector2 destTileSize; final TiledMap map; - final List> paintables = []; - - /// The parent [Group] layer (if it exists) - final GroupLayer? parent; + final CameraComponent? camera; /// The [FilterQuality] that should be used by all the layers. final FilterQuality filterQuality; RenderableLayer({ required this.layer, - required this.parent, + required Component? parent, required this.map, + required this.camera, required this.destTileSize, FilterQuality? filterQuality, - }) : filterQuality = filterQuality ?? FilterQuality.none; + }) : filterQuality = filterQuality ?? FilterQuality.none { + this.parent = parent; + } /// [load] is a factory method to create [RenderableLayer] by type of [layer]. static Future load({ @@ -50,6 +51,7 @@ abstract class RenderableLayer { return FlameTileLayer.load( layer: layer, parent: parent, + camera: camera, map: map, destTileSize: destTileSize, animationFrames: animationFrames, @@ -71,6 +73,8 @@ abstract class RenderableLayer { } else if (layer is ObjectGroup) { return ObjectLayer.load( layer, + parent, + camera, map, destTileSize, filterQuality, @@ -80,6 +84,7 @@ abstract class RenderableLayer { return GroupLayer( layer: groupLayer, parent: parent, + camera: camera, map: map, destTileSize: destTileSize, filterQuality: filterQuality, @@ -89,6 +94,7 @@ abstract class RenderableLayer { return UnsupportedLayer( layer: layer, parent: parent, + camera: camera, map: map, destTileSize: destTileSize, ); @@ -96,39 +102,41 @@ abstract class RenderableLayer { bool get visible => layer.visible; - @mustCallSuper - void render(Canvas canvas, CameraComponent? camera) { - for (final p in paintables) { - p.renderTree(canvas); - } - } - - void handleResize(Vector2 canvasSize); - void refreshCache(); - @mustCallSuper - void update(double dt) { - for (final p in paintables) { - p.updateTree(dt); - } - } - - void add(HasPaint paintable) => paintables.add(paintable); - bool remove(HasPaint paintable) => paintables.remove(paintable); - double get scaleX => destTileSize.x / map.tileWidth; double get scaleY => destTileSize.y / map.tileHeight; - late double offsetX = layer.offsetX * scaleX + (parent?.offsetX ?? 0); - - late double offsetY = layer.offsetY * scaleY + (parent?.offsetY ?? 0); + late double offsetX = layer.offsetX * scaleX + + switch (parent) { + final GroupLayer p => p.offsetX, + _ => 0, + }; - late double opacity = layer.opacity * (parent?.opacity ?? 1); + late double offsetY = layer.offsetY * scaleY + + switch (parent) { + final GroupLayer p => p.offsetY, + _ => 0, + }; - late double parallaxX = layer.parallaxX * (parent?.parallaxX ?? 1); - - late double parallaxY = layer.parallaxY * (parent?.parallaxY ?? 1); + @override + late double opacity = layer.opacity * + switch (parent) { + final GroupLayer p => p.opacity, + _ => 1, + }; + + late double parallaxX = layer.parallaxX * + switch (parent) { + final GroupLayer p => p.parallaxX, + _ => 1, + }; + + late double parallaxY = layer.parallaxY * + switch (parent) { + final GroupLayer p => p.parallaxY, + _ => 1, + }; /// Calculates the offset we need to apply to the canvas to compensate for /// parallax positioning and scroll for the layer and the current camera @@ -165,14 +173,12 @@ abstract class RenderableLayer { class UnsupportedLayer extends RenderableLayer { UnsupportedLayer({ required super.layer, - required super.parent, required super.map, + required super.parent, + required super.camera, required super.destTileSize, }); - @override - void handleResize(Vector2 canvasSize) {} - @override void refreshCache() {} } diff --git a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/hexagonal_tile_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/hexagonal_tile_layer.dart index e3f4de0b809..2bfaab7ec2c 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/hexagonal_tile_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/hexagonal_tile_layer.dart @@ -14,6 +14,7 @@ class HexagonalTileLayer extends FlameTileLayer { required super.layer, required super.parent, required super.map, + required super.camera, required super.destTileSize, required super.tiledAtlas, required super.animationFrames, diff --git a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/isometric_tile_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/isometric_tile_layer.dart index f2e1d210911..0d4a7ffd68c 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/isometric_tile_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/isometric_tile_layer.dart @@ -13,6 +13,7 @@ class IsometricTileLayer extends FlameTileLayer { required super.layer, required super.parent, required super.map, + required super.camera, required super.destTileSize, required super.tiledAtlas, required super.animationFrames, diff --git a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/orthogonal_tile_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/orthogonal_tile_layer.dart index a5f22af1417..71fe75cfae1 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/orthogonal_tile_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/orthogonal_tile_layer.dart @@ -13,6 +13,7 @@ class OrthogonalTileLayer extends FlameTileLayer { required super.layer, required super.parent, required super.map, + required super.camera, required super.destTileSize, required super.tiledAtlas, required super.animationFrames, diff --git a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/staggered_tile_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/staggered_tile_layer.dart index 017061a6e6b..ed0cf4a8e7b 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/staggered_tile_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/staggered_tile_layer.dart @@ -13,6 +13,7 @@ class StaggeredTileLayer extends FlameTileLayer { required super.layer, required super.parent, required super.map, + required super.camera, required super.destTileSize, required super.tiledAtlas, required super.animationFrames, diff --git a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart index acbfd1d15c7..66dfd46df87 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart @@ -3,8 +3,6 @@ import 'package:flame/extensions.dart'; import 'package:flame_tiled/flame_tiled.dart'; import 'package:flame_tiled/src/mutable_rect.dart'; import 'package:flame_tiled/src/mutable_transform.dart'; -import 'package:flame_tiled/src/renderable_layers/group_layer.dart'; -import 'package:flame_tiled/src/renderable_layers/renderable_layer.dart'; import 'package:flame_tiled/src/renderable_layers/tile_layers/hexagonal_tile_layer.dart'; import 'package:flame_tiled/src/renderable_layers/tile_layers/isometric_tile_layer.dart'; import 'package:flame_tiled/src/renderable_layers/tile_layers/orthogonal_tile_layer.dart'; @@ -44,6 +42,7 @@ abstract class FlameTileLayer extends RenderableLayer { FlameTileLayer({ required super.layer, required super.parent, + required super.camera, required super.map, required super.destTileSize, required this.tiledAtlas, @@ -56,7 +55,8 @@ abstract class FlameTileLayer extends RenderableLayer { /// {@macro flame_tile_layer} static FlameTileLayer load({ required TileLayer layer, - required GroupLayer? parent, + required Component? parent, + required CameraComponent? camera, required TiledMap map, required Vector2 destTileSize, required Map animationFrames, @@ -76,6 +76,7 @@ abstract class FlameTileLayer extends RenderableLayer { layer: layer, parent: parent, map: map, + camera: camera, destTileSize: destTileSize, tiledAtlas: atlas, animationFrames: animationFrames, @@ -87,6 +88,7 @@ abstract class FlameTileLayer extends RenderableLayer { layer: layer, parent: parent, map: map, + camera: camera, destTileSize: destTileSize, tiledAtlas: atlas, animationFrames: animationFrames, @@ -98,6 +100,7 @@ abstract class FlameTileLayer extends RenderableLayer { layer: layer, parent: parent, map: map, + camera: camera, destTileSize: destTileSize, tiledAtlas: atlas, animationFrames: animationFrames, @@ -109,6 +112,7 @@ abstract class FlameTileLayer extends RenderableLayer { layer: layer, parent: parent, map: map, + camera: camera, destTileSize: destTileSize, tiledAtlas: atlas, animationFrames: animationFrames, @@ -124,12 +128,10 @@ abstract class FlameTileLayer extends RenderableLayer { for (final animation in animations) { animation.update(dt); } - - super.update(dt); } @override - void render(Canvas canvas, CameraComponent? camera) { + void render(Canvas canvas) { if (tiledAtlas.batch == null) { return; } @@ -137,17 +139,12 @@ abstract class FlameTileLayer extends RenderableLayer { canvas.save(); canvas.translate(offsetX, offsetY); if (camera != null) { - applyParallaxOffset(canvas, camera); + applyParallaxOffset(canvas, camera!); } tiledAtlas.batch!.render(canvas, paint: _layerPaint); canvas.restore(); - - super.render(canvas, camera); } - @override - void handleResize(Vector2 canvasSize) {} - @protected void addAnimation(Tile tile, Tileset tileset, MutableRect source) { final frames = animationFrames[tile] ??= () { diff --git a/packages/flame_tiled/lib/src/renderable_tile_map.dart b/packages/flame_tiled/lib/src/renderable_tile_map.dart index 85adeac090a..1b35a3768a8 100644 --- a/packages/flame_tiled/lib/src/renderable_tile_map.dart +++ b/packages/flame_tiled/lib/src/renderable_tile_map.dart @@ -4,6 +4,7 @@ import 'package:flame/cache.dart'; import 'package:flame/components.dart'; import 'package:flame/extensions.dart'; import 'package:flame/flame.dart'; +import 'package:flame/game.dart'; import 'package:flame_tiled/src/flame_tsx_provider.dart'; import 'package:flame_tiled/src/mutable_transform.dart'; import 'package:flame_tiled/src/renderable_layers/group_layer.dart'; @@ -37,7 +38,8 @@ Paint _defaultLayerPaintFactory(double opacity) => /// - [Layer.parallaxY] (only supported if a [CameraComponent] is supplied) /// /// {@endtemplate} -class RenderableTiledMap { +class RenderableTiledMap extends Component + with HasPaint, HasGameReference { /// [TiledMap] instance for this map. final TiledMap map; @@ -73,6 +75,8 @@ class RenderableTiledMap { } else { _backgroundPaint = null; } + + addAll(renderableLayers); } /// Changes the visibility of the corresponding layer, if different @@ -167,7 +171,7 @@ class RenderableTiledMap { // else descend and ask for named children. tiles.addAll( _tileStack( - layer.children, + layer.children.whereType().toList(), x, y, named: named, @@ -368,17 +372,19 @@ class RenderableTiledMap { ); if (layer is Group && renderableLayer is GroupLayer) { - renderableLayer.children = await _renderableLayers( - layer.layers, - renderableLayer, - map, - destTileSize, - camera, - animationFrames, - atlas: atlas, - ignoreFlip: ignoreFlip, - images: images, - layerPaintFactory: layerPaintFactory, + await renderableLayer.addAll( + await _renderableLayers( + layer.layers, + renderableLayer, + map, + destTileSize, + camera, + animationFrames, + atlas: atlas, + ignoreFlip: ignoreFlip, + images: images, + layerPaintFactory: layerPaintFactory, + ), ); } @@ -388,10 +394,21 @@ class RenderableTiledMap { return Future.wait(layerLoaders); } + @override + Future? onLoad() async { + super.onLoad(); + // Automatically use the first attached CameraComponent camera if it's not + // already set.. + camera ??= game.children.query().firstOrNull; + } + /// Handle game resize and propagate it to renderable layers - void handleResize(Vector2 canvasSize) { + @override + void onGameResize(Vector2 canvasSize) { + super.onGameResize(canvasSize); + for (final layer in renderableLayers) { - layer.handleResize(canvasSize); + layer.onGameResize(canvasSize); } } @@ -402,25 +419,22 @@ class RenderableTiledMap { } } - /// Renders each renderable layer in the same order specified by the Tiled map + /// Renders the background and then calls super. + @override void render(Canvas c) { if (_backgroundPaint != null) { c.drawPaint(_backgroundPaint); } - // Paint each layer in reverse order, because the last layers should be - // rendered beneath the first layers - for (final layer in renderableLayers.where((l) => l.visible)) { - layer.render(c, camera); - } + super.render(c); } /// Returns a layer of type [T] with given [name] from all the layers /// of this map. If no such layer is found, null is returned. - T? getLayer(String name) { + L? getLayer(String name) { try { // layerByName will searches recursively starting with tiled.dart v0.8.5 - return map.layerByName(name) as T; + return map.layerByName(name) as L; } on ArgumentError { return null; } @@ -434,15 +448,13 @@ class RenderableTiledMap { final int idx => renderableLayers[idx], }; + @override void update(double dt) { - // First, update animation frames. + // Updatees tile frame animations. for (final frame in animationFrames.values) { frame.update(dt); } - // Then every layer. - for (final layer in renderableLayers) { - layer.update(dt); - } + super.update(dt); } } diff --git a/packages/flame_tiled/lib/src/tiled_component.dart b/packages/flame_tiled/lib/src/tiled_component.dart index 4413935089c..4891b10d791 100644 --- a/packages/flame_tiled/lib/src/tiled_component.dart +++ b/packages/flame_tiled/lib/src/tiled_component.dart @@ -1,6 +1,5 @@ import 'dart:ui'; -import 'package:collection/collection.dart'; import 'package:flame/cache.dart'; import 'package:flame/components.dart'; import 'package:flame/game.dart'; @@ -12,14 +11,14 @@ import 'package:meta/meta.dart'; import 'package:tiled/tiled.dart'; /// {@template _tiled_component} -/// A Flame [Component] to render a Tiled TiledMap. +/// An API to /// /// It uses a preloaded [RenderableTiledMap] to batch rendering calls into /// Sprite Batches. /// {@endtemplate} class TiledComponent extends PositionComponent with HasGameReference { - /// Map instance of this component. + /// Map component instance which manages and draws layers. RenderableTiledMap tileMap; /// This property **cannot** be reassigned at runtime. To make the @@ -66,27 +65,8 @@ class TiledComponent extends PositionComponent ); @override - Future? onLoad() async { - super.onLoad(); - // Automatically use the first attached CameraComponent camera if it's not - // already set.. - tileMap.camera ??= game.children.query().firstOrNull; - } - - @override - void update(double dt) { - tileMap.update(dt); - } - - @override - void render(Canvas canvas) { - tileMap.render(canvas); - } - - @override - void onGameResize(Vector2 size) { - super.onGameResize(size); - tileMap.handleResize(size); + Future onLoad() async { + await add(tileMap); } /// Loads a [TiledComponent] from a file. From b02abb4f30ed139817180c1e909c7364ceb4609c Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Mon, 21 Jul 2025 19:22:11 -0500 Subject: [PATCH 05/28] render fixes. TODO: expose RenderableLayer correctly as a pubic API. --- packages/flame_tiled/lib/flame_tiled.dart | 2 +- .../lib/src/renderable_layers/group_layer.dart | 7 ++++--- .../lib/src/renderable_layers/renderable_layer.dart | 9 +++++++++ 3 files changed, 14 insertions(+), 4 deletions(-) diff --git a/packages/flame_tiled/lib/flame_tiled.dart b/packages/flame_tiled/lib/flame_tiled.dart index 09d9c12ea27..87f71d07e35 100644 --- a/packages/flame_tiled/lib/flame_tiled.dart +++ b/packages/flame_tiled/lib/flame_tiled.dart @@ -4,8 +4,8 @@ export 'package:tiled/tiled.dart'; export 'src/extensions.dart'; export 'src/flame_tsx_provider.dart'; -export 'src/renderable_tile_map.dart'; export 'src/renderable_layers/renderable_layer.dart'; +export 'src/renderable_tile_map.dart'; export 'src/simple_flips.dart'; export 'src/tile_atlas.dart'; export 'src/tiled_component.dart'; diff --git a/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart index 497294094ac..98dec4b6f80 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart @@ -24,10 +24,11 @@ class GroupLayer extends RenderableLayer { @override void renderTree(Canvas canvas) { - super.render(canvas); - for (final child in children) { - child.render(canvas); + if (visible == false) { + return; } + + super.renderTree(canvas); } @override diff --git a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart index b8fa44cf71e..4095608783e 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart @@ -167,6 +167,15 @@ abstract class RenderableLayer extends PositionComponent canvas.translate(x, y); } + + // Only render if this layer is [visible]. + @override + void renderTree(Canvas c) { + if (!visible) { + return; + } + super.renderTree(c); + } } @internal From f26d1892b3641c75d69d4eb5faed51ee9b80b2f4 Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Mon, 21 Jul 2025 22:47:37 -0500 Subject: [PATCH 06/28] fixing @internal lib conflcit warning --- .../src/renderable_layers/renderable_layer.dart | 16 +--------------- .../tile_layers/unsupported_layer.dart | 17 +++++++++++++++++ .../lib/src/renderable_tile_map.dart | 2 +- 3 files changed, 19 insertions(+), 16 deletions(-) create mode 100644 packages/flame_tiled/lib/src/renderable_layers/tile_layers/unsupported_layer.dart diff --git a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart index 4095608783e..28b3ad63ca0 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart @@ -7,9 +7,9 @@ import 'package:flame_tiled/src/renderable_layers/group_layer.dart'; import 'package:flame_tiled/src/renderable_layers/image_layer.dart'; import 'package:flame_tiled/src/renderable_layers/object_layer.dart'; import 'package:flame_tiled/src/renderable_layers/tile_layers/tile_layer.dart'; +import 'package:flame_tiled/src/renderable_layers/tile_layers/unsupported_layer.dart'; import 'package:flame_tiled/src/tile_animation.dart'; import 'package:flame_tiled/src/tile_atlas.dart'; -import 'package:meta/meta.dart'; import 'package:tiled/tiled.dart'; abstract class RenderableLayer extends PositionComponent @@ -177,17 +177,3 @@ abstract class RenderableLayer extends PositionComponent super.renderTree(c); } } - -@internal -class UnsupportedLayer extends RenderableLayer { - UnsupportedLayer({ - required super.layer, - required super.map, - required super.parent, - required super.camera, - required super.destTileSize, - }); - - @override - void refreshCache() {} -} diff --git a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/unsupported_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/unsupported_layer.dart new file mode 100644 index 00000000000..9ba0c916aa3 --- /dev/null +++ b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/unsupported_layer.dart @@ -0,0 +1,17 @@ +import 'package:flame_tiled/flame_tiled.dart'; +import 'package:meta/meta.dart'; + +// Represents a [RenderableLayer] that cannot be parsed by this package. +@internal +class UnsupportedLayer extends RenderableLayer { + UnsupportedLayer({ + required super.layer, + required super.map, + required super.parent, + required super.camera, + required super.destTileSize, + }); + + @override + void refreshCache() {} +} diff --git a/packages/flame_tiled/lib/src/renderable_tile_map.dart b/packages/flame_tiled/lib/src/renderable_tile_map.dart index 1b35a3768a8..3b8c343ff17 100644 --- a/packages/flame_tiled/lib/src/renderable_tile_map.dart +++ b/packages/flame_tiled/lib/src/renderable_tile_map.dart @@ -396,7 +396,7 @@ class RenderableTiledMap extends Component @override Future? onLoad() async { - super.onLoad(); + await super.onLoad(); // Automatically use the first attached CameraComponent camera if it's not // already set.. camera ??= game.children.query().firstOrNull; From 16299353fd4fe3514825548598bf1ea950a18485 Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Tue, 22 Jul 2025 19:53:48 -0500 Subject: [PATCH 07/28] updated change log --- packages/flame_tiled/CHANGELOG.md | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/packages/flame_tiled/CHANGELOG.md b/packages/flame_tiled/CHANGELOG.md index a77b8a04ea0..d676f17b412 100644 --- a/packages/flame_tiled/CHANGELOG.md +++ b/packages/flame_tiled/CHANGELOG.md @@ -1,3 +1,13 @@ +## 1.21.1 + +- **FEAT**: Enable Tiled layers to respect component ordering for overlays and underlays. e.g. Foreground tiles obsuring sprites. +- `RenderableLayer` is now a part of the public API. +- `RenderableLayer` is now a `Component`. All rendering and update methods modified to integrate naturally into the Flame lifecycle. +- `RenderableTiledMap` has method `RenderableLayer? getRenderableLayer(String name)` to return the Flame component by name. + - e.g. `mapComponent.tileMap.getRenderableLayer('Ground')` +- Expanded the example map to be larger and placed coins beneath one of the layers to demonstrate this effect. +- Adjusted the camera move effect to better show-case this example map as the previous one poorly scrolled too far away. + ## 1.21.0 - **FEAT**: Add a getter for images cache keys ([#3324](https://github.com/flame-engine/flame/issues/3324)). ([7746f2f8](https://github.com/flame-engine/flame/commit/7746f2f867092c19222a40aec2b66dc80558dccb)) From 7ec043293c2d3542505d0aeaa5632e7ceaba590b Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Tue, 22 Jul 2025 20:32:23 -0500 Subject: [PATCH 08/28] PR draft personal review of code caught typos. --- packages/flame_tiled/CHANGELOG.md | 4 ++-- packages/flame_tiled/lib/src/renderable_tile_map.dart | 2 +- packages/flame_tiled/lib/src/tiled_component.dart | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/packages/flame_tiled/CHANGELOG.md b/packages/flame_tiled/CHANGELOG.md index d676f17b412..c607d42c02a 100644 --- a/packages/flame_tiled/CHANGELOG.md +++ b/packages/flame_tiled/CHANGELOG.md @@ -1,8 +1,8 @@ ## 1.21.1 -- **FEAT**: Enable Tiled layers to respect component ordering for overlays and underlays. e.g. Foreground tiles obsuring sprites. +- **FEAT**: Enable Tiled layers to respect component ordering for overlays and underlays. e.g. Foreground tiles obscure sprites. - `RenderableLayer` is now a part of the public API. -- `RenderableLayer` is now a `Component`. All rendering and update methods modified to integrate naturally into the Flame lifecycle. +- `RenderableLayer` is now a `Component` with `HasPaint` and `Position` traits. All render and update methods modified to integrate naturally into the Flame lifecycle. - `RenderableTiledMap` has method `RenderableLayer? getRenderableLayer(String name)` to return the Flame component by name. - e.g. `mapComponent.tileMap.getRenderableLayer('Ground')` - Expanded the example map to be larger and placed coins beneath one of the layers to demonstrate this effect. diff --git a/packages/flame_tiled/lib/src/renderable_tile_map.dart b/packages/flame_tiled/lib/src/renderable_tile_map.dart index 3b8c343ff17..452e50c0064 100644 --- a/packages/flame_tiled/lib/src/renderable_tile_map.dart +++ b/packages/flame_tiled/lib/src/renderable_tile_map.dart @@ -450,7 +450,7 @@ class RenderableTiledMap extends Component @override void update(double dt) { - // Updatees tile frame animations. + // Update any Tiled animations for tiles. for (final frame in animationFrames.values) { frame.update(dt); } diff --git a/packages/flame_tiled/lib/src/tiled_component.dart b/packages/flame_tiled/lib/src/tiled_component.dart index 4891b10d791..c6825494959 100644 --- a/packages/flame_tiled/lib/src/tiled_component.dart +++ b/packages/flame_tiled/lib/src/tiled_component.dart @@ -11,7 +11,7 @@ import 'package:meta/meta.dart'; import 'package:tiled/tiled.dart'; /// {@template _tiled_component} -/// An API to +/// A Flame [Component] to render a Tiled TiledMap. /// /// It uses a preloaded [RenderableTiledMap] to batch rendering calls into /// Sprite Batches. From 303fba047325d693e4006316137ac315b1ede409 Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Fri, 25 Jul 2025 14:05:56 -0500 Subject: [PATCH 09/28] object layers draw themselves. Now all layers are added to enderableLayers even if isible is false. While, invisible layers will not draw, they will load as expected. --- .../flame_tiled/lib/src/renderable_layers/group_layer.dart | 2 +- .../flame_tiled/lib/src/renderable_layers/object_layer.dart | 4 ---- packages/flame_tiled/lib/src/renderable_tile_map.dart | 4 +--- packages/flame_tiled/test/tiled_test.dart | 3 +++ 4 files changed, 5 insertions(+), 8 deletions(-) diff --git a/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart index 98dec4b6f80..e1f1087d329 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart @@ -24,7 +24,7 @@ class GroupLayer extends RenderableLayer { @override void renderTree(Canvas canvas) { - if (visible == false) { + if (!visible) { return; } diff --git a/packages/flame_tiled/lib/src/renderable_layers/object_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/object_layer.dart index 1733d1aa299..7516e5da5bd 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/object_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/object_layer.dart @@ -16,10 +16,6 @@ class ObjectLayer extends RenderableLayer { super.filterQuality, }); - // ignore non-renderable layers when looping over the layers to render - @override - bool get visible => false; - static Future load( ObjectGroup layer, Component? parent, diff --git a/packages/flame_tiled/lib/src/renderable_tile_map.dart b/packages/flame_tiled/lib/src/renderable_tile_map.dart index 452e50c0064..03e299b177b 100644 --- a/packages/flame_tiled/lib/src/renderable_tile_map.dart +++ b/packages/flame_tiled/lib/src/renderable_tile_map.dart @@ -355,9 +355,7 @@ class RenderableTiledMap extends Component bool? ignoreFlip, Images? images, }) { - final visibleLayers = layers.where((layer) => layer.visible); - - final layerLoaders = visibleLayers.map((layer) async { + final layerLoaders = layers.map((layer) async { final renderableLayer = await RenderableLayer.load( layer: layer, parent: parent, diff --git a/packages/flame_tiled/test/tiled_test.dart b/packages/flame_tiled/test/tiled_test.dart index cf4afcf1762..b82530a5784 100644 --- a/packages/flame_tiled/test/tiled_test.dart +++ b/packages/flame_tiled/test/tiled_test.dart @@ -24,6 +24,7 @@ void main() { /// RGBA [255, 255, 0 255] => Yellow. const pixel = 4; TestWidgetsFlutterBinding.ensureInitialized(); + final game = FlameGame(); setUp(TiledAtlas.atlasMap.clear); group('TiledComponent', () { @@ -169,6 +170,8 @@ void main() { bundle: bundle, images: Images(bundle: bundle), ); + await game.add(overlapMap); + final canvasRecorder = PictureRecorder(); final canvas = Canvas(canvasRecorder); overlapMap.render(canvas); From 7767b89535f6833935fdd67e0537f8c23f660c5c Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Fri, 25 Jul 2025 22:48:10 -0500 Subject: [PATCH 10/28] fixed all tests except for orthogonal: parallax effect is not being captured. All other 'failing' reports are < 1% error difference! --- .../src/renderable_layers/group_layer.dart | 18 -- .../src/renderable_layers/image_layer.dart | 6 +- .../renderable_layers/renderable_layer.dart | 22 +- .../tile_layers/tile_layer.dart | 4 +- .../flame_tiled/lib/src/tiled_component.dart | 3 + packages/flame_tiled/pubspec.yaml | 1 + .../test/assets/images/map-level1.png | Bin 0 -> 3059 bytes .../flame_tiled/test/test_image_utils.dart | 2 +- packages/flame_tiled/test/tiled_test.dart | 245 +++++++++++------- 9 files changed, 172 insertions(+), 129 deletions(-) create mode 100644 packages/flame_tiled/test/assets/images/map-level1.png diff --git a/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart index e1f1087d329..24a0b7326b3 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart @@ -21,22 +21,4 @@ class GroupLayer extends RenderableLayer { sub.refreshCache(); } } - - @override - void renderTree(Canvas canvas) { - if (!visible) { - return; - } - - super.renderTree(canvas); - } - - @override - void updateTree(double dt) { - super.update(dt); - - for (final child in children) { - child.update(dt); - } - } } diff --git a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart index d0618b92d51..34bd1fe4617 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart @@ -40,11 +40,7 @@ class FlameImageLayer extends RenderableLayer { canvas.save(); canvas.translate(offsetX, offsetY); - - if (camera != null) { - applyParallaxOffset(canvas, camera!); - } - + //applyParallaxOffset(canvas); _resizePaintArea(camera); paintImage( diff --git a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart index 28b3ad63ca0..2a97e14b775 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart @@ -120,7 +120,8 @@ abstract class RenderableLayer extends PositionComponent }; @override - late double opacity = layer.opacity * + double get opacity => + layer.opacity * switch (parent) { final GroupLayer p => p.opacity, _ => 1, @@ -142,12 +143,12 @@ abstract class RenderableLayer extends PositionComponent /// parallax positioning and scroll for the layer and the current camera /// position. /// https://doc.mapeditor.org/en/latest/manual/layers/#parallax-scrolling-factor - void applyParallaxOffset(Canvas canvas, CameraComponent camera) { - final anchor = camera.viewfinder.anchor; - final cameraX = camera.viewfinder.position.x; - final cameraY = camera.viewfinder.position.y; - final viewportCenterX = camera.viewport.size.x * anchor.x; - final viewportCenterY = camera.viewport.size.y * anchor.y; + void applyParallaxOffset(Canvas canvas) { + final anchor = camera?.viewfinder.anchor ?? Anchor.center; + final cameraX = camera?.viewfinder.position.x ?? 0.0; + final cameraY = camera?.viewfinder.position.y ?? 0.0; + final viewportCenterX = camera?.viewport.size.x ?? 0.0 * anchor.x; + final viewportCenterY = camera?.viewport.size.y ?? 0.0 * anchor.y; // Due to how Tiled treats the center of the view as the reference // point for parallax positioning (see Tiled docs), we need to offset the @@ -155,8 +156,8 @@ abstract class RenderableLayer extends PositionComponent var x = (1 - parallaxX) * viewportCenterX; var y = (1 - parallaxY) * viewportCenterY; // Compensate the offset for zoom. - x /= camera.viewfinder.zoom; - y /= camera.viewfinder.zoom; + x /= camera?.viewfinder.zoom ?? 1.0; + y /= camera?.viewfinder.zoom ?? 1.0; // Scale to tile space. x /= destTileSize.x; y /= destTileSize.y; @@ -174,6 +175,9 @@ abstract class RenderableLayer extends PositionComponent if (!visible) { return; } + c.save(); + applyParallaxOffset(c); super.renderTree(c); + c.restore(); } } diff --git a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart index 66dfd46df87..72154459bd7 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart @@ -138,9 +138,7 @@ abstract class FlameTileLayer extends RenderableLayer { canvas.save(); canvas.translate(offsetX, offsetY); - if (camera != null) { - applyParallaxOffset(canvas, camera!); - } + //applyParallaxOffset(canvas); tiledAtlas.batch!.render(canvas, paint: _layerPaint); canvas.restore(); } diff --git a/packages/flame_tiled/lib/src/tiled_component.dart b/packages/flame_tiled/lib/src/tiled_component.dart index c6825494959..358c51d04e5 100644 --- a/packages/flame_tiled/lib/src/tiled_component.dart +++ b/packages/flame_tiled/lib/src/tiled_component.dart @@ -66,6 +66,9 @@ class TiledComponent extends PositionComponent @override Future onLoad() async { + await super.onLoad(); + + // Add our renderable tile map await add(tileMap); } diff --git a/packages/flame_tiled/pubspec.yaml b/packages/flame_tiled/pubspec.yaml index 8738043db87..ea94b8b19e7 100644 --- a/packages/flame_tiled/pubspec.yaml +++ b/packages/flame_tiled/pubspec.yaml @@ -27,6 +27,7 @@ dependencies: dev_dependencies: dartdoc: ^8.0.8 flame_lint: ^1.2.1 + flame_test: ^1.17.2 flutter_test: sdk: flutter test: any diff --git a/packages/flame_tiled/test/assets/images/map-level1.png b/packages/flame_tiled/test/assets/images/map-level1.png new file mode 100644 index 0000000000000000000000000000000000000000..541b07a59a88b16dc03efcf872fd201a90347ea6 GIT binary patch literal 3059 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 renderMapToPng( ) async { final canvasRecorder = PictureRecorder(); final canvas = Canvas(canvasRecorder); - component.tileMap.render(canvas); + component.tileMap.renderTree(canvas); final picture = canvasRecorder.endRecording(); final size = component.size; diff --git a/packages/flame_tiled/test/tiled_test.dart b/packages/flame_tiled/test/tiled_test.dart index b82530a5784..dd980d4d52f 100644 --- a/packages/flame_tiled/test/tiled_test.dart +++ b/packages/flame_tiled/test/tiled_test.dart @@ -5,15 +5,20 @@ import 'package:flame/components.dart'; import 'package:flame/extensions.dart'; import 'package:flame/flame.dart'; import 'package:flame/game.dart'; +import 'package:flame_test/flame_test.dart'; import 'package:flame_tiled/flame_tiled.dart'; import 'package:flame_tiled/src/renderable_layers/tile_layers/tile_layer.dart'; import 'package:flutter/services.dart'; -import 'package:flutter_test/flutter_test.dart'; +import 'package:flutter_test/flutter_test.dart' + hide expect, group, setUp, isInstanceOf, expectLater; +import 'package:test/test.dart'; import 'test_asset_bundle.dart'; import 'test_image_utils.dart'; void main() { + TestWidgetsFlutterBinding.ensureInitialized(); + /// This represents the byte count of one pixel. /// /// Usually, Color is represented as [Uint8List] and Uint8 has the ability to @@ -23,42 +28,50 @@ void main() { /// RGBA [255, 0, 0 255] => red, /// RGBA [255, 255, 0 255] => Yellow. const pixel = 4; - TestWidgetsFlutterBinding.ensureInitialized(); - final game = FlameGame(); - - setUp(TiledAtlas.atlasMap.clear); group('TiledComponent', () { late TiledComponent tiled; - setUp(() async { + Future setUp(FlameGame game) async { Flame.bundle = TestAssetBundle( imageNames: ['map-level1.png', 'image1.png'], stringNames: ['map.tmx', 'tiles_custom_path/map_custom_path.tmx'], ); - tiled = await TiledComponent.load('map.tmx', Vector2.all(16)); - }); + tiled = await TiledComponent.load( + 'map.tmx', + Vector2.all(16), + images: Images(bundle: Flame.bundle), + ); + } - test('correct loads the file', () { + testWithFlameGame('correct loads the file', (game) async { + await setUp(game); expect(tiled.tileMap.renderableLayers.length, equals(4)); }); - test('component atlases returns the loaded atlases', () { + testWithFlameGame('component atlases returns the loaded atlases', + (game) async { + await setUp(game); final atlases = tiled.atlases(); expect(atlases, hasLength(1)); expect(atlases.first.$1, equals('map-level1.png')); }); - test('correct loads the file, with different prefix', () async { + testWithFlameGame('correct loads the file, with different prefix', + (game) async { + await setUp(game); tiled = await TiledComponent.load( 'map_custom_path.tmx', Vector2.all(16), prefix: 'assets/tiles/tiles_custom_path/', + images: Images(bundle: Flame.bundle), ); expect(tiled.tileMap.renderableLayers.length, equals(3)); }); group('is positionable', () { - test('size, width, and height are readable - not writable', () { + testWithFlameGame('size, width, and height are readable - not writable', + (game) async { + await setUp(game); expect(tiled.size, Vector2(512.0, 2048.0)); expect(tiled.width, 512); expect(tiled.height, 2048); @@ -71,7 +84,7 @@ void main() { expect(tiled.size, Vector2(512.0, 2048.0)); }); - test('from constructor', () { + testWithFlameGame('from constructor', (game) async { final map = TiledComponent( tiled.tileMap, position: Vector2(10, 20), @@ -92,7 +105,7 @@ void main() { }); }); - test('correctly loads external tileset', () async { + testWithFlameGame('correctly loads external tileset', (game) async { // Flame.bundle is a global static. Updating these in tests can lead to // odd errors if you're trying to debug. Flame.bundle = TestAssetBundle( @@ -120,7 +133,8 @@ void main() { ); }); - test('correctly loads external tileset with custom path', () async { + testWithFlameGame('correctly loads external tileset with custom path', + (game) async { // Flame.bundle is a global static. Updating these in tests can lead to // odd errors if you're trying to debug. Flame.bundle = TestAssetBundle( @@ -156,7 +170,8 @@ void main() { group('Layered tiles render correctly with layered sprite batch', () { late Uint8List canvasPixelData; late RenderableTiledMap overlapMap; - setUp(() async { + + Future setUp(FlameGame game) async { final bundle = TestAssetBundle( imageNames: [ 'green_sprite.png', @@ -171,31 +186,34 @@ void main() { images: Images(bundle: bundle), ); await game.add(overlapMap); + await game.ready(); final canvasRecorder = PictureRecorder(); final canvas = Canvas(canvasRecorder); - overlapMap.render(canvas); + overlapMap.renderTree(canvas); final picture = canvasRecorder.endRecording(); final image = await picture.toImageSafe(32, 16); final bytes = await image.toByteData(); canvasPixelData = bytes!.buffer.asUint8List(); - }); + } - test( - 'Correctly loads batches list', - () => expect(overlapMap.renderableLayers.length == 2, true), - ); + testWithFlameGame('Correctly loads batches list', (game) async { + await setUp(game); + expect(overlapMap.renderableLayers.length == 2, true); + }); - test( - 'Canvas pixel dimensions match', - () => expect( + testWithFlameGame('Canvas pixel dimensions match', (game) async { + await setUp(game); + expect( canvasPixelData.length == 16 * 32 * pixel, true, - ), - ); + ); + }); + + testWithFlameGame('Base test - right tile pixel is red', (game) async { + await setUp(game); - test('Base test - right tile pixel is red', () { expect( canvasPixelData[16 * pixel] == 255 && canvasPixelData[(16 * pixel) + 1] == 0 && @@ -218,7 +236,9 @@ void main() { expect(allRed, true); }); - test('Left tile pixel is green', () { + testWithFlameGame('Left tile pixel is green', (game) async { + await setUp(game); + expect( canvasPixelData[15 * pixel] == 0 && canvasPixelData[(15 * pixel) + 1] == 255 && @@ -251,7 +271,7 @@ void main() { Future renderMap() async { final canvasRecorder = PictureRecorder(); final canvas = Canvas(canvasRecorder); - overlapMap.render(canvas); + overlapMap.renderTree(canvas); final picture = canvasRecorder.endRecording(); final image = await picture.toImageSafe(64, 32); @@ -259,7 +279,7 @@ void main() { return bytes!.buffer.asUint8List(); } - setUp(() async { + Future setUp(FlameGame game) async { final bundle = TestAssetBundle( imageNames: [ '4_color_sprite.png', @@ -272,13 +292,18 @@ void main() { bundle: bundle, images: Images(bundle: bundle), ); - + await game.add(overlapMap); + await game.ready(); pixelsBeforeFlipApplied = await renderMap(); await Flame.images.ready(); pixelsAfterFlipApplied = await renderMap(); - }); + } + + testWithFlameGame( + '[useAtlas = true] Green tile pixels are in correct spots', + (game) async { + await setUp(game); - test('[useAtlas = true] Green tile pixels are in correct spots', () { const oneColorRect = 8; final leftTilePixels = []; for (var i = 65 * oneColorRect * pixel; @@ -314,7 +339,11 @@ void main() { expect(allGreen, true); }); - test('[useAtlas = false] Green tile pixels are in correct spots', () { + testWithFlameGame( + '[useAtlas = false] Green tile pixels are in correct spots', + (game) async { + await setUp(game); + final leftTilePixels = []; for (var i = 65 * 8 * pixel; i < ((64 * 23) + (8 * 3)) * pixel; @@ -381,13 +410,13 @@ void main() { rendered = await renderMapToPng(tiledComponent); } - test('flip works with [ignoreFlip = false]', () async { + testWithFlameGame('flip works with [ignoreFlip = false]', (game) async { await prepareForGolden(ignoreFlip: false); expect(texture, matchesGoldenFile('goldens/texture_with_flip.png')); expect(rendered, matchesGoldenFile('goldens/rendered_with_flip.png')); }); - test('flip ignored with [ignoreFlip = true]', () async { + testWithFlameGame('flip ignored with [ignoreFlip = true]', (game) async { await prepareForGolden(ignoreFlip: true); expect( texture, @@ -402,7 +431,7 @@ void main() { group('Test getLayer:', () { late RenderableTiledMap renderableTiledMap; - setUp(() async { + Future setUp(FlameGame game) async { Flame.bundle = TestAssetBundle( imageNames: ['map-level1.png'], stringNames: ['layers_test.tmx'], @@ -411,38 +440,44 @@ void main() { 'layers_test.tmx', Vector2.all(32), bundle: Flame.bundle, + images: Images(bundle: Flame.bundle), ); - }); + } - test('Get Tile Layer', () { + testWithFlameGame('Get Tile Layer', (game) async { + await setUp(game); expect( renderableTiledMap.getLayer('MyTileLayer'), isNotNull, ); }); - test('Get Object Layer', () { + testWithFlameGame('Get Object Layer', (game) async { + await setUp(game); expect( renderableTiledMap.getLayer('MyObjectLayer'), isNotNull, ); }); - test('Get Image Layer', () { + testWithFlameGame('Get Image Layer', (game) async { + await setUp(game); expect( renderableTiledMap.getLayer('MyImageLayer'), isNotNull, ); }); - test('Get Group Layer', () { + testWithFlameGame('Get Group Layer', (game) async { + await setUp(game); expect( renderableTiledMap.getLayer('MyGroupLayer'), isNotNull, ); }); - test('Get no layer', () { + testWithFlameGame('Get no layer', (game) async { + await setUp(game); expect( renderableTiledMap.getLayer('Nonexistent layer'), isNull, @@ -454,7 +489,7 @@ void main() { late TiledComponent component; final mapSizePx = Vector2(32 * 16, 128 * 16); - setUp(() async { + Future setUp(FlameGame game) async { Flame.bundle = TestAssetBundle( imageNames: [ 'image1.png', @@ -462,36 +497,36 @@ void main() { ], stringNames: ['map.tmx'], ); + component = await TiledComponent.load( 'map.tmx', Vector2(16, 16), bundle: Flame.bundle, + images: Images(bundle: Flame.bundle), ); // Need to initialize a game and call `onLoad` and `onGameResize` to // get the camera and canvas sizes all initialized - final game = FlameGame(); game.onGameResize(mapSizePx); final camera = game.camera; - game.world.add(component); + await game.world.add(component); camera.viewfinder.position = Vector2(150, 20); camera.viewport.size = mapSizePx.clone(); game.onGameResize(mapSizePx); - component.onGameResize(mapSizePx); - await component.onLoad(); await game.ready(); - }); + } - test('component size', () { + testWithFlameGame('component size', (game) async { + await setUp(game); expect(component.tileMap.destTileSize, Vector2(16, 16)); expect(component.size, mapSizePx); }); - test( + testWithFlameGame( 'renders', - () async { + (game) async { + await setUp(game); final pngData = await renderMapToPng(component); - expect(pngData, matchesGoldenFile('goldens/orthogonal.png')); }, ); @@ -500,27 +535,30 @@ void main() { group('isometric', () { late TiledComponent component; - setUp(() async { + Future setUp(FlameGame game) async { final bundle = TestAssetBundle( imageNames: [ 'isometric_spritesheet.png', ], stringNames: ['test_isometric.tmx'], ); + component = await TiledComponent.load( 'test_isometric.tmx', Vector2(256 / 4, 128 / 4), bundle: bundle, images: Images(bundle: bundle), ); - }); + } - test('component size', () { + testWithFlameGame('component size', (game) async { + await setUp(game); expect(component.tileMap.destTileSize, Vector2(64, 32)); expect(component.size, Vector2(320, 160)); }); - test('renders', () async { + testWithFlameGame('renders', (game) async { + await setUp(game); // Map size is now 320 wide, but it has 1 extra tile of height because // its actually double-height tiles. final pngData = await renderMapToPng(component); @@ -551,7 +589,7 @@ void main() { ); } - test('flat + even staggered', () async { + testWithFlameGame('flat + even staggered', (game) async { await setupMap( 'flat_hex_even.tmx', 'Tileset_Hexagonal_FlatTop_60x39_60x60.png', @@ -565,7 +603,7 @@ void main() { expect(pngData, matchesGoldenFile('goldens/flat_hex_even.png')); }); - test('flat + odd staggered', () async { + testWithFlameGame('flat + odd staggered', (game) async { await setupMap( 'flat_hex_odd.tmx', 'Tileset_Hexagonal_FlatTop_60x39_60x60.png', @@ -579,7 +617,7 @@ void main() { expect(pngData, matchesGoldenFile('goldens/flat_hex_odd.png')); }); - test('pointy + even staggered', () async { + testWithFlameGame('pointy + even staggered', (game) async { await setupMap( 'pointy_hex_even.tmx', 'Tileset_Hexagonal_PointyTop_60x52_60x80.png', @@ -593,7 +631,7 @@ void main() { expect(pngData, matchesGoldenFile('goldens/pointy_hex_even.png')); }); - test('pointy + odd staggered', () async { + testWithFlameGame('pointy + odd staggered', (game) async { await setupMap( 'pointy_hex_odd.tmx', 'Tileset_Hexagonal_PointyTop_60x52_60x80.png', @@ -630,7 +668,7 @@ void main() { ); } - test('tile offset hexagonal', () async { + testWithFlameGame('tile offset hexagonal', (game) async { await setupMap( // flame tiled currently does not support hexagon side length property, // to use export from Tiled, tweak that value @@ -649,7 +687,7 @@ void main() { ); }); - test('tile offset isometric', () async { + testWithFlameGame('tile offset isometric', (game) async { await setupMap( 'test_tile_offset_isometric.tmx', '4_color_sprite.png', @@ -666,7 +704,7 @@ void main() { ); }); - test('tile offset orthogonal', () async { + testWithFlameGame('tile offset orthogonal', (game) async { await setupMap( 'test_tile_offset_orthogonal.tmx', '4_color_sprite.png', @@ -683,7 +721,7 @@ void main() { ); }); - test('tile offset staggered', () async { + testWithFlameGame('tile offset staggered', (game) async { await setupMap( 'test_tile_offset_staggered.tmx', '4_color_sprite.png', @@ -723,7 +761,7 @@ void main() { ); } - test('x + odd', () async { + testWithFlameGame('x + odd', (game) async { await setupMap( 'iso_staggered_overlap_x_odd.tmx', 'dirt_atlas.png', @@ -740,7 +778,7 @@ void main() { ); }); - test('x + even + half sized', () async { + testWithFlameGame('x + even + half sized', (game) async { await setupMap( 'iso_staggered_overlap_x_even.tmx', 'dirt_atlas.png', @@ -757,7 +795,7 @@ void main() { ); }); - test('y + odd + half', () async { + testWithFlameGame('y + odd + half', (game) async { await setupMap( 'iso_staggered_overlap_y_odd.tmx', 'dirt_atlas.png', @@ -774,7 +812,7 @@ void main() { ); }); - test('y + even', () async { + testWithFlameGame('y + even', (game) async { await setupMap( 'iso_staggered_overlap_y_even.tmx', 'dirt_atlas.png', @@ -813,7 +851,7 @@ void main() { ); } - test('regular', () async { + testWithFlameGame('regular', (game) async { await setupMap(size); final pngData = await renderMapToPng(component); @@ -823,7 +861,7 @@ void main() { ); }); - test('smaller', () async { + testWithFlameGame('smaller', (game) async { final smallSize = size / 3; await setupMap(smallSize); final pngData = await renderMapToPng(component); @@ -834,7 +872,7 @@ void main() { ); }); - test('larger', () async { + testWithFlameGame('larger', (game) async { final largeSize = size * 2; await setupMap(largeSize); final pngData = await renderMapToPng(component); @@ -850,7 +888,7 @@ void main() { late TiledComponent component; final size = Vector2(256 / 2, 128 / 2); - setUp(() async { + Future setUp(FlameGame game) async { final bundle = TestAssetBundle( imageNames: [ 'isometric_spritesheet.png', @@ -863,8 +901,12 @@ void main() { bundle: bundle, images: Images(bundle: bundle), ); - }); - test('from all layers', () { + await game.add(component); + await game.ready(); + } + + testWithFlameGame('from all layers', (game) async { + await setUp(game); var stack = component.tileMap.tileStack(0, 0, all: true); expect(stack.length, 2); @@ -872,7 +914,8 @@ void main() { expect(stack.length, 1); }); - test('from some layers', () { + testWithFlameGame('from some layers', (game) async { + await setUp(game); var stack = component.tileMap.tileStack(0, 0, named: {'empty'}); expect(stack.length, 0); @@ -886,7 +929,9 @@ void main() { expect(stack.length, 2); }); - test('can be positioned together', () async { + testWithFlameGame('can be positioned together', (game) async { + await setUp(game); + final stack = component.tileMap.tileStack(0, 0, all: true); stack.position = stack.position + Vector2.all(20); @@ -897,7 +942,9 @@ void main() { ); }); - test('can be positioned singularly', () async { + testWithFlameGame('can be positioned singularly', (game) async { + await setUp(game); + final stack = component.tileMap.tileStack(0, 0, named: {'item'}); stack.position = stack.position + Vector2(-20, 20); @@ -921,7 +968,7 @@ void main() { 'staggered', ]) { group(mapType, () { - setUp(() async { + Future setUp(FlameGame game) async { final bundle = TestAssetBundle( imageNames: [ '0x72_DungeonTilesetII_v1.4.png', @@ -935,10 +982,15 @@ void main() { images: Images(bundle: bundle), ); map = component.tileMap; - }); + await game.add(component); + await game.ready(); + } + + testWithFlameGame('handle single frame animations ($mapType)', + (game) async { + await setUp(game); - test('handle single frame animations ($mapType)', () { - expect(map.renderableLayers.first, isInstanceOf()); + expect(map.renderableLayers.first is FlameTileLayer, true); final layer = map.renderableLayers.first as FlameTileLayer; expect( layer.animations, @@ -953,10 +1005,13 @@ void main() { expect(layer.animations.first.frames.sources, hasLength(1)); }); - test('handle single frame animations ($mapType)', () { + testWithFlameGame('handle single frame animations ($mapType)', + (game) async { + await setUp(game); + expect( - map.renderableLayers[1], - isInstanceOf(), + map.renderableLayers[1] is FlameTileLayer, + true, ); final layer = map.renderableLayers[1] as FlameTileLayer; expect( @@ -975,7 +1030,8 @@ void main() { expect(waterAnimation.frames.durations, [0.18, 0.17, 0.15]); expect(spikeAnimation.frames.durations, [0.176, 0.176, 0.176, 0.176]); - map.update(0.177); + game.update(0.177); + expect(waterAnimation.frame, 0); expect(waterAnimation.frames.frameTime, 0.177); expect( @@ -990,13 +1046,13 @@ void main() { spikeAnimation.frames.sources[1], ); - map.update(0.003); + game.update(0.003); expect(waterAnimation.frame, 1); expect(waterAnimation.frames.frameTime, moreOrLessEquals(0.0)); expect(spikeAnimation.frame, 1); expect(spikeAnimation.frames.frameTime, moreOrLessEquals(0.004)); - map.update(0.17 + 0.15); + game.update(0.17 + 0.15); expect(waterAnimation.frame, 0, reason: 'wraps around'); expect( waterAnimation.batchedSource.toRect(), @@ -1006,7 +1062,9 @@ void main() { /// This will not produce a pretty map for non-orthogonal, but that's /// OK, we're looking for parsing and handling of animations. - test('renders ($mapType)', () async { + testWithFlameGame('renders ($mapType)', (game) async { + await setUp(game); + var pngData = await renderMapToPng(component); await expectLater( pngData, @@ -1049,7 +1107,7 @@ void main() { 'staggered', ]) { group(mapType, () { - setUp(() async { + Future setUp(game) async { final bundle = TestAssetBundle( imageNames: [ '0x72_DungeonTilesetII_v1.4.png', @@ -1062,9 +1120,10 @@ void main() { bundle: bundle, images: Images(bundle: bundle), ); - }); + } - test('renders ($mapType)', () async { + testWithFlameGame('renders ($mapType)', (game) async { + await setUp(game); final pngData = await renderMapToPng(component); await expectLater( pngData, From 2d36b26be7a4a5841a9eb3236a05e1541061f688 Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Sun, 27 Jul 2025 09:24:31 -0500 Subject: [PATCH 11/28] camera needs to be passed into the child components in new version of tiled map component. --- packages/flame_tiled/lib/src/tiled_component.dart | 2 ++ 1 file changed, 2 insertions(+) diff --git a/packages/flame_tiled/lib/src/tiled_component.dart b/packages/flame_tiled/lib/src/tiled_component.dart index 358c51d04e5..102ce56cb6d 100644 --- a/packages/flame_tiled/lib/src/tiled_component.dart +++ b/packages/flame_tiled/lib/src/tiled_component.dart @@ -96,6 +96,7 @@ class TiledComponent extends PositionComponent int? priority, bool? ignoreFlip, AssetBundle? bundle, + CameraComponent? camera, Images? images, bool Function(Tileset)? tsxPackingFilter, bool useAtlas = true, @@ -112,6 +113,7 @@ class TiledComponent extends PositionComponent ignoreFlip: ignoreFlip, prefix: prefix, bundle: bundle, + camera: camera, images: images, tsxPackingFilter: tsxPackingFilter, useAtlas: useAtlas, From 63f2d43ec65801b23efeda8432bb180360ed259d Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Tue, 29 Jul 2025 19:47:27 -0500 Subject: [PATCH 12/28] image layer repeat draw behavior now accurate AND optimized --- packages/flame_tiled/example/lib/main.dart | 2 +- .../src/renderable_layers/group_layer.dart | 1 - .../src/renderable_layers/image_layer.dart | 99 +++++++++++++++---- .../renderable_layers/renderable_layer.dart | 14 ++- .../tile_layers/tile_layer.dart | 6 +- packages/flame_tiled/test/tiled_test.dart | 11 +-- 6 files changed, 102 insertions(+), 31 deletions(-) diff --git a/packages/flame_tiled/example/lib/main.dart b/packages/flame_tiled/example/lib/main.dart index 4dbcd24452b..44c34e29beb 100644 --- a/packages/flame_tiled/example/lib/main.dart +++ b/packages/flame_tiled/example/lib/main.dart @@ -37,7 +37,7 @@ class TiledGame extends FlameGame { ); mapComponent = await TiledComponent.load('map.tmx', Vector2.all(16)); - world.add(mapComponent); + await world.add(mapComponent); final objectGroup = mapComponent.tileMap.getLayer('AnimatedCoins'); diff --git a/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart index 24a0b7326b3..026de974687 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart @@ -1,4 +1,3 @@ -import 'package:flame/extensions.dart'; import 'package:flame_tiled/src/renderable_layers/renderable_layer.dart'; import 'package:meta/meta.dart'; import 'package:tiled/tiled.dart'; diff --git a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart index 34bd1fe4617..a8f42a84a4b 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart @@ -8,6 +8,7 @@ import 'package:flame_tiled/src/renderable_layers/renderable_layer.dart'; import 'package:flutter/rendering.dart'; import 'package:meta/meta.dart'; import 'package:tiled/tiled.dart'; +import 'dart:math'; @internal class FlameImageLayer extends RenderableLayer { @@ -38,11 +39,7 @@ class FlameImageLayer extends RenderableLayer { @override void render(Canvas canvas) { canvas.save(); - - canvas.translate(offsetX, offsetY); - //applyParallaxOffset(canvas); _resizePaintArea(camera); - paintImage( canvas: canvas, rect: _paintArea, @@ -60,37 +57,66 @@ class FlameImageLayer extends RenderableLayer { // Track the maximum amount the canvas could have been translated // for this layer so we can calculate how many extra images to draw if (camera != null) { - _maxTranslation.x = - offsetX.abs() + camera.viewfinder.position.x.abs() * parallaxX; - _maxTranslation.y = - offsetY.abs() + camera.viewfinder.position.y.abs() * parallaxY; + _maxTranslation.x = offsetX - camera.viewfinder.position.x * parallaxX; + _maxTranslation.y = offsetY - camera.viewfinder.position.y * parallaxY; } else { - _maxTranslation.x = offsetX.abs(); - _maxTranslation.y = offsetY.abs(); + _maxTranslation.x = offsetX; + _maxTranslation.y = offsetY; } + final virtualSize = camera?.viewport.virtualSize; + final destSize = virtualSize ?? _canvasSize; + final imageW = _image.size.x; + final imageH = _image.size.y; + // When the image is being repeated, make sure the _paintArea rect is // big enough that it repeats off the edge of the canvas in both positive // and negative directions on that axis (Tiled repeats forever on an axis). // Also, make sure the rect's left and top are only moved by exactly the // image's length along that axis (width or height) so that with repeats // it still matches up with its initial layer offsets. - if (_repeat == ImageRepeat.repeatX || _repeat == ImageRepeat.repeat) { - final xImages = (_maxTranslation.x / _image.size.x).ceil(); - _paintArea.left = -_image.size.x * xImages; - _paintArea.right = _canvasSize.x + _image.size.x * xImages; + final (left, right) = _calculatePaintRange( + translation: _maxTranslation.x, + destSize: destSize.x, + imageSideLen: imageW, + ); + _paintArea + ..left = left + ..right = right; + + // The canvas will already be shifted by the parent component's + // render step. Account for this offset to match expectations while + // also respect camera bounds, if any. This prevents scaling the + // painted image down when the window resizes to small values. + final worldRect = camera?.viewfinder.visibleWorldRect ?? Rect.zero; + _paintArea.left += worldRect.left - super.cachedLayerOffset.x; + _paintArea.right += worldRect.right - super.cachedLayerOffset.x; } else { + // Simply draw the full width of the image. _paintArea.left = 0; - _paintArea.right = _canvasSize.x; + _paintArea.right = imageW; } if (_repeat == ImageRepeat.repeatY || _repeat == ImageRepeat.repeat) { - final yImages = (_maxTranslation.y / _image.size.y).ceil(); - _paintArea.top = -_image.size.y * yImages; - _paintArea.bottom = _canvasSize.y + _image.size.y * yImages; + final (top, bottom) = _calculatePaintRange( + translation: _maxTranslation.y, + destSize: destSize.y, + imageSideLen: imageH, + ); + _paintArea + ..top = top + ..bottom = bottom; + // The canvas will already be shifted by the parent component's + // render step. Account for this offset to match expectations while + // also respect camera bounds, if any. This prevents scaling the + // painted image down when the window resizes to small values. + final worldRect = camera?.viewfinder.visibleWorldRect ?? Rect.zero; + _paintArea.top += worldRect.top - super.cachedLayerOffset.y; + _paintArea.bottom += worldRect.bottom - super.cachedLayerOffset.y; } else { + // Simply draw the full height of the image. _paintArea.top = 0; - _paintArea.bottom = _canvasSize.y; + _paintArea.bottom = imageH; } } @@ -106,6 +132,41 @@ class FlameImageLayer extends RenderableLayer { } } + // As an optimization, the [_paintArea] rect can be positioned in a + // particular way that reduces the time spent on computation and clip steps + // in flutter when drawing infinitely across an axis. This method accounts + // for the destination canvas size, camera viewport size, and the exact + // coverage of the image w.r.t. [translation]. + // This is achieved by wrapping the rect coordinates around [destSize] + // after calculating the image coverage with [imageSideLen] and adding the + // unseen portion of the image in the span of the wrap range, if any. + (double min, double max) _calculatePaintRange({ + required double translation, + required double destSize, + required double imageSideLen, + }) { + // What portion of the image is seen. + final seen = destSize / imageSideLen; + + // Integer count of whole images to draw. + final imageCount = seen.ceil(); + + // Calculate unseen part of image(s). + final unseen = (imageCount - seen) * imageSideLen; + + // Wrap around the target axis w.r.t. parallax. + final wrapPoint = translation.ceil() % (destSize + unseen).toInt(); + + // Partition the _paintArea into two parts. + final part = (wrapPoint / imageSideLen).ceil(); + + // Return the range where the centroid is the wrap point. + return ( + wrapPoint - (part * imageSideLen), + wrapPoint + (imageSideLen * (imageCount - part)), + ); + } + static Future load({ required ImageLayer layer, required GroupLayer? parent, diff --git a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart index 2a97e14b775..727f569402d 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart @@ -22,6 +22,11 @@ abstract class RenderableLayer extends PositionComponent /// The [FilterQuality] that should be used by all the layers. final FilterQuality filterQuality; + /// Cached canvas translation used in parallax effects. + /// This field needs to be read in the case of repeated textures + /// as part of an optimization. + Vector2 cachedLayerOffset = Vector2.zero(); + RenderableLayer({ required this.layer, required Component? parent, @@ -147,8 +152,8 @@ abstract class RenderableLayer extends PositionComponent final anchor = camera?.viewfinder.anchor ?? Anchor.center; final cameraX = camera?.viewfinder.position.x ?? 0.0; final cameraY = camera?.viewfinder.position.y ?? 0.0; - final viewportCenterX = camera?.viewport.size.x ?? 0.0 * anchor.x; - final viewportCenterY = camera?.viewport.size.y ?? 0.0 * anchor.y; + final viewportCenterX = (camera?.viewport.virtualSize.x ?? 0.0) * anchor.x; + final viewportCenterY = (camera?.viewport.virtualSize.y ?? 0.0) * anchor.y; // Due to how Tiled treats the center of the view as the reference // point for parallax positioning (see Tiled docs), we need to offset the @@ -166,6 +171,11 @@ abstract class RenderableLayer extends PositionComponent x += cameraX - (cameraX * parallaxX); y += cameraY - (cameraY * parallaxY); + // Apply layer offset. + x += offsetX; + y += offsetY; + + cachedLayerOffset = Vector2(x, y); canvas.translate(x, y); } diff --git a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart index 72154459bd7..8f55f57796a 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart @@ -31,7 +31,9 @@ import 'package:meta/meta.dart'; /// {@endtemplate} @internal abstract class FlameTileLayer extends RenderableLayer { - late final _layerPaint = layerPaintFactory(opacity); + @override + late Paint paint = layerPaintFactory(opacity); + final TiledAtlas tiledAtlas; late List> transforms; final animations = []; @@ -139,7 +141,7 @@ abstract class FlameTileLayer extends RenderableLayer { canvas.save(); canvas.translate(offsetX, offsetY); //applyParallaxOffset(canvas); - tiledAtlas.batch!.render(canvas, paint: _layerPaint); + tiledAtlas.batch!.render(canvas, paint: paint); canvas.restore(); } diff --git a/packages/flame_tiled/test/tiled_test.dart b/packages/flame_tiled/test/tiled_test.dart index dd980d4d52f..471824a1fad 100644 --- a/packages/flame_tiled/test/tiled_test.dart +++ b/packages/flame_tiled/test/tiled_test.dart @@ -498,18 +498,16 @@ void main() { stringNames: ['map.tmx'], ); + final camera = game.camera; component = await TiledComponent.load( 'map.tmx', Vector2(16, 16), bundle: Flame.bundle, images: Images(bundle: Flame.bundle), + camera: camera, ); - // Need to initialize a game and call `onLoad` and `onGameResize` to - // get the camera and canvas sizes all initialized - game.onGameResize(mapSizePx); - final camera = game.camera; - await game.world.add(component); + await game.world.ensureAdd(component); camera.viewfinder.position = Vector2(150, 20); camera.viewport.size = mapSizePx.clone(); game.onGameResize(mapSizePx); @@ -980,9 +978,10 @@ void main() { size, bundle: bundle, images: Images(bundle: bundle), + camera: game.camera, ); map = component.tileMap; - await game.add(component); + await game.ensureAdd(component); await game.ready(); } From 311256efdd43d08ec6f022b727eb7502c1bc5fe0 Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Tue, 29 Jul 2025 20:37:44 -0500 Subject: [PATCH 13/28] cleanup and prettify code --- .../src/renderable_layers/image_layer.dart | 57 +++++++++---------- 1 file changed, 28 insertions(+), 29 deletions(-) diff --git a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart index a8f42a84a4b..a2789a2acbf 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart @@ -8,7 +8,6 @@ import 'package:flame_tiled/src/renderable_layers/renderable_layer.dart'; import 'package:flutter/rendering.dart'; import 'package:meta/meta.dart'; import 'package:tiled/tiled.dart'; -import 'dart:math'; @internal class FlameImageLayer extends RenderableLayer { @@ -64,8 +63,8 @@ class FlameImageLayer extends RenderableLayer { _maxTranslation.y = offsetY; } - final virtualSize = camera?.viewport.virtualSize; - final destSize = virtualSize ?? _canvasSize; + final visibleWorldRect = camera?.visibleWorldRect ?? Rect.zero; + final destSize = camera?.viewport.virtualSize ?? _canvasSize; final imageW = _image.size.x; final imageH = _image.size.y; @@ -77,21 +76,16 @@ class FlameImageLayer extends RenderableLayer { // it still matches up with its initial layer offsets. if (_repeat == ImageRepeat.repeatX || _repeat == ImageRepeat.repeat) { final (left, right) = _calculatePaintRange( - translation: _maxTranslation.x, - destSize: destSize.x, - imageSideLen: imageW, - ); + translation: _maxTranslation.x, + destSize: destSize.x, + imageSideLen: imageW, + layerOffset: cachedLayerOffset.x, + ) + // Apply camera left/right to range. + (visibleWorldRect.left, visibleWorldRect.right); + _paintArea ..left = left ..right = right; - - // The canvas will already be shifted by the parent component's - // render step. Account for this offset to match expectations while - // also respect camera bounds, if any. This prevents scaling the - // painted image down when the window resizes to small values. - final worldRect = camera?.viewfinder.visibleWorldRect ?? Rect.zero; - _paintArea.left += worldRect.left - super.cachedLayerOffset.x; - _paintArea.right += worldRect.right - super.cachedLayerOffset.x; } else { // Simply draw the full width of the image. _paintArea.left = 0; @@ -99,20 +93,16 @@ class FlameImageLayer extends RenderableLayer { } if (_repeat == ImageRepeat.repeatY || _repeat == ImageRepeat.repeat) { final (top, bottom) = _calculatePaintRange( - translation: _maxTranslation.y, - destSize: destSize.y, - imageSideLen: imageH, - ); + translation: _maxTranslation.y, + destSize: destSize.y, + imageSideLen: imageH, + layerOffset: cachedLayerOffset.y, + ) + // Apply camera top/bottom to range. + (visibleWorldRect.top, visibleWorldRect.bottom); + _paintArea ..top = top ..bottom = bottom; - // The canvas will already be shifted by the parent component's - // render step. Account for this offset to match expectations while - // also respect camera bounds, if any. This prevents scaling the - // painted image down when the window resizes to small values. - final worldRect = camera?.viewfinder.visibleWorldRect ?? Rect.zero; - _paintArea.top += worldRect.top - super.cachedLayerOffset.y; - _paintArea.bottom += worldRect.bottom - super.cachedLayerOffset.y; } else { // Simply draw the full height of the image. _paintArea.top = 0; @@ -140,10 +130,15 @@ class FlameImageLayer extends RenderableLayer { // This is achieved by wrapping the rect coordinates around [destSize] // after calculating the image coverage with [imageSideLen] and adding the // unseen portion of the image in the span of the wrap range, if any. + // + // The return tuple value is the range where its centroid is the wrap point + // plus the [layerOffset] which shifts the range to account for earlier + // transformations applied to the canvas. (double min, double max) _calculatePaintRange({ required double translation, required double destSize, required double imageSideLen, + required double layerOffset, }) { // What portion of the image is seen. final seen = destSize / imageSideLen; @@ -160,10 +155,9 @@ class FlameImageLayer extends RenderableLayer { // Partition the _paintArea into two parts. final part = (wrapPoint / imageSideLen).ceil(); - // Return the range where the centroid is the wrap point. return ( - wrapPoint - (part * imageSideLen), - wrapPoint + (imageSideLen * (imageCount - part)), + wrapPoint - (part * imageSideLen) - layerOffset, + wrapPoint + (imageSideLen * (imageCount - part)) - layerOffset, ); } @@ -190,3 +184,8 @@ class FlameImageLayer extends RenderableLayer { @override void refreshCache() {} } + +extension _PrivRangeTupleHelper on (double, double) { + (double, double) operator +((double, double) other) => + ($1 + other.$1, $2 + other.$2); +} From b913f32801e604b89e012afecc94daa8d11584b8 Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Wed, 30 Jul 2025 20:01:41 -0500 Subject: [PATCH 14/28] parallax math almost perfect with what Tiled shows. WYSIWYG. --- .../src/renderable_layers/image_layer.dart | 27 +++++++++++-------- 1 file changed, 16 insertions(+), 11 deletions(-) diff --git a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart index a2789a2acbf..e994071d7d4 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart @@ -53,21 +53,22 @@ class FlameImageLayer extends RenderableLayer { } void _resizePaintArea(CameraComponent? camera) { - // Track the maximum amount the canvas could have been translated - // for this layer so we can calculate how many extra images to draw - if (camera != null) { - _maxTranslation.x = offsetX - camera.viewfinder.position.x * parallaxX; - _maxTranslation.y = offsetY - camera.viewfinder.position.y * parallaxY; - } else { - _maxTranslation.x = offsetX; - _maxTranslation.y = offsetY; - } - final visibleWorldRect = camera?.visibleWorldRect ?? Rect.zero; final destSize = camera?.viewport.virtualSize ?? _canvasSize; final imageW = _image.size.x; final imageH = _image.size.y; + // Track the maximum amount the canvas could have been translated + // for this layer so we can calculate the wrap point within the + // paint area. + _maxTranslation.x = offsetX - (visibleWorldRect.left * parallaxX); + _maxTranslation.y = offsetY - (visibleWorldRect.top * parallaxY); + + /* + _maxTranslation.x = offsetX - camera.viewfinder.position.x * parallaxX; + _maxTranslation.y = offsetY - camera.viewfinder.position.y * parallaxY; +*/ + // When the image is being repeated, make sure the _paintArea rect is // big enough that it repeats off the edge of the canvas in both positive // and negative directions on that axis (Tiled repeats forever on an axis). @@ -140,6 +141,10 @@ class FlameImageLayer extends RenderableLayer { required double imageSideLen, required double layerOffset, }) { + // Prevent DBZ error. + if (imageSideLen < 1) { + return (0, 0); + } // What portion of the image is seen. final seen = destSize / imageSideLen; @@ -156,7 +161,7 @@ class FlameImageLayer extends RenderableLayer { final part = (wrapPoint / imageSideLen).ceil(); return ( - wrapPoint - (part * imageSideLen) - layerOffset, + wrapPoint - (imageSideLen * part) - layerOffset, wrapPoint + (imageSideLen * (imageCount - part)) - layerOffset, ); } From 21b53ff2f773cc722b2988c460b27c8a354b0a8c Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Wed, 13 Aug 2025 18:51:33 -0500 Subject: [PATCH 15/28] stable changes tested in other repos. commiting checkpoint before tests. --- .../src/renderable_layers/image_layer.dart | 7 ++-- .../renderable_layers/renderable_layer.dart | 32 +++++++------------ .../tile_layers/tile_layer.dart | 2 +- .../lib/src/renderable_tile_map.dart | 2 +- 4 files changed, 19 insertions(+), 24 deletions(-) diff --git a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart index e994071d7d4..d996707265f 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart @@ -61,8 +61,10 @@ class FlameImageLayer extends RenderableLayer { // Track the maximum amount the canvas could have been translated // for this layer so we can calculate the wrap point within the // paint area. - _maxTranslation.x = offsetX - (visibleWorldRect.left * parallaxX); - _maxTranslation.y = offsetY - (visibleWorldRect.top * parallaxY); + _maxTranslation.x = cachedLayerOffset.x; + // offsetX; //- (visibleWorldRect.left * parallaxX); + _maxTranslation.y = cachedLayerOffset.y; + // offsetY; //- (visibleWorldRect.top * parallaxY); /* _maxTranslation.x = offsetX - camera.viewfinder.position.x * parallaxX; @@ -190,6 +192,7 @@ class FlameImageLayer extends RenderableLayer { void refreshCache() {} } +/// Provide tuples with addition. extension _PrivRangeTupleHelper on (double, double) { (double, double) operator +((double, double) other) => ($1 + other.$1, $2 + other.$2); diff --git a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart index 727f569402d..e7126dfe778 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart @@ -154,29 +154,21 @@ abstract class RenderableLayer extends PositionComponent final cameraY = camera?.viewfinder.position.y ?? 0.0; final viewportCenterX = (camera?.viewport.virtualSize.x ?? 0.0) * anchor.x; final viewportCenterY = (camera?.viewport.virtualSize.y ?? 0.0) * anchor.y; + final topLeftX = cameraX - viewportCenterX; + final topLeftY = cameraY - viewportCenterY; - // Due to how Tiled treats the center of the view as the reference - // point for parallax positioning (see Tiled docs), we need to offset the - // entire layer - var x = (1 - parallaxX) * viewportCenterX; - var y = (1 - parallaxY) * viewportCenterY; - // Compensate the offset for zoom. - x /= camera?.viewfinder.zoom ?? 1.0; - y /= camera?.viewfinder.zoom ?? 1.0; - // Scale to tile space. - x /= destTileSize.x; - y /= destTileSize.y; - - // Now add the scroll for the current camera position - x += cameraX - (cameraX * parallaxX); - y += cameraY - (cameraY * parallaxY); - - // Apply layer offset. - x += offsetX; - y += offsetY; + final double initOffsetX = viewportCenterX * parallaxX; + final double initOffsetY = viewportCenterY * parallaxY; + + // Use the complement of the parallax coefficient in order to account for + // the camera applying its transformations earlier in the render cycle + // of Flame. This adjustment draws the layers correctly w.r.t. their own + // offset and parallax values. + final double x = offsetX + (cameraX * (1.0 - parallaxX)); + final double y = offsetY + (cameraY * (1.0 - parallaxY)); cachedLayerOffset = Vector2(x, y); - canvas.translate(x, y); + canvas.translate(cachedLayerOffset.x, cachedLayerOffset.y); } // Only render if this layer is [visible]. diff --git a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart index 8f55f57796a..0a5af95c3b7 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart @@ -139,7 +139,7 @@ abstract class FlameTileLayer extends RenderableLayer { } canvas.save(); - canvas.translate(offsetX, offsetY); + //canvas.translate(offsetX, offsetY); //applyParallaxOffset(canvas); tiledAtlas.batch!.render(canvas, paint: paint); canvas.restore(); diff --git a/packages/flame_tiled/lib/src/renderable_tile_map.dart b/packages/flame_tiled/lib/src/renderable_tile_map.dart index 03e299b177b..b028d21d1c2 100644 --- a/packages/flame_tiled/lib/src/renderable_tile_map.dart +++ b/packages/flame_tiled/lib/src/renderable_tile_map.dart @@ -417,7 +417,7 @@ class RenderableTiledMap extends Component } } - /// Renders the background and then calls super. + /// Fills canvas with [_backgroundPaint] and then calls super. @override void render(Canvas c) { if (_backgroundPaint != null) { From 97c85db45eb8487c971eb385693d2de4fc59b908 Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Wed, 13 Aug 2025 22:33:44 -0500 Subject: [PATCH 16/28] fixed the animation tests. the only remaining test to fix is test_shifted.tmx. Also, added an override for field 'paint' at the RenderLayer class so that any layer can have their paint easily modified. --- .../src/renderable_layers/group_layer.dart | 1 + .../src/renderable_layers/image_layer.dart | 3 ++ .../src/renderable_layers/object_layer.dart | 3 ++ .../renderable_layers/renderable_layer.dart | 48 ++++++++++++------- .../tile_layers/tile_layer.dart | 11 +---- .../tile_layers/unsupported_layer.dart | 1 + packages/flame_tiled/test/tiled_test.dart | 10 ++-- 7 files changed, 45 insertions(+), 32 deletions(-) diff --git a/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart index 026de974687..25ad661428d 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart @@ -10,6 +10,7 @@ class GroupLayer extends RenderableLayer { required super.camera, required super.map, required super.destTileSize, + required super.layerPaintFactory, super.filterQuality, }); diff --git a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart index d996707265f..1b41afb8203 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart @@ -24,6 +24,7 @@ class FlameImageLayer extends RenderableLayer { required super.map, required super.destTileSize, required Image image, + required super.layerPaintFactory, super.filterQuality, }) : _image = image { _initImageRepeat(); @@ -174,6 +175,7 @@ class FlameImageLayer extends RenderableLayer { required CameraComponent? camera, required TiledMap map, required Vector2 destTileSize, + required Paint Function(double opacity) layerPaintFactory, FilterQuality? filterQuality, Images? images, }) async { @@ -184,6 +186,7 @@ class FlameImageLayer extends RenderableLayer { map: map, destTileSize: destTileSize, filterQuality: filterQuality, + layerPaintFactory: layerPaintFactory, image: await (images ?? Flame.images).load(layer.image.source!), ); } diff --git a/packages/flame_tiled/lib/src/renderable_layers/object_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/object_layer.dart index 7516e5da5bd..7367e895773 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/object_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/object_layer.dart @@ -13,6 +13,7 @@ class ObjectLayer extends RenderableLayer { required super.camera, required super.map, required super.destTileSize, + required super.layerPaintFactory, super.filterQuality, }); @@ -22,6 +23,7 @@ class ObjectLayer extends RenderableLayer { CameraComponent? camera, TiledMap map, Vector2 destTileSize, + Paint Function(double opacity) layerPaintFactory, FilterQuality? filterQuality, ) async { return ObjectLayer( @@ -30,6 +32,7 @@ class ObjectLayer extends RenderableLayer { camera: camera, map: map, destTileSize: destTileSize, + layerPaintFactory: layerPaintFactory, filterQuality: filterQuality, ); } diff --git a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart index e7126dfe778..5eb05df7e7b 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart @@ -24,15 +24,24 @@ abstract class RenderableLayer extends PositionComponent /// Cached canvas translation used in parallax effects. /// This field needs to be read in the case of repeated textures - /// as part of an optimization. + /// as an optimization step. Vector2 cachedLayerOffset = Vector2.zero(); + /// Given the layer's [opacity], compute [Paint] for drawing. + /// This is useful if your layer requires translucency or other effects. + Paint Function(double opacity) layerPaintFactory; + + /// A read on [paint] will compute the value from [layerPaintFactory]. + @override + Paint get paint => layerPaintFactory(opacity); + RenderableLayer({ required this.layer, required Component? parent, required this.map, required this.camera, required this.destTileSize, + required this.layerPaintFactory, FilterQuality? filterQuality, }) : filterQuality = filterQuality ?? FilterQuality.none { this.parent = parent; @@ -73,6 +82,7 @@ abstract class RenderableLayer extends PositionComponent map: map, destTileSize: destTileSize, filterQuality: filterQuality, + layerPaintFactory: layerPaintFactory, images: images, ); } else if (layer is ObjectGroup) { @@ -82,17 +92,18 @@ abstract class RenderableLayer extends PositionComponent camera, map, destTileSize, + layerPaintFactory, filterQuality, ); } else if (layer is Group) { - final groupLayer = layer; return GroupLayer( - layer: groupLayer, + layer: layer, parent: parent, camera: camera, map: map, destTileSize: destTileSize, filterQuality: filterQuality, + layerPaintFactory: layerPaintFactory, ); } @@ -102,6 +113,7 @@ abstract class RenderableLayer extends PositionComponent camera: camera, map: map, destTileSize: destTileSize, + layerPaintFactory: layerPaintFactory, ); } @@ -149,25 +161,29 @@ abstract class RenderableLayer extends PositionComponent /// position. /// https://doc.mapeditor.org/en/latest/manual/layers/#parallax-scrolling-factor void applyParallaxOffset(Canvas canvas) { - final anchor = camera?.viewfinder.anchor ?? Anchor.center; - final cameraX = camera?.viewfinder.position.x ?? 0.0; - final cameraY = camera?.viewfinder.position.y ?? 0.0; - final viewportCenterX = (camera?.viewport.virtualSize.x ?? 0.0) * anchor.x; - final viewportCenterY = (camera?.viewport.virtualSize.y ?? 0.0) * anchor.y; - final topLeftX = cameraX - viewportCenterX; - final topLeftY = cameraY - viewportCenterY; - - final double initOffsetX = viewportCenterX * parallaxX; - final double initOffsetY = viewportCenterY * parallaxY; + final viewfinder = camera?.viewfinder; + final cameraX = viewfinder?.position.x ?? 0.0; + final cameraY = viewfinder?.position.y ?? 0.0; + final zoom = viewfinder?.zoom ?? 1.0; // Use the complement of the parallax coefficient in order to account for // the camera applying its transformations earlier in the render cycle // of Flame. This adjustment draws the layers correctly w.r.t. their own // offset and parallax values. - final double x = offsetX + (cameraX * (1.0 - parallaxX)); - final double y = offsetY + (cameraY * (1.0 - parallaxY)); - + final viewportCenterX = (camera?.viewport.size.x ?? 0) * anchor.x; + final viewportCenterY = (camera?.viewport.size.y ?? 0) * anchor.y; + + //final x = offsetX + (cameraX * (1.0 - parallaxX)); + //final y = offsetY + (cameraY * (1.0 - parallaxY)); + var x = (1.0 - parallaxX) * viewportCenterX; + var y = (1.0 - parallaxY) * viewportCenterY; + x /= zoom; + y /= zoom; + x += offsetX + cameraX - (cameraX * parallaxX); + y += offsetY + cameraY - (cameraY * parallaxY); + //cachedLayerOffset = Vector2(x / zoom, y / zoom); cachedLayerOffset = Vector2(x, y); + canvas.translate(cachedLayerOffset.x, cachedLayerOffset.y); } diff --git a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart index 0a5af95c3b7..f6efb562250 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/tile_layer.dart @@ -31,15 +31,11 @@ import 'package:meta/meta.dart'; /// {@endtemplate} @internal abstract class FlameTileLayer extends RenderableLayer { - @override - late Paint paint = layerPaintFactory(opacity); - final TiledAtlas tiledAtlas; late List> transforms; final animations = []; final Map animationFrames; final bool ignoreFlip; - Paint Function(double opacity) layerPaintFactory; FlameTileLayer({ required super.layer, @@ -50,7 +46,7 @@ abstract class FlameTileLayer extends RenderableLayer { required this.tiledAtlas, required this.animationFrames, required this.ignoreFlip, - required this.layerPaintFactory, + required super.layerPaintFactory, super.filterQuality, }); @@ -137,12 +133,7 @@ abstract class FlameTileLayer extends RenderableLayer { if (tiledAtlas.batch == null) { return; } - - canvas.save(); - //canvas.translate(offsetX, offsetY); - //applyParallaxOffset(canvas); tiledAtlas.batch!.render(canvas, paint: paint); - canvas.restore(); } @protected diff --git a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/unsupported_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/unsupported_layer.dart index 9ba0c916aa3..895b20b70b6 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/unsupported_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/unsupported_layer.dart @@ -10,6 +10,7 @@ class UnsupportedLayer extends RenderableLayer { required super.parent, required super.camera, required super.destTileSize, + required super.layerPaintFactory, }); @override diff --git a/packages/flame_tiled/test/tiled_test.dart b/packages/flame_tiled/test/tiled_test.dart index 471824a1fad..c9ab3619fc1 100644 --- a/packages/flame_tiled/test/tiled_test.dart +++ b/packages/flame_tiled/test/tiled_test.dart @@ -832,9 +832,7 @@ void main() { late TiledComponent component; final size = Vector2(256, 128); - Future setupMap( - Vector2 destTileSize, - ) async { + Future setupMap(Vector2 destTileSize) async { final bundle = TestAssetBundle( imageNames: [ 'isometric_spritesheet.png', @@ -1070,21 +1068,21 @@ void main() { matchesGoldenFile('goldens/dungeon_animation_${mapType}_0.png'), ); - component.update(0.18); + component.updateTree(0.18); pngData = await renderMapToPng(component); await expectLater( pngData, matchesGoldenFile('goldens/dungeon_animation_${mapType}_1.png'), ); - component.update(0.18); + component.updateTree(0.18); pngData = await renderMapToPng(component); await expectLater( pngData, matchesGoldenFile('goldens/dungeon_animation_${mapType}_2.png'), ); - component.update(0.18); + component.updateTree(0.18); pngData = await renderMapToPng(component); await expectLater( pngData, From 91795aca24360fba6c1c833b4b87c96d087571d7 Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Wed, 13 Aug 2025 23:15:02 -0500 Subject: [PATCH 17/28] cleanup for review. --- .../src/renderable_layers/image_layer.dart | 25 +++---------------- .../renderable_layers/renderable_layer.dart | 5 +--- .../lib/src/renderable_tile_map.dart | 11 ++++---- 3 files changed, 10 insertions(+), 31 deletions(-) diff --git a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart index 1b41afb8203..b33d9d8c870 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart @@ -15,7 +15,6 @@ class FlameImageLayer extends RenderableLayer { late final ImageRepeat _repeat; final MutableRect _paintArea = MutableRect.fromLTRB(0, 0, 0, 0); final Vector2 _canvasSize = Vector2.zero(); - final Vector2 _maxTranslation = Vector2.zero(); FlameImageLayer({ required super.layer, @@ -59,19 +58,6 @@ class FlameImageLayer extends RenderableLayer { final imageW = _image.size.x; final imageH = _image.size.y; - // Track the maximum amount the canvas could have been translated - // for this layer so we can calculate the wrap point within the - // paint area. - _maxTranslation.x = cachedLayerOffset.x; - // offsetX; //- (visibleWorldRect.left * parallaxX); - _maxTranslation.y = cachedLayerOffset.y; - // offsetY; //- (visibleWorldRect.top * parallaxY); - - /* - _maxTranslation.x = offsetX - camera.viewfinder.position.x * parallaxX; - _maxTranslation.y = offsetY - camera.viewfinder.position.y * parallaxY; -*/ - // When the image is being repeated, make sure the _paintArea rect is // big enough that it repeats off the edge of the canvas in both positive // and negative directions on that axis (Tiled repeats forever on an axis). @@ -80,7 +66,6 @@ class FlameImageLayer extends RenderableLayer { // it still matches up with its initial layer offsets. if (_repeat == ImageRepeat.repeatX || _repeat == ImageRepeat.repeat) { final (left, right) = _calculatePaintRange( - translation: _maxTranslation.x, destSize: destSize.x, imageSideLen: imageW, layerOffset: cachedLayerOffset.x, @@ -97,7 +82,6 @@ class FlameImageLayer extends RenderableLayer { } if (_repeat == ImageRepeat.repeatY || _repeat == ImageRepeat.repeat) { final (top, bottom) = _calculatePaintRange( - translation: _maxTranslation.y, destSize: destSize.y, imageSideLen: imageH, layerOffset: cachedLayerOffset.y, @@ -130,16 +114,15 @@ class FlameImageLayer extends RenderableLayer { // particular way that reduces the time spent on computation and clip steps // in flutter when drawing infinitely across an axis. This method accounts // for the destination canvas size, camera viewport size, and the exact - // coverage of the image w.r.t. [translation]. + // coverage of the image w.r.t. translation. // This is achieved by wrapping the rect coordinates around [destSize] // after calculating the image coverage with [imageSideLen] and adding the // unseen portion of the image in the span of the wrap range, if any. // // The return tuple value is the range where its centroid is the wrap point - // plus the [layerOffset] which shifts the range to account for earlier - // transformations applied to the canvas. + // plus the [layerOffset] which is the accumulation of all translations + // applied to this layer earlier in the render pipeline. (double min, double max) _calculatePaintRange({ - required double translation, required double destSize, required double imageSideLen, required double layerOffset, @@ -158,7 +141,7 @@ class FlameImageLayer extends RenderableLayer { final unseen = (imageCount - seen) * imageSideLen; // Wrap around the target axis w.r.t. parallax. - final wrapPoint = translation.ceil() % (destSize + unseen).toInt(); + final wrapPoint = layerOffset.ceil() % (destSize + unseen).toInt(); // Partition the _paintArea into two parts. final part = (wrapPoint / imageSideLen).ceil(); diff --git a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart index 5eb05df7e7b..902d06a3b27 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart @@ -173,17 +173,14 @@ abstract class RenderableLayer extends PositionComponent final viewportCenterX = (camera?.viewport.size.x ?? 0) * anchor.x; final viewportCenterY = (camera?.viewport.size.y ?? 0) * anchor.y; - //final x = offsetX + (cameraX * (1.0 - parallaxX)); - //final y = offsetY + (cameraY * (1.0 - parallaxY)); var x = (1.0 - parallaxX) * viewportCenterX; var y = (1.0 - parallaxY) * viewportCenterY; x /= zoom; y /= zoom; x += offsetX + cameraX - (cameraX * parallaxX); y += offsetY + cameraY - (cameraY * parallaxY); - //cachedLayerOffset = Vector2(x / zoom, y / zoom); - cachedLayerOffset = Vector2(x, y); + cachedLayerOffset = Vector2(x, y); canvas.translate(cachedLayerOffset.x, cachedLayerOffset.y); } diff --git a/packages/flame_tiled/lib/src/renderable_tile_map.dart b/packages/flame_tiled/lib/src/renderable_tile_map.dart index b028d21d1c2..8164761c514 100644 --- a/packages/flame_tiled/lib/src/renderable_tile_map.dart +++ b/packages/flame_tiled/lib/src/renderable_tile_map.dart @@ -394,7 +394,6 @@ class RenderableTiledMap extends Component @override Future? onLoad() async { - await super.onLoad(); // Automatically use the first attached CameraComponent camera if it's not // already set.. camera ??= game.children.query().firstOrNull; @@ -423,23 +422,23 @@ class RenderableTiledMap extends Component if (_backgroundPaint != null) { c.drawPaint(_backgroundPaint); } - super.render(c); } - /// Returns a layer of type [T] with given [name] from all the layers + /// Returns a [Layer] of type [L] with given [name] from all the layers /// of this map. If no such layer is found, null is returned. L? getLayer(String name) { try { - // layerByName will searches recursively starting with tiled.dart v0.8.5 + // layerByName searches recursively starting with tiled.dart v0.8.5 return map.layerByName(name) as L; } on ArgumentError { return null; } } - /// Returns a [RenderableLayer] with given [name] from all the layers - /// of this map. If no such layer is found, null is returned. + /// Returns a [RenderableLayer] with given [name] from all the + /// [renderableLayers] tracked by this component. + /// If no such layer is found, null is returned. RenderableLayer? getRenderableLayer(String name) => switch (renderableLayers.indexWhere((e) => e.layer.name == name)) { -1 => null, From 991eea6bc96f5396b3ced337b456e662e6068eff Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Thu, 14 Aug 2025 00:07:44 -0500 Subject: [PATCH 18/28] patch yaml --- packages/flame_tiled/pubspec.yaml | 2 +- packages/flame_tiled/test/tiled_test.dart | 206 +++++++++++----------- 2 files changed, 108 insertions(+), 100 deletions(-) diff --git a/packages/flame_tiled/pubspec.yaml b/packages/flame_tiled/pubspec.yaml index cb852ccb1c7..43634a17d5c 100644 --- a/packages/flame_tiled/pubspec.yaml +++ b/packages/flame_tiled/pubspec.yaml @@ -27,8 +27,8 @@ dependencies: dev_dependencies: dartdoc: ^8.0.8 - flame_test: ^1.17.2 flame_lint: ^1.4.1 + flame_test: ^2.0.1 flutter_test: sdk: flutter test: any diff --git a/packages/flame_tiled/test/tiled_test.dart b/packages/flame_tiled/test/tiled_test.dart index 7e18b8ea71e..e553157351c 100644 --- a/packages/flame_tiled/test/tiled_test.dart +++ b/packages/flame_tiled/test/tiled_test.dart @@ -11,7 +11,7 @@ import 'package:flame_tiled/src/renderable_layers/tile_layers/tile_layer.dart'; import 'package:flutter/services.dart'; import 'package:flutter_test/flutter_test.dart' hide expect, group, setUp, isInstanceOf, expectLater; -import 'package:test/test.dart'; +import 'package:test/test.dart' hide test; import 'test_asset_bundle.dart'; import 'test_image_utils.dart'; @@ -41,23 +41,25 @@ void main() { images: Images(bundle: Flame.bundle), key: ComponentKey.named('test'), ); - }); + } testWithFlameGame('correct loads the file', (game) async { await setUp(game); expect(tiled.tileMap.renderableLayers.length, equals(4)); }); - testWithFlameGame('component atlases returns the loaded atlases', - (game) async { + testWithFlameGame('component atlases returns the loaded atlases', ( + game, + ) async { await setUp(game); final atlases = tiled.atlases(); expect(atlases, hasLength(1)); expect(atlases.first.$1, equals('map-level1.png')); }); - testWithFlameGame('correct loads the file, with different prefix', - (game) async { + testWithFlameGame('correct loads the file, with different prefix', ( + game, + ) async { await setUp(game); tiled = await TiledComponent.load( 'map_custom_path.tmx', @@ -74,8 +76,9 @@ void main() { }); group('is positionable', () { - testWithFlameGame('size, width, and height are readable - not writable', - (game) async { + testWithFlameGame('size, width, and height are readable - not writable', ( + game, + ) async { await setUp(game); expect(tiled.size, Vector2(512.0, 2048.0)); expect(tiled.width, 512); @@ -138,8 +141,9 @@ void main() { ); }); - testWithFlameGame('correctly loads external tileset with custom path', - (game) async { + testWithFlameGame('correctly loads external tileset with custom path', ( + game, + ) async { // Flame.bundle is a global static. Updating these in tests can lead to // odd errors if you're trying to debug. Flame.bundle = TestAssetBundle( @@ -307,99 +311,101 @@ void main() { } testWithFlameGame( - '[useAtlas = true] Green tile pixels are in correct spots', - (game) async { - await setUp(game); - - const oneColorRect = 8; - final leftTilePixels = []; - for ( - var i = 65 * oneColorRect * pixel; - i < ((64 * 23) + (oneColorRect * 3)) * pixel; - i += 64 * pixel - ) { - leftTilePixels.addAll( - pixelsAfterFlipApplied.getRange(i, i + (16 * pixel)), - ); - } + '[useAtlas = true] Green tile pixels are in correct spots', + (game) async { + await setUp(game); - var allGreen = true; - for (var i = 0; i < leftTilePixels.length; i += pixel) { - allGreen &= - leftTilePixels[i] == 0 && - leftTilePixels[i + 1] == 255 && - leftTilePixels[i + 2] == 0 && - leftTilePixels[i + 3] == 255; - } - expect(allGreen, true); + const oneColorRect = 8; + final leftTilePixels = []; + for ( + var i = 65 * oneColorRect * pixel; + i < ((64 * 23) + (oneColorRect * 3)) * pixel; + i += 64 * pixel + ) { + leftTilePixels.addAll( + pixelsAfterFlipApplied.getRange(i, i + (16 * pixel)), + ); + } - final rightTilePixels = []; - for ( - var i = 69 * 8 * pixel; - i < ((64 * 23) + (8 * 7)) * pixel; - i += 64 * pixel - ) { - rightTilePixels.addAll( - pixelsAfterFlipApplied.getRange(i, i + (16 * pixel)), - ); - } + var allGreen = true; + for (var i = 0; i < leftTilePixels.length; i += pixel) { + allGreen &= + leftTilePixels[i] == 0 && + leftTilePixels[i + 1] == 255 && + leftTilePixels[i + 2] == 0 && + leftTilePixels[i + 3] == 255; + } + expect(allGreen, true); + + final rightTilePixels = []; + for ( + var i = 69 * 8 * pixel; + i < ((64 * 23) + (8 * 7)) * pixel; + i += 64 * pixel + ) { + rightTilePixels.addAll( + pixelsAfterFlipApplied.getRange(i, i + (16 * pixel)), + ); + } - for (var i = 0; i < rightTilePixels.length; i += pixel) { - allGreen &= - rightTilePixels[i] == 0 && - rightTilePixels[i + 1] == 255 && - rightTilePixels[i + 2] == 0 && - rightTilePixels[i + 3] == 255; - } - expect(allGreen, true); - }); + for (var i = 0; i < rightTilePixels.length; i += pixel) { + allGreen &= + rightTilePixels[i] == 0 && + rightTilePixels[i + 1] == 255 && + rightTilePixels[i + 2] == 0 && + rightTilePixels[i + 3] == 255; + } + expect(allGreen, true); + }, + ); testWithFlameGame( - '[useAtlas = false] Green tile pixels are in correct spots', - (game) async { - await setUp(game); - - final leftTilePixels = []; - for ( - var i = 65 * 8 * pixel; - i < ((64 * 23) + (8 * 3)) * pixel; - i += 64 * pixel - ) { - leftTilePixels.addAll( - pixelsBeforeFlipApplied.getRange(i, i + (16 * pixel)), - ); - } + '[useAtlas = false] Green tile pixels are in correct spots', + (game) async { + await setUp(game); - var allGreen = true; - for (var i = 0; i < leftTilePixels.length; i += pixel) { - allGreen &= - leftTilePixels[i] == 0 && - leftTilePixels[i + 1] == 255 && - leftTilePixels[i + 2] == 0 && - leftTilePixels[i + 3] == 255; - } - expect(allGreen, true); + final leftTilePixels = []; + for ( + var i = 65 * 8 * pixel; + i < ((64 * 23) + (8 * 3)) * pixel; + i += 64 * pixel + ) { + leftTilePixels.addAll( + pixelsBeforeFlipApplied.getRange(i, i + (16 * pixel)), + ); + } - final rightTilePixels = []; - for ( - var i = 69 * 8 * pixel; - i < ((64 * 23) + (8 * 7)) * pixel; - i += 64 * pixel - ) { - rightTilePixels.addAll( - pixelsBeforeFlipApplied.getRange(i, i + (16 * pixel)), - ); - } + var allGreen = true; + for (var i = 0; i < leftTilePixels.length; i += pixel) { + allGreen &= + leftTilePixels[i] == 0 && + leftTilePixels[i + 1] == 255 && + leftTilePixels[i + 2] == 0 && + leftTilePixels[i + 3] == 255; + } + expect(allGreen, true); + + final rightTilePixels = []; + for ( + var i = 69 * 8 * pixel; + i < ((64 * 23) + (8 * 7)) * pixel; + i += 64 * pixel + ) { + rightTilePixels.addAll( + pixelsBeforeFlipApplied.getRange(i, i + (16 * pixel)), + ); + } - for (var i = 0; i < rightTilePixels.length; i += pixel) { - allGreen &= - rightTilePixels[i] == 0 && - rightTilePixels[i + 1] == 255 && - rightTilePixels[i + 2] == 0 && - rightTilePixels[i + 3] == 255; - } - expect(allGreen, true); - }); + for (var i = 0; i < rightTilePixels.length; i += pixel) { + allGreen &= + rightTilePixels[i] == 0 && + rightTilePixels[i + 1] == 255 && + rightTilePixels[i + 2] == 0 && + rightTilePixels[i + 3] == 255; + } + expect(allGreen, true); + }, + ); }); group('ignoring flip makes different texture and rendering result', () { @@ -1006,8 +1012,9 @@ void main() { await game.ready(); } - testWithFlameGame('handle single frame animations ($mapType)', - (game) async { + testWithFlameGame('handle single frame animations ($mapType)', ( + game, + ) async { await setUp(game); expect(map.renderableLayers.first is FlameTileLayer, true); @@ -1025,8 +1032,9 @@ void main() { expect(layer.animations.first.frames.sources, hasLength(1)); }); - testWithFlameGame('handle single frame animations ($mapType)', - (game) async { + testWithFlameGame('handle single frame animations ($mapType)', ( + game, + ) async { await setUp(game); expect( From f8070181acc15b06bbaa533bcff6986198a9734d Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Thu, 14 Aug 2025 00:16:54 -0500 Subject: [PATCH 19/28] satisfy word check linter --- .../flame_tiled/lib/src/renderable_layers/group_layer.dart | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart index 25ad661428d..2d9a1658aec 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/group_layer.dart @@ -16,9 +16,9 @@ class GroupLayer extends RenderableLayer { @override void refreshCache() { - final sublayers = children.whereType(); - for (final sub in sublayers) { - sub.refreshCache(); + final childLayers = children.whereType(); + for (final child in childLayers) { + child.refreshCache(); } } } From a9776ea2a49108667d828c4a173223bf4bc78f51 Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Thu, 14 Aug 2025 16:15:35 -0500 Subject: [PATCH 20/28] melos format. fixed tiled component key test. --- .../lib/src/renderable_layers/image_layer.dart | 6 ++++-- .../lib/src/renderable_layers/renderable_layer.dart | 12 ++++++++---- packages/flame_tiled/test/tiled_test.dart | 3 ++- 3 files changed, 14 insertions(+), 7 deletions(-) diff --git a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart index b33d9d8c870..3d72cd9a6cd 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart @@ -65,7 +65,8 @@ class FlameImageLayer extends RenderableLayer { // image's length along that axis (width or height) so that with repeats // it still matches up with its initial layer offsets. if (_repeat == ImageRepeat.repeatX || _repeat == ImageRepeat.repeat) { - final (left, right) = _calculatePaintRange( + final (left, right) = + _calculatePaintRange( destSize: destSize.x, imageSideLen: imageW, layerOffset: cachedLayerOffset.x, @@ -81,7 +82,8 @@ class FlameImageLayer extends RenderableLayer { _paintArea.right = imageW; } if (_repeat == ImageRepeat.repeatY || _repeat == ImageRepeat.repeat) { - final (top, bottom) = _calculatePaintRange( + final (top, bottom) = + _calculatePaintRange( destSize: destSize.y, imageSideLen: imageH, layerOffset: cachedLayerOffset.y, diff --git a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart index 902d06a3b27..00db012b689 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart @@ -124,13 +124,15 @@ abstract class RenderableLayer extends PositionComponent double get scaleX => destTileSize.x / map.tileWidth; double get scaleY => destTileSize.y / map.tileHeight; - late double offsetX = layer.offsetX * scaleX + + late double offsetX = + layer.offsetX * scaleX + switch (parent) { final GroupLayer p => p.offsetX, _ => 0, }; - late double offsetY = layer.offsetY * scaleY + + late double offsetY = + layer.offsetY * scaleY + switch (parent) { final GroupLayer p => p.offsetY, _ => 0, @@ -144,13 +146,15 @@ abstract class RenderableLayer extends PositionComponent _ => 1, }; - late double parallaxX = layer.parallaxX * + late double parallaxX = + layer.parallaxX * switch (parent) { final GroupLayer p => p.parallaxX, _ => 1, }; - late double parallaxY = layer.parallaxY * + late double parallaxY = + layer.parallaxY * switch (parent) { final GroupLayer p => p.parallaxY, _ => 1, diff --git a/packages/flame_tiled/test/tiled_test.dart b/packages/flame_tiled/test/tiled_test.dart index e553157351c..a3a2d4c918d 100644 --- a/packages/flame_tiled/test/tiled_test.dart +++ b/packages/flame_tiled/test/tiled_test.dart @@ -71,7 +71,8 @@ void main() { expect(tiled.tileMap.renderableLayers.length, equals(3)); }); - test('assigns key', () async { + testWithFlameGame('assigns key', (game) async { + await setUp(game); expect(tiled.key, equals(ComponentKey.named('test'))); }); From d69552a1a78f795c4bbd705c2e82fe2de3fcf253 Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Thu, 14 Aug 2025 16:31:55 -0500 Subject: [PATCH 21/28] PR review: elaborate documentation for UnsupportedLayer class. --- .../renderable_layers/tile_layers/unsupported_layer.dart | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/unsupported_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/unsupported_layer.dart index 895b20b70b6..dafb6928aab 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/unsupported_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/unsupported_layer.dart @@ -1,7 +1,13 @@ import 'package:flame_tiled/flame_tiled.dart'; import 'package:meta/meta.dart'; -// Represents a [RenderableLayer] that cannot be parsed by this package. +/// An instance of this class represents a [RenderableLayer] that could not be +/// parsed by this package. +/// +/// Because every [RenderableLayer]'s offsets are accumulated and used by their +/// down-stream child components during rendering, an [UnsupportedLayer] +/// must be retained in the component tree. In this way, offsets can propogate +/// correctly even if this package lacks features in newer Tiled versions. @internal class UnsupportedLayer extends RenderableLayer { UnsupportedLayer({ From 3dea410000cd755e46f6b19fb07c0cbe2725db2d Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Thu, 14 Aug 2025 16:33:54 -0500 Subject: [PATCH 22/28] satisfy spell checker --- .../src/renderable_layers/tile_layers/unsupported_layer.dart | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/unsupported_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/unsupported_layer.dart index dafb6928aab..57e1c6c92e6 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/tile_layers/unsupported_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/tile_layers/unsupported_layer.dart @@ -6,7 +6,7 @@ import 'package:meta/meta.dart'; /// /// Because every [RenderableLayer]'s offsets are accumulated and used by their /// down-stream child components during rendering, an [UnsupportedLayer] -/// must be retained in the component tree. In this way, offsets can propogate +/// must be retained in the component tree. In this way, offsets can propagate /// correctly even if this package lacks features in newer Tiled versions. @internal class UnsupportedLayer extends RenderableLayer { From 0cf2ea480c72576ee424b12c398516b82af38a6b Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Fri, 15 Aug 2025 00:29:42 -0500 Subject: [PATCH 23/28] new math allows each layer to apply its own offset to the canvas using partial parallax locality. This is equivalent to the product of all parent parallax coefficients. --- .../src/renderable_layers/image_layer.dart | 26 ++++--- .../renderable_layers/renderable_layer.dart | 78 +++++++------------ 2 files changed, 44 insertions(+), 60 deletions(-) diff --git a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart index 3d72cd9a6cd..15365e3db29 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart @@ -37,7 +37,6 @@ class FlameImageLayer extends RenderableLayer { @override void render(Canvas canvas) { - canvas.save(); _resizePaintArea(camera); paintImage( canvas: canvas, @@ -48,8 +47,6 @@ class FlameImageLayer extends RenderableLayer { repeat: _repeat, filterQuality: filterQuality, ); - - canvas.restore(); } void _resizePaintArea(CameraComponent? camera) { @@ -68,8 +65,8 @@ class FlameImageLayer extends RenderableLayer { final (left, right) = _calculatePaintRange( destSize: destSize.x, - imageSideLen: imageW, - layerOffset: cachedLayerOffset.x, + imageSideLen: imageW.toInt(), + layerOffset: cachedLocalParallax.x.round(), ) + // Apply camera left/right to range. (visibleWorldRect.left, visibleWorldRect.right); @@ -85,8 +82,8 @@ class FlameImageLayer extends RenderableLayer { final (top, bottom) = _calculatePaintRange( destSize: destSize.y, - imageSideLen: imageH, - layerOffset: cachedLayerOffset.y, + imageSideLen: imageH.toInt(), + layerOffset: cachedLocalParallax.y.round(), ) + // Apply camera top/bottom to range. (visibleWorldRect.top, visibleWorldRect.bottom); @@ -126,8 +123,8 @@ class FlameImageLayer extends RenderableLayer { // applied to this layer earlier in the render pipeline. (double min, double max) _calculatePaintRange({ required double destSize, - required double imageSideLen, - required double layerOffset, + required int imageSideLen, + required int layerOffset, }) { // Prevent DBZ error. if (imageSideLen < 1) { @@ -143,7 +140,7 @@ class FlameImageLayer extends RenderableLayer { final unseen = (imageCount - seen) * imageSideLen; // Wrap around the target axis w.r.t. parallax. - final wrapPoint = layerOffset.ceil() % (destSize + unseen).toInt(); + final wrapPoint = layerOffset % (destSize + unseen).ceil(); // Partition the _paintArea into two parts. final part = (wrapPoint / imageSideLen).ceil(); @@ -151,7 +148,7 @@ class FlameImageLayer extends RenderableLayer { return ( wrapPoint - (imageSideLen * part) - layerOffset, wrapPoint + (imageSideLen * (imageCount - part)) - layerOffset, - ); + ).toDouble(); } static Future load({ @@ -181,7 +178,12 @@ class FlameImageLayer extends RenderableLayer { } /// Provide tuples with addition. -extension _PrivRangeTupleHelper on (double, double) { +extension _PrivRangeTupleDouble on (double, double) { (double, double) operator +((double, double) other) => ($1 + other.$1, $2 + other.$2); } + +/// Provides tuples of ints to doubles. +extension _PrivRangeTupleInt on (int, int) { + (double, double) toDouble() => ($1.toDouble(), $2.toDouble()); +} diff --git a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart index 00db012b689..0077d557701 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart @@ -25,7 +25,7 @@ abstract class RenderableLayer extends PositionComponent /// Cached canvas translation used in parallax effects. /// This field needs to be read in the case of repeated textures /// as an optimization step. - Vector2 cachedLayerOffset = Vector2.zero(); + Vector2 cachedLocalParallax = Vector2.zero(); /// Given the layer's [opacity], compute [Paint] for drawing. /// This is useful if your layer requires translucency or other effects. @@ -121,23 +121,6 @@ abstract class RenderableLayer extends PositionComponent void refreshCache(); - double get scaleX => destTileSize.x / map.tileWidth; - double get scaleY => destTileSize.y / map.tileHeight; - - late double offsetX = - layer.offsetX * scaleX + - switch (parent) { - final GroupLayer p => p.offsetX, - _ => 0, - }; - - late double offsetY = - layer.offsetY * scaleY + - switch (parent) { - final GroupLayer p => p.offsetY, - _ => 0, - }; - @override double get opacity => layer.opacity * @@ -146,19 +129,11 @@ abstract class RenderableLayer extends PositionComponent _ => 1, }; - late double parallaxX = - layer.parallaxX * - switch (parent) { - final GroupLayer p => p.parallaxX, - _ => 1, - }; + double get scaleX => destTileSize.x / map.tileWidth; + double get scaleY => destTileSize.y / map.tileHeight; - late double parallaxY = - layer.parallaxY * - switch (parent) { - final GroupLayer p => p.parallaxY, - _ => 1, - }; + late double offsetX = layer.offsetX * scaleX; + late double offsetY = layer.offsetY * scaleY; /// Calculates the offset we need to apply to the canvas to compensate for /// parallax positioning and scroll for the layer and the current camera @@ -166,26 +141,33 @@ abstract class RenderableLayer extends PositionComponent /// https://doc.mapeditor.org/en/latest/manual/layers/#parallax-scrolling-factor void applyParallaxOffset(Canvas canvas) { final viewfinder = camera?.viewfinder; - final cameraX = viewfinder?.position.x ?? 0.0; - final cameraY = viewfinder?.position.y ?? 0.0; + final cameraX = viewfinder?.position.x ?? 0; + final cameraY = viewfinder?.position.y ?? 0; final zoom = viewfinder?.zoom ?? 1.0; - // Use the complement of the parallax coefficient in order to account for - // the camera applying its transformations earlier in the render cycle - // of Flame. This adjustment draws the layers correctly w.r.t. their own - // offset and parallax values. - final viewportCenterX = (camera?.viewport.size.x ?? 0) * anchor.x; - final viewportCenterY = (camera?.viewport.size.y ?? 0) * anchor.y; - - var x = (1.0 - parallaxX) * viewportCenterX; - var y = (1.0 - parallaxY) * viewportCenterY; - x /= zoom; - y /= zoom; - x += offsetX + cameraX - (cameraX * parallaxX); - y += offsetY + cameraY - (cameraY * parallaxY); - - cachedLayerOffset = Vector2(x, y); - canvas.translate(cachedLayerOffset.x, cachedLayerOffset.y); + final x = cameraX - (cameraX * layer.parallaxX); + final y = cameraY - (cameraY * layer.parallaxY); + + final deltaX = + layer.parallaxX * + switch (parent) { + final GroupLayer p => p.cachedLocalParallax.x, + _ => 0, + }; + + final deltaY = + layer.parallaxY * + switch (parent) { + final GroupLayer p => p.cachedLocalParallax.y, + _ => 0, + }; + + cachedLocalParallax = Vector2(deltaX + x / zoom, deltaY + y / zoom); + + canvas.translate( + offsetX + cachedLocalParallax.x, + offsetY + cachedLocalParallax.y, + ); } // Only render if this layer is [visible]. From f257c7ff55e4042feee6453e6fe2ee14bbceb5b1 Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Fri, 15 Aug 2025 12:23:06 -0500 Subject: [PATCH 24/28] fixed parallax effect optimization with new layer translation math --- .../src/renderable_layers/image_layer.dart | 20 +++--- .../renderable_layers/renderable_layer.dart | 68 +++++++++++++------ 2 files changed, 58 insertions(+), 30 deletions(-) diff --git a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart index 15365e3db29..8a7018de6a2 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart @@ -50,6 +50,7 @@ class FlameImageLayer extends RenderableLayer { } void _resizePaintArea(CameraComponent? camera) { + final displacement = absoluteParallax + absoluteOffset; final visibleWorldRect = camera?.visibleWorldRect ?? Rect.zero; final destSize = camera?.viewport.virtualSize ?? _canvasSize; final imageW = _image.size.x; @@ -66,7 +67,8 @@ class FlameImageLayer extends RenderableLayer { _calculatePaintRange( destSize: destSize.x, imageSideLen: imageW.toInt(), - layerOffset: cachedLocalParallax.x.round(), + parallax: absoluteParallax.x.round(), + displacement: displacement.x.round(), ) + // Apply camera left/right to range. (visibleWorldRect.left, visibleWorldRect.right); @@ -83,7 +85,8 @@ class FlameImageLayer extends RenderableLayer { _calculatePaintRange( destSize: destSize.y, imageSideLen: imageH.toInt(), - layerOffset: cachedLocalParallax.y.round(), + parallax: absoluteParallax.y.round(), + displacement: displacement.y.round(), ) + // Apply camera top/bottom to range. (visibleWorldRect.top, visibleWorldRect.bottom); @@ -113,18 +116,19 @@ class FlameImageLayer extends RenderableLayer { // particular way that reduces the time spent on computation and clip steps // in flutter when drawing infinitely across an axis. This method accounts // for the destination canvas size, camera viewport size, and the exact - // coverage of the image w.r.t. translation. + // coverage of the image w.r.t. [parallax]. // This is achieved by wrapping the rect coordinates around [destSize] // after calculating the image coverage with [imageSideLen] and adding the // unseen portion of the image in the span of the wrap range, if any. // // The return tuple value is the range where its centroid is the wrap point - // plus the [layerOffset] which is the accumulation of all translations + // minus the [displacement] which is the accumulation of all translations // applied to this layer earlier in the render pipeline. (double min, double max) _calculatePaintRange({ required double destSize, required int imageSideLen, - required int layerOffset, + required int parallax, + required int displacement, }) { // Prevent DBZ error. if (imageSideLen < 1) { @@ -140,14 +144,14 @@ class FlameImageLayer extends RenderableLayer { final unseen = (imageCount - seen) * imageSideLen; // Wrap around the target axis w.r.t. parallax. - final wrapPoint = layerOffset % (destSize + unseen).ceil(); + final wrapPoint = (displacement + parallax) % (destSize + unseen).ceil(); // Partition the _paintArea into two parts. final part = (wrapPoint / imageSideLen).ceil(); return ( - wrapPoint - (imageSideLen * part) - layerOffset, - wrapPoint + (imageSideLen * (imageCount - part)) - layerOffset, + wrapPoint - (imageSideLen * part) - displacement, + wrapPoint + (imageSideLen * (imageCount - part)) - displacement, ).toDouble(); } diff --git a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart index 0077d557701..406a1591947 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart @@ -22,10 +22,14 @@ abstract class RenderableLayer extends PositionComponent /// The [FilterQuality] that should be used by all the layers. final FilterQuality filterQuality; - /// Cached canvas translation used in parallax effects. + /// The total canvas translation used in parallax effects. /// This field needs to be read in the case of repeated textures /// as an optimization step. - Vector2 cachedLocalParallax = Vector2.zero(); + Vector2 absoluteParallax = Vector2.zero(); + + /// The total offsets computed from our [Layer.offsetX] and [Layer.offsetY] + /// and all parent layer offsets, if any. + Vector2 absoluteOffset = Vector2.zero(); /// Given the layer's [opacity], compute [Paint] for drawing. /// This is useful if your layer requires translucency or other effects. @@ -145,28 +149,48 @@ abstract class RenderableLayer extends PositionComponent final cameraY = viewfinder?.position.y ?? 0; final zoom = viewfinder?.zoom ?? 1.0; - final x = cameraX - (cameraX * layer.parallaxX); - final y = cameraY - (cameraY * layer.parallaxY); - - final deltaX = - layer.parallaxX * - switch (parent) { - final GroupLayer p => p.cachedLocalParallax.x, - _ => 0, - }; - - final deltaY = - layer.parallaxY * - switch (parent) { - final GroupLayer p => p.cachedLocalParallax.y, - _ => 0, - }; - - cachedLocalParallax = Vector2(deltaX + x / zoom, deltaY + y / zoom); + // Discover parent layer terms used for the calculations below. + final parentOffset = switch (parent) { + final GroupLayer p => p.absoluteOffset, + _ => Vector2.zero(), + }; + final parentParallax = switch (parent) { + final GroupLayer p => p.absoluteParallax, + _ => Vector2(1.0, 1.0), + }; + final parallaxLocality = Vector2( + layer.parallaxX * parentParallax.x, + layer.parallaxY * parentParallax.y, + ); + // Calculate our local parallax. + double calcParallax(double cam, double parallax) => cam - (cam * parallax); + final localParallax = + Vector2( + calcParallax(cameraX, layer.parallaxX), + calcParallax(cameraY, layer.parallaxY), + ) / + zoom; + + absoluteParallax = localParallax + parallaxLocality; + absoluteOffset = parentOffset + Vector2(offsetX, offsetY); + + // Adjustment term for canvas translation below. + final delta = switch (parent is GroupLayer) { + true => parentParallax - localParallax, + false => Vector2.zero(), + }; + + // Strictly apply local translations in our render step. + // + // Explanation: + // B/c sum of all local translations w.r.t. parallax locality is equal to the + // products of all absolute parallax values followed by translation, the + // scene graph render by Flame produces the same visuals as painting layers + //using absolute values in a traditional composite renderer. canvas.translate( - offsetX + cachedLocalParallax.x, - offsetY + cachedLocalParallax.y, + offsetX + localParallax.x + delta.x, + offsetY + localParallax.y + delta.y, ); } From bfc96414ccb41b747b1d61e1ff220a5102e3d492 Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Fri, 15 Aug 2025 17:38:39 -0500 Subject: [PATCH 25/28] Wrap math fixed. --- .../src/renderable_layers/image_layer.dart | 52 ++++++++++--------- .../renderable_layers/renderable_layer.dart | 18 +++---- 2 files changed, 37 insertions(+), 33 deletions(-) diff --git a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart index 8a7018de6a2..15be9116da8 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart @@ -50,26 +50,31 @@ class FlameImageLayer extends RenderableLayer { } void _resizePaintArea(CameraComponent? camera) { - final displacement = absoluteParallax + absoluteOffset; final visibleWorldRect = camera?.visibleWorldRect ?? Rect.zero; final destSize = camera?.viewport.virtualSize ?? _canvasSize; final imageW = _image.size.x; final imageH = _image.size.y; - // When the image is being repeated, make sure the _paintArea rect is - // big enough that it repeats off the edge of the canvas in both positive - // and negative directions on that axis (Tiled repeats forever on an axis). - // Also, make sure the rect's left and top are only moved by exactly the - // image's length along that axis (width or height) so that with repeats - // it still matches up with its initial layer offsets. + // In order to recover the displacement w.r.t. the canvas translation, + // subtract the center view vector to this accumulated offset vector. + // B/c we will wrap the image along the axis infinitely, add the negative + // of the accumulated offset in order to cancel out the layer translation + // and bake the offset value into the total parallax term instead. + final center = visibleWorldRect.center.toVector2(); + final displacement = absoluteParallax - center - absoluteOffset; + final parallax = absoluteOffset + absoluteParallax; + + /// [_calculatePaintRange] ensures the _paintArea rect is + /// big enough that it repeats off the edge of the canvas in both positive + /// and negative directions on that axis (Tiled repeats forever on an axis). if (_repeat == ImageRepeat.repeatX || _repeat == ImageRepeat.repeat) { final (left, right) = _calculatePaintRange( destSize: destSize.x, imageSideLen: imageW.toInt(), - parallax: absoluteParallax.x.round(), + parallax: parallax.x.round(), displacement: displacement.x.round(), - ) + // Apply camera left/right to range. + ) + (visibleWorldRect.left, visibleWorldRect.right); _paintArea @@ -85,9 +90,9 @@ class FlameImageLayer extends RenderableLayer { _calculatePaintRange( destSize: destSize.y, imageSideLen: imageH.toInt(), - parallax: absoluteParallax.y.round(), + parallax: (absoluteOffset + absoluteParallax).y.round(), displacement: displacement.y.round(), - ) + // Apply camera top/bottom to range. + ) + (visibleWorldRect.top, visibleWorldRect.bottom); _paintArea @@ -116,13 +121,13 @@ class FlameImageLayer extends RenderableLayer { // particular way that reduces the time spent on computation and clip steps // in flutter when drawing infinitely across an axis. This method accounts // for the destination canvas size, camera viewport size, and the exact - // coverage of the image w.r.t. [parallax]. + // coverage of the image w.r.t. translation. // This is achieved by wrapping the rect coordinates around [destSize] // after calculating the image coverage with [imageSideLen] and adding the // unseen portion of the image in the span of the wrap range, if any. // // The return tuple value is the range where its centroid is the wrap point - // minus the [displacement] which is the accumulation of all translations + // plus the [displacement] which is the accumulation of all translations // applied to this layer earlier in the render pipeline. (double min, double max) _calculatePaintRange({ required double destSize, @@ -143,16 +148,20 @@ class FlameImageLayer extends RenderableLayer { // Calculate unseen part of image(s). final unseen = (imageCount - seen) * imageSideLen; - // Wrap around the target axis w.r.t. parallax. - final wrapPoint = (displacement + parallax) % (destSize + unseen).ceil(); + // Wrap around the target axis w.r.t. negative parallax. + final coverage = (destSize + unseen).ceil(); + final wrapPoint = coverage - (parallax % coverage) - 1; // Partition the _paintArea into two parts. final part = (wrapPoint / imageSideLen).ceil(); - return ( - wrapPoint - (imageSideLen * part) - displacement, - wrapPoint + (imageSideLen * (imageCount - part)) - displacement, - ).toDouble(); + // Add displacement to the wrap range to account for the + // canvas translations pushing the layer further away from + // where this wrap is expected to be seen in the viewport. + final min = wrapPoint - (imageSideLen * part) + displacement; + final max = wrapPoint + (imageSideLen * (imageCount - part)) + displacement; + + return (min.toDouble(), max.toDouble()); } static Future load({ @@ -186,8 +195,3 @@ extension _PrivRangeTupleDouble on (double, double) { (double, double) operator +((double, double) other) => ($1 + other.$1, $2 + other.$2); } - -/// Provides tuples of ints to doubles. -extension _PrivRangeTupleInt on (int, int) { - (double, double) toDouble() => ($1.toDouble(), $2.toDouble()); -} diff --git a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart index 406a1591947..437ac57a961 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart @@ -156,7 +156,7 @@ abstract class RenderableLayer extends PositionComponent }; final parentParallax = switch (parent) { final GroupLayer p => p.absoluteParallax, - _ => Vector2(1.0, 1.0), + _ => Vector2.zero(), }; final parallaxLocality = Vector2( layer.parallaxX * parentParallax.x, @@ -164,7 +164,7 @@ abstract class RenderableLayer extends PositionComponent ); // Calculate our local parallax. - double calcParallax(double cam, double parallax) => cam - (cam * parallax); + double calcParallax(double cam, double parallax) => cam * parallax; final localParallax = Vector2( calcParallax(cameraX, layer.parallaxX), @@ -172,15 +172,15 @@ abstract class RenderableLayer extends PositionComponent ) / zoom; - absoluteParallax = localParallax + parallaxLocality; - absoluteOffset = parentOffset + Vector2(offsetX, offsetY); - - // Adjustment term for canvas translation below. + // Adjustment term for parallax locality. final delta = switch (parent is GroupLayer) { - true => parentParallax - localParallax, + true => (localParallax + parallaxLocality) - parentParallax, false => Vector2.zero(), }; + absoluteParallax = localParallax + parallaxLocality; + absoluteOffset = parentOffset + Vector2(offsetX, offsetY); + // Strictly apply local translations in our render step. // // Explanation: @@ -189,8 +189,8 @@ abstract class RenderableLayer extends PositionComponent // scene graph render by Flame produces the same visuals as painting layers //using absolute values in a traditional composite renderer. canvas.translate( - offsetX + localParallax.x + delta.x, - offsetY + localParallax.y + delta.y, + (cameraX + offsetX) - (localParallax.x + delta.x), + (cameraY + offsetY) - (localParallax.y + delta.y), ); } From afd3f38a3f39899bf5d16dc285ce9d9294089384 Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Fri, 15 Aug 2025 22:51:09 -0500 Subject: [PATCH 26/28] Parallax effects are now 1:1 with Tiled. WYSIWYG. --- .../example/assets/images/snow.png | Bin 0 -> 518 bytes .../flame_tiled/example/assets/tiles/map.tmx | 5 +- packages/flame_tiled/example/lib/main.dart | 51 +++++++++++++++--- packages/flame_tiled/example/pubspec.yaml | 1 + .../src/renderable_layers/image_layer.dart | 22 ++++---- .../renderable_layers/renderable_layer.dart | 17 +++--- .../lib/src/renderable_tile_map.dart | 9 +++- 7 files changed, 78 insertions(+), 27 deletions(-) create mode 100644 packages/flame_tiled/example/assets/images/snow.png diff --git a/packages/flame_tiled/example/assets/images/snow.png b/packages/flame_tiled/example/assets/images/snow.png new file mode 100644 index 0000000000000000000000000000000000000000..3cb3cf57b70e5f82d9be7d0e8234138f11beb400 GIT binary patch literal 518 zcmeAS@N?(olHy`uVBq!ia0vp^4j|0I1|(Ny7TyC=jKx9jP7LeL$-D$|SkfJR9T^xl z_H+M9WCij$3p^r=85sBugD~Uq{1qucL5ULAh?3y^w370~qEv=}#LT=BJwMkF1yemk zJy)37&w3&Rt70XRt82O%L|C5p=^+AG#Ht|;!HrcAtMum0FaIX z;>>myuy_`b4FU;34AKvy(JWgnPbQW5v|x*``-porVU;~Yr>CNq3)`K&vj z)Nyi!bOG}twwOs*b7!z@<`&ra+lI${2jk4faytv2&)colCNGIPw{wx{*<>y5_VX`1 zug^Gj=wa-w%UWullTPUzfU;L%cUxq7ne*_*YS>ouE`tSpDZH72dzQ!Z^)lrD9x}{%OCyL}s T&v$VY0(r*M)z4*}Q$iB}aF>cf literal 0 HcmV?d00001 diff --git a/packages/flame_tiled/example/assets/tiles/map.tmx b/packages/flame_tiled/example/assets/tiles/map.tmx index 1fae79cffef..ad51fcb1818 100644 --- a/packages/flame_tiled/example/assets/tiles/map.tmx +++ b/packages/flame_tiled/example/assets/tiles/map.tmx @@ -1,5 +1,5 @@ - + @@ -78,4 +78,7 @@ + + + diff --git a/packages/flame_tiled/example/lib/main.dart b/packages/flame_tiled/example/lib/main.dart index d46b5c139d2..7f644ef2b24 100644 --- a/packages/flame_tiled/example/lib/main.dart +++ b/packages/flame_tiled/example/lib/main.dart @@ -1,3 +1,5 @@ +import 'dart:math'; + import 'package:flame/components.dart'; import 'package:flame/effects.dart'; import 'package:flame/flame.dart'; @@ -9,6 +11,25 @@ void main() { runApp(GameWidget(game: TiledGame())); } +class ScrollSnowComponent extends Component { + ScrollSnowComponent(); + double _elapsed = 0; + + @override + void update(double dt) { + if (parent is! RenderableLayer || parent == null) { + return; + } + + final p = parent! as RenderableLayer; + _elapsed += dt; + + p + ..offsetX -= sin(_elapsed * 0.5) * 3.0 + ..offsetY += 1 + sin(_elapsed).abs(); + } +} + class TiledGame extends FlameGame { late TiledComponent mapComponent; @@ -27,29 +48,47 @@ class TiledGame extends FlameGame { ..anchor = Anchor.topLeft ..add( MoveToEffect( - Vector2(320, 180), + Vector2(180, 90), EffectController( - duration: 10, + duration: 5, alternate: true, infinite: true, ), ), ); - mapComponent = await TiledComponent.load('map.tmx', Vector2.all(16)); + mapComponent = await TiledComponent.load( + 'map.tmx', + Vector2.all(16), + ); await world.add(mapComponent); + final snowLayer = mapComponent.tileMap.getRenderableLayer( + 'Snow', + ); + + // This layer is toggled to scroll infinitely across both + // the x and y axis. Add a component to apply real-time + // scrolling behavior to make the snow fall! + if (snowLayer != null) { + await snowLayer.add(ScrollSnowComponent()); + } + final objectGroup = mapComponent.tileMap.getLayer( 'AnimatedCoins', ); + + // No coins to add. No work to be done. + if (objectGroup == null) { + return; + } + final coins = await Flame.images.load('coins.png'); // Add sprites behind the ground decoration layer. final groundLayer = mapComponent.tileMap.getRenderableLayer('Ground'); - // We are 100% sure that an object layer named `AnimatedCoins` - // exists in the example `map.tmx`. - for (final object in objectGroup!.objects) { + for (final object in objectGroup.objects) { groundLayer?.add( SpriteAnimationComponent( size: Vector2.all(20.0), diff --git a/packages/flame_tiled/example/pubspec.yaml b/packages/flame_tiled/example/pubspec.yaml index 3e90e700108..bedc648c4ae 100644 --- a/packages/flame_tiled/example/pubspec.yaml +++ b/packages/flame_tiled/example/pubspec.yaml @@ -23,3 +23,4 @@ flutter: - assets/images/level_standard_tileset.png - assets/images/repeatable_background.png - assets/images/coins.png + - assets/images/snow.png diff --git a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart index 15be9116da8..4d2440003d5 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/image_layer.dart @@ -52,17 +52,17 @@ class FlameImageLayer extends RenderableLayer { void _resizePaintArea(CameraComponent? camera) { final visibleWorldRect = camera?.visibleWorldRect ?? Rect.zero; final destSize = camera?.viewport.virtualSize ?? _canvasSize; + final focus = camera?.viewfinder.position ?? Vector2.zero(); final imageW = _image.size.x; final imageH = _image.size.y; - // In order to recover the displacement w.r.t. the canvas translation, - // subtract the center view vector to this accumulated offset vector. - // B/c we will wrap the image along the axis infinitely, add the negative - // of the accumulated offset in order to cancel out the layer translation - // and bake the offset value into the total parallax term instead. - final center = visibleWorldRect.center.toVector2(); - final displacement = absoluteParallax - center - absoluteOffset; - final parallax = absoluteOffset + absoluteParallax; + // For infinite painting, we need to recover the displacement term + // from the canvas translation. + final displacement = totalParallax - focus - totalOffset; + + // If this image repeats across an axis infinitely, bake the offset + // into the parallax value instead. + final parallax = (destSize * 0.5) + totalOffset - totalParallax; /// [_calculatePaintRange] ensures the _paintArea rect is /// big enough that it repeats off the edge of the canvas in both positive @@ -90,7 +90,7 @@ class FlameImageLayer extends RenderableLayer { _calculatePaintRange( destSize: destSize.y, imageSideLen: imageH.toInt(), - parallax: (absoluteOffset + absoluteParallax).y.round(), + parallax: parallax.y.round(), displacement: displacement.y.round(), ) + (visibleWorldRect.top, visibleWorldRect.bottom); @@ -148,9 +148,9 @@ class FlameImageLayer extends RenderableLayer { // Calculate unseen part of image(s). final unseen = (imageCount - seen) * imageSideLen; - // Wrap around the target axis w.r.t. negative parallax. + // Wrap around the destination size. final coverage = (destSize + unseen).ceil(); - final wrapPoint = coverage - (parallax % coverage) - 1; + final wrapPoint = parallax % coverage; // Partition the _paintArea into two parts. final part = (wrapPoint / imageSideLen).ceil(); diff --git a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart index 437ac57a961..8e5f833a913 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart @@ -17,7 +17,10 @@ abstract class RenderableLayer extends PositionComponent final T layer; final Vector2 destTileSize; final TiledMap map; - final CameraComponent? camera; + + /// A [camera] is only required if using parallax effects. + /// If one exists in the game tree, [camera] will be assigned to it [onLoad]. + CameraComponent? camera; /// The [FilterQuality] that should be used by all the layers. final FilterQuality filterQuality; @@ -25,11 +28,11 @@ abstract class RenderableLayer extends PositionComponent /// The total canvas translation used in parallax effects. /// This field needs to be read in the case of repeated textures /// as an optimization step. - Vector2 absoluteParallax = Vector2.zero(); + Vector2 totalParallax = Vector2.zero(); /// The total offsets computed from our [Layer.offsetX] and [Layer.offsetY] /// and all parent layer offsets, if any. - Vector2 absoluteOffset = Vector2.zero(); + Vector2 totalOffset = Vector2.zero(); /// Given the layer's [opacity], compute [Paint] for drawing. /// This is useful if your layer requires translucency or other effects. @@ -151,11 +154,11 @@ abstract class RenderableLayer extends PositionComponent // Discover parent layer terms used for the calculations below. final parentOffset = switch (parent) { - final GroupLayer p => p.absoluteOffset, + final GroupLayer p => p.totalOffset, _ => Vector2.zero(), }; final parentParallax = switch (parent) { - final GroupLayer p => p.absoluteParallax, + final GroupLayer p => p.totalParallax, _ => Vector2.zero(), }; final parallaxLocality = Vector2( @@ -178,8 +181,8 @@ abstract class RenderableLayer extends PositionComponent false => Vector2.zero(), }; - absoluteParallax = localParallax + parallaxLocality; - absoluteOffset = parentOffset + Vector2(offsetX, offsetY); + totalParallax = localParallax + parallaxLocality; + totalOffset = parentOffset + Vector2(offsetX, offsetY); // Strictly apply local translations in our render step. // diff --git a/packages/flame_tiled/lib/src/renderable_tile_map.dart b/packages/flame_tiled/lib/src/renderable_tile_map.dart index fdb62dd04a2..71c565f4dc0 100644 --- a/packages/flame_tiled/lib/src/renderable_tile_map.dart +++ b/packages/flame_tiled/lib/src/renderable_tile_map.dart @@ -52,10 +52,10 @@ class RenderableTiledMap extends Component final Vector2 destTileSize; /// Camera used for determining the current viewport for layer rendering. - /// Optional, but required for parallax support + /// Optional, but required for parallax support. CameraComponent? camera; - /// Paint for the map's background color, if there is one + /// Paint for the map's background color, if there is one. late final Paint? _backgroundPaint; final Map animationFrames; @@ -437,6 +437,11 @@ class RenderableTiledMap extends Component // Automatically use the first attached CameraComponent camera if it's not // already set.. camera ??= game.children.query().firstOrNull; + + // Provide camera to layers + for (final layer in renderableLayers) { + layer.camera = camera; + } } /// Handle game resize and propagate it to renderable layers From 344c77dfc23c7e51abb2c4a877de2f038553da80 Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Mon, 15 Sep 2025 22:06:52 -0500 Subject: [PATCH 27/28] new tests WIP so far --- packages/flame/lib/src/game/transform2d.dart | 12 ++++ .../renderable_layers/renderable_layer.dart | 2 +- .../test/assets/images/map-level1.png | Bin 3059 -> 0 bytes .../test/assets/isometric_plain.tmx | 2 +- .../flame_tiled/test/assets/parallax_test.tmx | 31 ++++++++++ .../assets/tiles/samelevel-map-level1.png | Bin 3059 -> 0 bytes .../test/assets/tiles/samelevel_tileset_1.tsx | 24 ++++---- .../tiles_custom_path/map_custom_path.tmx | 6 +- .../flame_tiled/test/goldens/orthogonal.png | Bin 106169 -> 107272 bytes .../parallax_rendering_offset_none.png | Bin 0 -> 4725 bytes .../parallax_rendering_offset_some.png | Bin 0 -> 7485 bytes .../test/goldens/tile_stack_all_move.png | Bin 103311 -> 103380 bytes .../test/goldens/tile_stack_single_move.png | Bin 104741 -> 104761 bytes .../flame_tiled/test/test_asset_bundle.dart | 12 +++- .../flame_tiled/test/test_image_utils.dart | 37 +++++++++--- packages/flame_tiled/test/tiled_test.dart | 56 ++++++++++++++++++ 16 files changed, 156 insertions(+), 26 deletions(-) delete mode 100644 packages/flame_tiled/test/assets/images/map-level1.png create mode 100644 packages/flame_tiled/test/assets/parallax_test.tmx delete mode 100644 packages/flame_tiled/test/assets/tiles/samelevel-map-level1.png create mode 100644 packages/flame_tiled/test/goldens/parallax_rendering_offset_none.png create mode 100644 packages/flame_tiled/test/goldens/parallax_rendering_offset_some.png diff --git a/packages/flame/lib/src/game/transform2d.dart b/packages/flame/lib/src/game/transform2d.dart index 8d81ba4ec72..d289271a571 100644 --- a/packages/flame/lib/src/game/transform2d.dart +++ b/packages/flame/lib/src/game/transform2d.dart @@ -54,9 +54,21 @@ class Transform2D extends ChangeNotifier { ..scale = other.scale ..offset = other.offset; + factory Transform2D.fromInverse(Transform2D other) { + final t = other.clone(); + t.angle = -t.angle; + t.position = -t.position; + t.scale = Vector2(1.0 / t.scale.x, 1.0 / t.scale.y); + t.offset = -t.offset; + return t; + } + /// Clone of this. Transform2D clone() => Transform2D.copy(this); + /// Inverse of this. + Transform2D inverse() => Transform2D.fromInverse(this); + /// Set this to the values of the [other] [Transform2D]. void setFrom(Transform2D other) { angle = other.angle; diff --git a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart index 8e5f833a913..d623da1e9c5 100644 --- a/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart +++ b/packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart @@ -190,7 +190,7 @@ abstract class RenderableLayer extends PositionComponent // B/c sum of all local translations w.r.t. parallax locality is equal to the // products of all absolute parallax values followed by translation, the // scene graph render by Flame produces the same visuals as painting layers - //using absolute values in a traditional composite renderer. + // using absolute values in a traditional composite renderer. canvas.translate( (cameraX + offsetX) - (localParallax.x + delta.x), (cameraY + offsetY) - (localParallax.y + delta.y), diff --git a/packages/flame_tiled/test/assets/images/map-level1.png b/packages/flame_tiled/test/assets/images/map-level1.png deleted file mode 100644 index 541b07a59a88b16dc03efcf872fd201a90347ea6..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3059 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 - + diff --git a/packages/flame_tiled/test/assets/parallax_test.tmx b/packages/flame_tiled/test/assets/parallax_test.tmx new file mode 100644 index 00000000000..36116cb5757 --- /dev/null +++ b/packages/flame_tiled/test/assets/parallax_test.tmx @@ -0,0 +1,31 @@ + + + + + + QQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAAA7AAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEIAAABCAAAAQgAAAEIAAABCAAAAQgAAAEIAAABCAAAACgAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAACgAAgEIAAABCAAAAQgAAAEIAAABCAAAAQgAAAEIAAABCAAAAQgAAAEIAAABCAAAAQgAAAEIAAABCAAAAQgAAAAoAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAAoAAIBCAAAAQgAAAEIAAABCAAAAQgAAAEIAAABCAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAALAAAAgQAAAIIAAACCAAAAggAAAIIAAACCAAAAggAAAIEAAIALAACAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAACwAAAIEAAACCAAAAggAAAIIAAACCAAAAggAAAIIAAACBAACACwAAgBkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAWAAAAFgAAABYAAAAWAAAAFgAAABYAAAAWAAAAFgAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAAFgAAABYAAAAWAAAAFgAAABYAAAAWAAAAFgAAABYAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAABYAAAAWAAAAFgAAABYAAAAWAAAAFgAAABYAAAAWAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAWAAAAFgAAABYAAAAWAAAAFgAAABYAAAAWAAAAFgAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAAFgAAABYAAAAWAAAAFgAAABYAAAAWAAAAFgAAABYAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAABYAAAAWAAAAFgAAABYAAAAWAAAAFgAAABYAAAAWAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAWAAAAFgAAABYAAAAWAAAAFgAAABYAAAAWAAAAFgAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAAFgAAABYAAAAWAAAAFgAAABYAAAAWAAAAFgAAABYAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAABYAAAAWAAAAFgAAABYAAAAWAAAAFgAAABYAAAAWAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAWAAAAFgAAABYAAAAWAAAAFgAAABYAAAAWAAAAFgAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAAFgAAABYAAAAWAAAAFgAAABYAAAAWAAAAFgAAABYAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAABYAAAAWAAAAFgAAABYAAAAWAAAAFgAAABYAAAAWAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAWAAAAFgAAABYAAAAWAAAAFgAAABYAAAAWAAAAFgAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAAFgAAABYAAAAWAAAAFgAAABYAAAAWAAAAFgAAABYAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAA== + + + + + + + + + + + + + + + + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADcAAAA4AAAAOQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3AAAAOAAAADkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANwAAADgAAAA5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAA== + + + + + + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGsAAABsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAawAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAawAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAawAAAGwAAAAAAAAAAAAAAGsAAABsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAawAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABrAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABrAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGsAAABsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAawAAAGwAAAAAAAAAAAAAAGsAAABsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGsAAABsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAawAAAGwAAABrAAAAbAAAAGsAAABsAAAAawAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAawAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA== + + + diff --git a/packages/flame_tiled/test/assets/tiles/samelevel-map-level1.png b/packages/flame_tiled/test/assets/tiles/samelevel-map-level1.png deleted file mode 100644 index 541b07a59a88b16dc03efcf872fd201a90347ea6..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3059 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 - - - - - - - - - - - - + + + + + + + + + + + + diff --git a/packages/flame_tiled/test/assets/tiles_custom_path/map_custom_path.tmx b/packages/flame_tiled/test/assets/tiles_custom_path/map_custom_path.tmx index 9d519c8531c..d5ac1b37fc3 100644 --- a/packages/flame_tiled/test/assets/tiles_custom_path/map_custom_path.tmx +++ b/packages/flame_tiled/test/assets/tiles_custom_path/map_custom_path.tmx @@ -1,7 +1,7 @@ - + - + @@ -26,6 +26,6 @@ - + diff --git a/packages/flame_tiled/test/goldens/orthogonal.png b/packages/flame_tiled/test/goldens/orthogonal.png index 764faa2792c7f2d0870d34e6a4de020334fef53d..56f1b88436f70749130220b8791605995dcef70b 100644 GIT binary patch literal 107272 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
    Iu21eEE=-hz4*GPeA|sK^$wjx${SvS57>n@LRD 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

    k1Zh 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� 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 diff --git a/packages/flame_tiled/test/goldens/parallax_rendering_offset_none.png b/packages/flame_tiled/test/goldens/parallax_rendering_offset_none.png new file mode 100644 index 0000000000000000000000000000000000000000..1f8d770d118ce03a5cd6f659f88c01ba4059ad04 GIT binary patch literal 4725 zcmeHKX;f3!8oeMjP#KDCKno-w5I~s(l_;ZOFjOpB5wHe9 z<`xtsVGsc^Bmtu$B?uTGBr+so!Dx^q7($Toolw^s{=R>2EzVkJ-F5Fh_n!0Z{SEv3 z^+yk9t&jCTh9F4G)y2sRf>iyKQ+*?N(iU-j6kJr|yqq1Oy529|fE%?qM^_(pFjCdS zE<(^|BUdK}pED)XV+?$r?-tmLV$O<+depU;!@sf|Rg-+MnK}JCP));`SL1Koc<9p< z;N;J0GCjBJd2}QSC45rRk#J*IkDHkO(P)=^YF`<*Gs)J-HuwC*8SR2Me3HOA?$&2u z)Ag~A!2cftA;oFUA_VjxA~}9`Jf0&_8RC>YXxGi zH0llnAqPTKp!h1LD)ibt<0I%<;s3CZ7$i4FC|L5S>#VHQp`6{M*B_$t zAb};8MHR$bZQr@qzG4Uy6dbYuf{Nd;*%t;d?XVT;La$=-#SB@{ zA>ThA6%E@2-8Y0C$gUpFF;*npVydR^+53Ds&50w1(@B#>hK6+ud(6VRwgEsiwm{Fu z!W4%@60}a|jZ;&e0D^#{$@9+M`(grl0#r8Vx+mnJ5Ik-dq&I|g-%?j`nK6AR$Kn%% zQI(&=4~G^}^k4&V8rYLHL(AS7-)}a9c#gR_D;O3W?w|GKXPLO&e=r`cql2hxAe&J) zK=CHZ;|!S`W_Z^W1#%jK5*yNvd3T=M1E{%TX}831PsCpyrs|)Sd(1A#GP*{M73feW zbtpL9*?AQyGkrwSFUB?t;Joj!Y=!Yz|Jc>0q~@+S7&btyU~)Gai>5@!!A+>GPxTJq zKV9Qn%v9apVdqy|9W-+4Hw@0JwTo-1c{mo9Zt=8YWAxpW(0dQ;trD9Mfzi1^c;af* zYV;u6z~S6S2QR4|r!CLrwwF^g$NPJRYTK7*WHX)brdQhnSc`$aiFcs%XR}fTwFgru zbA3?wS8n-Ao;*|@odiDy3cAbIk&uQ$L))|g1XG_IjAJ1Yp`hY>S^14jGY1fj z<@NiREdQ2>?yEL`Yk}=n&lx|N&=4$;%BAvOc0Mc$+Gc@Z>@MIr(992=hi?2sH>L$` zpsQV*9CjO&5>!S&HHFp^_vKD66O!k)Axnc=(cPZ>jhoW* zy2N7x;~P%1U*1I~*iDhAcwN!iQTLSgd|_KwqHUDUz8b4xm?s*Hs}%Q}?#TXOH+&I?LLhm953v{TK3J-0k?l2*bKD}QbStw&Lk18C#iN{)-eZiB;J%dlrW#`LDLk zsmXV&LLXWBUA6$y@NNankCJxsX+|%hH(-*GWxw}+d&|C&o=f)Oeu}%%8OBPb_P3Q2 z6BDCHQ{L01L2iW%>_&~DQ{#*(eBGc`;|AGS(Ie= zy@ox3H{_yhCmMlY=oKetw8%<)i?&hv-v&3+FbR6c?;po#Ss1|qkKu0%>~yr0SY1T+ z5xS8Qz-ZqX9=>EL9KR@CX3vcNRG|#7MA%dXY>Wr1KqgRXy3L*hJN?V$aErL}Y~L46 z+`XCu=8dCivXy9A-O+(XbNNC!l{P3|B z%w_Df9#W_N^e!|D5D9cGS_}m~=g~4*`urEuwnB6wzHI9g#c|_`uS<1gq>=gI`dR*g-=mA0a9 z8?1ShglrW&H)`I-4Hy{-SGa)=fkp3liEaZB1&aynYnqSLD7aLjO#G;@v^KJypAV*g zEbK+J2`$NUWOY$6Xh1I&(!JcQ!63PF)QJqufxFUse>TO^BRKZY^_qIxL03_Y=wKK=qWAj_DSs=X?Mwmoex3!h;#mR Z71sIVlUU8Syk2Gd?uznos&foE_fJ%bH6Q>0 literal 0 HcmV?d00001 diff --git a/packages/flame_tiled/test/goldens/parallax_rendering_offset_some.png b/packages/flame_tiled/test/goldens/parallax_rendering_offset_some.png new file mode 100644 index 0000000000000000000000000000000000000000..6295a7c0475b1a0c77407a15a5f788e59d3cb17d GIT binary patch literal 7485 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 literal 0 HcmV?d00001 diff --git a/packages/flame_tiled/test/goldens/tile_stack_all_move.png b/packages/flame_tiled/test/goldens/tile_stack_all_move.png index 582b0c4908f84a060872ec73a9d38829d346976f..091c628168cb3a7be9ec6271eb236ccc0471bc4a 100644 GIT binary patch delta 73791 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�v-M!# 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%0ANP#nw4jTn?r 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 avx@X4FRbgW{^1S~zK5!hR7#bsL;nM!#V7s% delta 73771 zcmYg%byQVP)b^!Q8fobc32CIcba!`m2~vkHX+*laySqiYyAhB^r0c!}4vP!`FQFsOSqV^+Ux;|xyQAdxOAcqjX2 z((X2@{bzg!d{HifSM3l8eBLkmXoOf(Yl?p{y5h(7w#g1=1@9vw<7v}0%IN90UN$Dg z-z-#8?XJd?HQF8Z+8r9|8s-+_8CQ?ndOPA~X8KDfG};2B!W!xp0}%lBf!Y4+&)ZEz zOvp3IBlvXDuL+ewnVdpS zpvY;2CPaVFKLG>@WlHWSq?^bDZYkgyQRp!GJvTyUyO@LhUoY08rPVuJ>0_e)$6V`@8=}DO+I` zPNscjv)B6|RfJ(8Tku}(f-929?q#FHPnp$WlLZRYnbpJ9G5=R`@gOin5KO_&F4^u; z`=(3&h+Gl+tF89C4(2TKR&Oe*Y}UFeoiB34i?Npt#l;71Fp!KOuNc5z7TP+Yc6{nn z1_rdwaoR(ZGViy_s9!_tkq^z7P;ma!QoFN?vL_qzOU>^CzW$rW4*kE`=YwobZ-^;dw3fWL521Ft zhFsfyhbu`~tYabUm__9#MCiJvdR>5?3F{P(FW+F+M=VjfAv%Z@#qHq!+aHhJ{x^F{ zlkwdmTw^dwK*mC4euVXI18(A{gY+oF5JpWGCT8mlzND=S;|K*w&%bNLtktJd^n(6- zBC$mB$#(UOQbc_fo8#>6+{7-GzQug69HNqTq*d#|`Re{+n9+D&!yKbTZ}ho!V8(!u|YZVsx zy8R)yfocjMDhwT$#gN76v8nHJ7mHT0C?z{NuC7zbjS7IQVpW35AM)admgjUxn_0Md z0weA|HY`jLzK~)H&{NJ}7uYdo0)l;}KW66d8J(ZohNkneiWLf%I&~?ekA}IC_8J}` zs|mLf``_=_N8l5+g1L`cFe#|)#)7ZiLw=e^U%S7d$XUcrNyR+;gk+5@rA=)W%odn# z{sIkK$qA+mRf$q9rivkvt+7r1Q@OG78hyjfzQ+;w5Eov#xhpCTM_bUZJIc9wJ(dV)Vf?QAF-iaU7_E1XXGwYy78$U zU$x^(utCh-gfSeJ74jN3()rlwg_@nE^pi^kS}agv;P4aN+qZHkP3<0>?*!*sJZr@h z=>9y0qMiZkjF6RyH_INn!6p=ZtSzY8hmsaeNyj$&BttR3gUa1@aQG7a|ITC@F+w># z-Lqb+*XuX@)Gv&;Z?VQEWKLF#FD`QXezTi?);47|LWM`>cAz_1F_&p3<}s@Ch^A=K z)}yGfkus{P;+0=pwIMczsJS>cM9l$laRKg>g|td(==8HW)^C$^u7uVMQ|H(>XG!?6 zobWKwkR_jOE@~MpcwPvLA&Mr@nGukW7IeY~Xe+i9ue&$E51EDtAhhWRC`ihwLs8!U zHCVO(GuTvyCgt9PrUNk#XRTNCk~;r-CXwpmT5s;%5Inifjd^t-nu`2ngE_8fJLPnQ zb}XvStfGRBiJ2Y)Dh$2&(2eGxX+DALKb`&$u=*_a9NYIwD^uLAoGHlU;bw3Suc`L; z@ljChNNIH$ihKp!kL=J6qT6A1=L}N>tU`as^eF5{oZ}eI;-WK78ZIpD# z0J<4Qv+gHSIiJVOo<8xN;e$#Nc#8&!+pa7vU=4iYS-EK|AMvmk?b9V85*zsRzpyEi zIMsOlurBi}IU1+YTE^%(rA(_q1(gCV60E3rB&FJSwvN#zJcdBT?zVUh$yxV{YNZ_Gsogel>WWBIR(4QOnHP}JZXptqrEJ#sb603g&NH?c< z{3-aCP163;E=kk0on~B*OO2Qi=J%#`UQm?;pC?*;+XotLk&llFIXIvtW2DB$3c3n) zdAg(PVkm1NM{*}X*5oAjcMCDS7VE-&-RZ+0OwZE90Zb!B=+POv0Bsspq4#Y3j4w#ZrJ{vM&lm_9pJqF@qQgSx$U|==6{eiI-FRqm`@i=Zxa~=1vC-_&+-=_$x*EpZD_4=W6gFNV zVmqb$3os-xX*)0-6I)d%BIWL>ATX>KO+?QJ=$6!nrpzjGU0zF|d`V_(TVwx#J!Ujv z`WOjA9;@fT_?41^qA6AiL`m_9&hOm&oW)4sPbjG{o=67aq991G7#TW961GFJhg5*E zN<5$6LS)o2{GSSQJLQ?TL;$v-&gVflcK>5 zz!&d{o@R*P+Dw62BquEa>Wc+=L{XCBZxbj5`@MQ^W+~o2jX9owyk>kAOSrDvzgks? zB2A(*L18(NRDLY_Sd8OzZV-|EL^b^7Jq?cw70jHc?=OVc#dEYphjoggb3yb+QcTQC ztG~Ky64ul5P`AiA=N%XvaY+GP4_^y#-oje#hi)U_uXz@z1PkLsd1eRS1${{MwF&Pz z2hLZo?(w_PwmJ*C4{XB>AEOm!QlW|l#(6(@A37Aj(YwkxrSo4^N8zSP`^%`YfB-lP zM(Ea+VE+L7(C5wK>ye?&M?%){z5fnnGW4%Zvz!|SJsTPM5$8z`fU|UmyGk8cO*Dyc z%wSK_iflT}lJIPId#pBVM{cyv8zLz_j#y&VW?Vbk(tFrnKf3z~PieQ&X<-{R>;5?w0)hg6x4c6j@v&TW3BS6nmfH#g?cfzgvq+Hj z&-h`DFcP$se>ecHn13923K)7Iei&ijry3VHcA!kPTgJWJ01B<=Z6g*o7{*Rs3OF3g;| z$!y10QCs1lD%NYydTX*WKaM3Z-gZQgPzoc8$p8)S0`6U7G1HZv2*r~LzFXXEP1&CJ zwE7ntGa|43K_k81Y+QJ`ZNg$h{Jv(9DZ#~vY#&373Qzr)_wQXI@C@ZHevhV(zQ9eX zfjov@ASmf0_}|6@G@r;e5>>h;bUch7Cl{1GuArbuVQqdWK1Guz)gG;I$5x2UNeMc)-Qu7Z-IzZ{d7HmV zMIm3n;q83a=t0II1}bj#YR2kc9LTr8bo@!E`&o{D$SB9@R3}01Zz2Wj6bVWTZF8$ zF{mgh5|YJXeAA-irUMBiP|Sg!bj}&6C~nT}K9QmUKkdI)yrxDhT4?v!o7x?u={mFV z_2+{_Vf%&7FSgfv(>L86Xht;K3hi zUiwu9OR56ouI37&Vw+&$KE|-KJ}(+8DO4K@Vkq%G1F4|KPZ@KI@vBjY_&c-!iPAaL zj=O(5XC2nXI-hje0(s{0G1Arng070W%rTFg^cDzIdHqeQkYCbv$g05kKp{d=kly(q zrVp~d>aH}C$t+mu89@yWlsoOEzw4q6f*2z}k%c8k<58p8!vHsoB|K-_svepJ%KqB3 zAhGxjbqcYl-ZYd!sndv6#{?w^Cb*LZMu#z-YKvbX3U>O@$}Bq6{YjXsyqU&6Gy@OXbH{NI1<}wJrgN4_ePa$JnRT8wXigY8C?~Hhfkf zh6LO5auDb03Mn{6;lt=Oi2LQp_t59Gbo1XDzx)FX*0fB1tz(Bu(;)62r>ULldPF(C zQOT@lysTQk+RSF@UX{DStGG1M+P(sh>Be9`qsm52no52b*o#NesYk+!-23*6pL!*J zyay|2YbhxyAU##zz%(pW>3bsZcAc5e#Qe=Elu%BVhEV-0)7LK6J zvk>-#wN86w6~kJW{>~5FkUBF+%(1gn3(LWgSM<~v-{bOu71^lkW$p~HW5dI|bo=Mp z(gy#y9yyQ4spgmpS$H#8WF6C5vp3=tL z`siH0Rb{IeCR!n^#-qCDsiWtlLcExg40e&-<=B=V$%DWmhlv2!RV{7 zl!DLvvT<6v;IFcRB{cNAF5M_5HOdEE(qvQ&DmbgEA+cwj zQ)EEpd1IY;iBXKW#HW!m$Q#uUJ!rZ`#Gx_N8g9`5u}z+HRZiO0dn~>Y0X^!=&6)l# zmI9X1o&TklDUTT{d=vsY{^%(3SWlHcbQqd6 zBt)#WR18!Iv$1W}e(tlt`VM}4Po=~vW&?Q5JUV*4k(7W?70N%z%;s3}S`0kCUhXh# z&UFf*DqZKqYxynuV}M+n6+WeMW_LYcR*grK7F~@x*~(!IT~$y}rw$zC48`uC+tUW; zp2Ncif}%-W+E&;V7AcPhm#w91Z@NKCx7QPWT3@oEsgh-x)_Kfk!7Qf3&&LFIH#)Io zWsxDj<75A?!jM?&8c{nG9t!q%M*P89F?sNqa52mYBuaur`B@*K>+7MlX^Jc!nsTc^ z8t$Ot({8!|Ci16?5Plv%+xIHWS)tFQP&oWwAT%WMkA__Pz@4_o?jOnu!bYGw0}}9_ z*2{3bnpw*{TaE5ykN|e^$kgNOKRUau(1YWK+!?y~98I_h=ELr_CJIR=`lB{C3gYj< zsb|<#YvI0AR6MMdzs`q@S5fe-G%vWkeE6LNK1@R5%;;W!=ku(-^>#u=M#9ey9hDYm zC+oc`gb68B!rut;c=&C15Is(@4zE!!6YB&wkJ{2F`PD$hXF&HtiarCmr9W^vidTC) zA>enp&|7T%DhV16oWaD*=J*?mdyXy1oa^M*IF099XMGUrc=LwxlokgcU!qX?*gj2^ zBi<@tf3SSkXE=OncSQ=eWK+?-?maC<3D?Ac1ZY$9ZAH1xXZbwUYKfio?wB!uPBX3` zysn3IDerbJfJ#Pw(a}|ZW#?!`D!P2$5=SKZa*4`0YB(y7^~gXwZArvFk);53W^Mq< zf*^O6O{iTzfGQxCWDPMLbJgcmQ1JN}J?HoJjS@7x*X>YBYid3Z_%5HjY6n|+OVfe4 zck=z|?dapz6Tt0_q_|JazcXPo=I^xaw_A){RRdV~ueADo-=ePG4i2vAtMD(m(Q3Uvc+k*epIgd=ly}hx&j8Am>o* zqsFDSh83tQqyrf$nZl3@rY*Z+)T$Y$Pbse^)GO{uk(>{PW&l7v6V2XejSwV@#i8Of#ZVB~eJekr)`ff)f3nR;GRqoL~+}HkN$C zjmUqStoNK|yii2zDUPAC@LM=-Z<5H~A}&tQp@#jgruT_hubWrWMnF@ZYfSLQ)l5G= zhOoO5+pr1h({%wJd~nZLpEUpGscAV9MLIUuk^(u!owv#_S5x~CkV6PvnNN6<>+w>ZPc+l^9b7^4o@3jkoZWk^D8#R13QPGZ28mt z>xFG~%QC}+C;Z7=qO z6V`H{gGOoY#pg0??hi7ZAJhxEOtz%0>eUb;e&jsvbZn>W;ff;zk`!#Y8)~z;Z2^+1 zAJa2DB*KqMNiVd^_mIHMmy6kWG=nLwKQ8&|&WP(;Ln5x7j_2NvHe)u)AUAt=q>nc2 zHhb%X@O>VzD>feDwZ%A)d;FE6Ugp)!(1$P_mT0Q98&QpN5N zc({EfAXX*Rf+KG+)TJZz5$~1Q)C91N{h_sU z{AKv^cmK!9nU`2P3kVF^5&X4gIT2mnWMFu{{Vl3$UqP-_19fm*P8kkD|AL&DQzwIN z6MIETENs1hb?I?C7%>syhr59_8W=EBN+jhtc~uS-V-9yPRw7cL!SS^#Ec` z*(uP*KD0K7J5^%mEn(y%x*faG7M5L5cCFrGIX9U8<^4{N)4ulVD<(dhEf0kW_Fo5S z+MnF-_aao&Kx{jreqIkvXw~VZ*SU^9gAf{mMzi+s0d%OPtg3+1-J4G~<9XBan$Cw7 z>EW2D`=`UTYzCpQAf+FcwhQ~%z?w_DC{hFF6yYy7OKp!_{y|Lpi3m=BaYM_NH*cwF_zp3W~o%ybYD7v)OK8!$T)+v5nsOj0fN zRY0DtCVe%gaFyilvMs4$YX4@d3-mLE_x??GYX09X!2I2UF(#G}JkYI>B&oOyGkrTS7x42C+^7HmB zB&3Ajo1}?Q(z4@Y-KT;R?pqAGx-=ph@XmcZt2JIqaA!CUw^4$!>TH@f7LMpO58sHB zKJX=#JOPyhLBV)3qMG8@guToPmn%WDF(rHJa_wpa_ZWgltmJ~FT@~^^X-?pLY6kg*5maL+tEley_tfxceg#QGQEb1_?ewf1b;A)%oK9|>BDNx} zXW1h4-Dn#CyqdE#0=@cAF?+0aZq53el8XH)DieGCMshV;s$|S!3yhnTGI(&0h&SA8xAs=wCw|i97y0pBq+L zeuw1CX+5iOd#(;9X&pN*!4)Le8QbeuoBBBvpVOr>Mu#4zY8lJ#1Ne_EXV_>@+DLfj zbAJ(1ZtKPqP*0MpJ#d}tACp#-tHGAnwn#vg0tn}+b?j!*F1iG1aZ(G9^$YVtyLlRZ zdii&8$Le)R}uO)Ul^x%pwgq`s7f9leOF^W`d?!9=NRponF6S$}; z0N)qYO%!oe;&kz9CZVgqT(?+H@}T|SXnvPoHDNp!$iaOqpczV6h7+}sHYBNhnxdF{IE{t z$g6mk0OWZ$MC3St9&U+$?su^ccLszvBe}&$Wx!1}YLv?j{oH{FuU||ypF?{>nz^mC z2vLW-gv$)YKUUJkeNxHwW8-a=Ie5!J+^Irc|IY{IJQ0jcYLZZx*EflwG)e3fwL0}5^s{lh;MuAR9~|Q|Zw?v# zD*mqdE$7GO*C@@qXT>4Hdb~5SD%^Qh2Zi2EaGi1w>U&%uUnwT9P&OYHnyY{= z54=mBi!+2x{X|x>w}9+ms#^t?rx*^t5q$;4P!^TE+gT0LTfv)&c_mw|rxh zEeXVvmYIYye=V2euvm^8_oU%Od_yN5H}xiS@#a(M8ixt{Siol8d_~OiR>X|saVisl z(gxnu%{C91n6kHMpKO4UNXH0mIzmlO1;L})CIT&CCM~F(@BGzU3!m{?A-rh*{U=+= zg93Z*U2g4u73$cqH7+)xm+nWT`h)ssXxF1{fsGa~R0zFr-DKCI?x3K?2i&6~X0E(w zT1F${L>LVKu0fUwpe!N4uZd~&J;#+T$S*qFFCZ1&KJ2hDfB-)lU$c52QsCn8QZspd z!LerObIhXlhw?uLv0zNU_KyMaMZX5QH#~Q@P1{GpC!;(BJv~Gs_fFM5O<*1}#j_4n zmkPi#L_fEm>~(nl`C;Vwy)D!hc8Z=*Lmee(TVD^zL27A+S5Em&prg*R>xBR}w_c-y zPaWH;jGWI`C*9-EFp_WK3xj2S-9dlGSBBb%ycT6(Rm+ewYP4UY36)o{P?;ORi*x$?;=Y zld=QjWl=lwf}-*ZjpRFJ-*ZPX=R8S%TEX2vz~CH@(n*#p?FNkOH%1<7+-A!}L!4K) ze6H@3QvG0B{32O}8j6s-Fj+vEIrkMwgtMHu3=43g z*36KVNqLVsb%MehHpH&B8r6r0J&V_3vTbi5eAIVkqgPj2;1tc%Fla&`X0O)u;2mP` z-`P;*NMcaJH8j9!_lsyLMVi}PbRE>bn(<-Gftk@GtNW2Yb-6+*PFPe0{})8;54=rp z$A@s(O}nn= z2~g3QDzl}B`H=K&jV)?a9RMGAbBwD!{f;L198F?EYF)Bmde`kCA%XKQ>g+3EN8nrh=KAs=O2#HF{uqvMZZ#7hKgb|MIN#Pq7l zgI@nAzW!mZyxv5((3tI9MXlICoDFP9GC_qWBn1S9GWj7%A9Y+*dMJ9NUAEmj=ZM*2 z?349$(I3*y;-1kU06pUHefVLv-}ABIt7dE$GG;pY*b$u50u~4qrIM^g`kqq0?U2eB zk!W_Fi3g<^{zFr9E@85DRg|r#wN-e|$CO}LyOS(cVZAZ6)1NzD>3l9zQL`=uqEbYQ z1<@)bCAiqyU3x(DswAyVeIwy~kGzh#ipH~nKB<Q$92GzwdSWXU!?iY($GzJ>srY6E47-ds$!od&Vi;h)0-Xk0jc>q zpXcM1F4jJ(xc#$c+(3u30`Il#MNi;_;PzslmbM01@_u&%z>;qu97D3WpJ20Opzmmb z-?X#|RQJH6&hcwhI2xo7>&WpTBG2_c22AL2_O->O5K^;_x=e{T?_sQ_N=c_&Yb(sb zVI_o;=;d({-%8SCADg6&TP@G>%uIbn>^bke-%rPD@`b@vz5L5@(Ra671-74hNwNB7sv$RRO7$JV8KQON28yWI!jGrAk2;F=g(Xen=nb9Nl z02IGbJzm#1?7X*n9n>I(+=#S6ZF6f&vYppD6tpvbZpaEHCm(f=@!{&Y>TO4n;Pv5`_c~~kezi+;YlAI6;e>vH5_XQ* z_Jk9a`ZL3uZocYg_ff3jnREYp-a;AE;yaeCuF}x=Ytxo|a9C1MR%m*_Tp7TF^&Rhm zGXh$`*h5N&BW6E>$#hP>p4;U#7~Ne=GSSh8RPTKO^KYU#9=DJp&d1$!gy-2EdoBD;g)~cGf$T7-+Pq)@t&i0Pu<_veK+YnOm@-q1jh6O(Kh*3OLLo8vF z0%=V!quk@8A#btUXRf5osvRs?Q3iggg7FDELVZ?b&ORPPG46CR3JxI}PQ)liSbNfn z+>Oql+{V5dtq^}YkKE?FzMnt0x7!C(9q6$vmik7{h+)C>WJ(LCM{U7QPBGE~WL9{I zmIP~NPlo0hN6!(*^+2|oc$$N$?%80e%$ca)$FdcGQL5}6~mpP!)J zWtKR7)*dILQW?v;#&zw*UqAEQmu}4Yt)CA{M*}bW`m@Mr*MQ6WL_)SjF{-}Z@Hnf! z_iKE?h8^w~pVwZOYcsiWJy2_!OoJrV1 zPhX&T_xrzvR?;W3;qq!4&!0&wUuRm}N_(Ck32kko^xORtX*tHmk=)vYKj31BjOIq~ z&tjGH)KOgkfZuL3H~gwj$pOx}&&64v9Qz~J$R4q<<&{gPZV9H>vI8O(oqCL3G!y0t zMLa!X9vGC$2_6LL*#6;fm+ReZ6IXeSLk}m1p216C949>9HOGJqVgldmq(*%i)O4Wj z7xNgltgBTp;vh|rBu0o9+!p2-)x$md56s*yk5OHp6b(1DNH{;bd!o7B?34Tm+{W-rg~&sn}w`nB&p z5wpofkzzJzd>nGJD+bfr42CDfw*O+U1x&R6e zGwDRi;8N<>vcRInop9^OgFu_wOoEZdBLy$!kA;c9kChwpt+gB z_od7b&Th2lXb5e@2ltSV-mq`qQvGcj^wrI!!-o{ox3+q5%t!8~ zV_o#RDx6MIAT?JAjZz1bF)>LI3o>2wp;+6J^eC;PM3gRgsd}(-002X<=Pl9Z-Oz1w zs~P`0V_rOy#Q9@(h9nl{Ben%F`n2?8C`eQo(O6w5M-5KKKHP|c12N$x{gKrW4&*kg zZ8(+;9S9pbg7b+@AMs6p!8QTzG2I+SryaKpC)gl{bvBiIk&2;SkNI6YJN}uWj!@!# z;EX%;;)m9v{Vc{KAS!ewKsXr{CxTwPn^RM((!cS>+`;Ei9DjA;I~{lnGu^>zT8Y`6 zRkb}Pkgzkny!GA;Vc#5HAM`7Vz!Gujf?J&mub&eWz@G`IamT0W7El=Le@0vbuvu>5 z6`hx7Sw77;A4mFdBTd}g7*^q?+}{Z%H0FUH{By2zyesa3R_v0Xam59J@6h1Y3LP8~ zK#$evDh91`a$7gqpl?h|@cfY!;_InK)5?G*vxPR9BX@2i4*6A&j_$ixrPNj5%%v%R zg8&URi$24}7L@6^LEm&f{r*0LO&KrGU-SchnuF7zixsG~wBlNv^9ODXfX{I5+eKcH~^uQ7A>*&t05{sAvkAXiHDWy6*RO} zr+YY@Wp-#TTk!BywmI3MHv!7`A7Eq{+w{OxvYv6^^L?$?fe_VF_*Qr<0Q zeJEuXyMQt@qydoBFD(2;lOjz5CEljr4M@V!(&ec2)2zZzI^UBYGq-smmY!D=Bfl z_-6u!K*;G#7Vy$yk6?3QFPbZQ74{QxU74Vp{-%NcL)(zG<+p~1e>+Ja_30?{!$&J# zGI!=n+Y*Aa95*C5eNr3PI=)eW;HpfMky)(A!vW+4quSMA7Rg`P*Jns*3a@;c_;c0YX6elJd8)_xA%d-aV6*5yQfWui9xvulH9exKDox zChn|beC5+w4O|9L?t+eL-tNw7Yo#%zBl2se#37T{Od359>+yjc@sT5VbcrPS82=~C z-cJlzqo!u`i0`P@4U4X3GLf(mCu(O#!H-ret!(%byhAI8f^`iDg|b!}hefVZ;>h&a z$5~Za3Ma=Mazi$kOY@D}y{opCb!!8NUX8tNdA@qeC7vySXkS#Bk5sr)#La7SD+%UT za->8wCa7SJlSBqG#S*F;MC; zChtm*Vo!GI#58vYo*UvCFMjx;9}hrv`4yn&R4hqs-Jl8{xWK!!jn-Q8FCkr$khbtfPT~AuqT6Vb`f;`;_zpKCZ16(Z`+^e2U|nxWbQd>gbv2Bkh@;Kh%AvI6%@7 zK&m`+fizykiKr43Jf%F}luoW%t0onkv{ZZxFSUeZMwgpcRmbJdn0Q@y>sz>_WhMej zckWxWRV_y(e!fE;YB<6SEaR4MqCLwFoZ~YltQl>#N@2 z!=-MRmBFWHpJAAvR!lu*_52a;k#x=TFvfjSvt#58>|{Xx;pO*MaSD-#lgnq8GXQ9O z)dy`FZ>`>Y{(OG@=>c$H^@h_1(t<(uL+80ov`u0KL%Tmt`8mXlX!dwbEx?cl^oS(f z*=bWh0~3b{D$j}v*1D)#NC(bL!ceF8(8c*WqtipfKmbgUz}Sc12u8Ewu}IBw(G3d| zAK8e}ETK;BvU(@x`I#0cfBrmV0)+L8>l#06(sbj;y>DTZh*X#f`&z2r2a1*ZLJK}KK1t+#3djQ0TVr((Q zRTZ0V8}_57U;FaM1-X=`vn`S$&QY093nA{)7-6l-1li;5F?;-%%RXC>$J%{GT79iST+@v1M3rdY8ua zVft||xbR@3heh!<;|t9_7a;48UMn6ekJIAfpPEq8*{d##nT#(8c0+I~xWV6rqdV@O z(FI4-kPRFCqZh@5xe&AigoIp3+OHCq>NlbvH`jm~>cG)>M6l1crwOdn2SWG4uk}`O zZR2`n+pan=<>iEnRrG%zgCT8f?*!E#e&Y5LTg1P+SHZDDEEm6l(V^?dEhuB2ImrDS zDOFVl3u~m5Ot`Lxc^t`@0x8w$@9)yZiSBLvRPEcdi@v0%KJ%TZwNw}|+!G^OdRup= zCyE=yC>=p(79f!87({NAtH4?HyKU9Tq(v`Zb))3tKXe+=o$7r@{+zmcDW|Au{J3Vr z!p49s74Jo%<@(E$h>eL(;W!B+kt(k>c!7{YS}qv@BLyECI*?s8v5AKQ!me(}@%U(k zF!@;i#t8<(8kiM``G!ogzf;N=cZ0>E2?iG4NI^3-Fq^EoH7+k!9=PMSmVb>~NbX^` ztJbjS0QWVVAg_nIM~^(t3m{31CNsRUBT36$X~Bc+O(ZL!iiAr`vA-O-ODY6Z`l8K! z!Ph*$yjk?UqqrH&Yqfy`hMU4aK%sAaM$rbJ|F0^&Jq| zZ^aGi>AHR@i-MJ{3CTM}7Gu zXz=+Jcv#CX zrl!)S&t*IQs6dm;=(QIK!$NE?*a+f58oj>2YSZX$Y^4uVHjQ_Fc1(|7&4f3cD4aV8 zzhmO?NMgy+CQl;3iqBIsjf#YVl{Oq`rICeYH5`aeppj59{|QgJ^{wcxQK0}a+kXLh zWe6KtCNB9n&IAq6v4t=nB?jLwRIKHI25DMEa5YNOiO^c3>O@LzuFoS&@k&aCPDlr_ zu8GZxBkyP`-my}foQ8I0*JB`EJxs^lkqV!H7rG^%sZ3g?UOx}BhwE6=^S1@Esx`&^ z2AT0ol)i1><;C(EK?`!>1!{{dtWcwefk}Tec=%+Ppf|t;`_@s*G{ove-;=<-YNnq& zf8#Wd5QB52sH^OvoD-Ge)WzEJ_4)Ls-<9Ot=`x8$aHgHw`nSY#xVv3hb>qD@dtaMO zA9(^97h7T7p2PY6R=J6h_fu#jiF!Gw2%^3fbiKW+)~!OY=?6=0o7M$=(O(Q?t_^*W$%z1!!CRfYL^*ZH;lnN|s}#{>2d0-U@M$ebimgo8qz zF8UUNM0)nQQh&iQB9B#OtJ53OJ}T?9Cl%=XNc9#Eg^7g$;y%u1e_N`T%wMJ65mp&t?sr$HGNUgo zXHWZz&6!OVFw`^wK@ zJ@!9nxa1KL2M^Z>b6h>NN)5NyY(4Z0ofHTAdAj{2;p#T_EVV|5F+yHLYW=o}ZJN*O zJ}tqsbh?l^ApVcd4Nz7hxHF5`<}>i0vMDzo^Ymj*tFYJKbJ^aeiz{9bAh z#_NkFDzZH9@`cVs6R`z1%R=rU8VOkJwca;z;iq(Ui3?Xt^7sk#LON>AM-oZ%m<#MF z=c}c4vS~ZKU)oXh!kZ=Ux7J#;gjVG(+p4J3bx}0GwknyDrqfD5r_xNVi5SGNF)WY; zi+^(?FQo_^BMc$bq?(`x*W3djNBhrU1-TNbFmKUF98oHzwhxO~5$D(yjiOaxx*wPg z>}&#s6KqTx802!8q1!L&oqNywuD$sS)p?W!j6(@=VlrzA3>l>DFVxV2yz%tzk)J0^ZD{ZzXu z-K$ozjp<2ds*UZ(G@S^y6uap<1>6SsVBt@WQ5%(<*@&2Je!NPrT+r=iu}1;YKQS(< z+apB8gsKd;j#_mBr*X0Y$LMCxjo8Q!FXP*~DI=;KUV!5opav;KETmAJ^v1ZSUXm!u zy^Xl@xtPQ5p;>zCV_>-0)coG*NG%d#dy#?8uU&nR+kVkR$R1}_bZ`}wN&l{c!aeu~ z@O$9Y$@z!p;+XP$fXkO37rFv(%Di>CYUOgTDTQvr9JM4-04~Ku4qzkdwP(&_BGscJ zIcJ^w{UX!oKB|6gRWm&l*VN}jjQg6GPAwSpNv|S^ERF^oqS_{2IwWPj`00{$k^2l= zEt4OStZ8Uquq#04CMYf(wa{HwR;IHxK{SunVp`gZ?gyJpX8N75E~qVWLO8CWO3zah za!#iLdQi6MFd-*_iDN?KKN_}hJwIKqfkO7nCuDsb3foYIjvs1%9A5?kQh zVD@BhHI(OPbd~dU+R4IVcnb_x0P?I|fClb_d7&~VS9##GK5>4w?qD7xx2}F@nSKwE zy`lioBWaX2z@n7A))pYA-$l8eyyg47A*k?%m@PR4%|5^fCLkN<#?~F9p zUbj$)kgU6FY7I5Lv&IRFN)W*U8UmcKPL!Iq&yK3M=aAbV= zr(`U^0?AWRPXEGS(W7%Zh#7j|%U|V$xyXA5$1AEsE9@JA%CbCb`{SR%+i#0?IVT?B${153lgdT*s5a&qYWZy*{3+nsPg8^`R`|T zQf}j$6lBL+T-ToxcpfY}3JYr*q}<#!Ohwgkj!4!6?)iN|%4=WwT(`7#Bm7Y7CXmA`yVk`QWL*u5EvKh z&|0ID_R&pe5+ysQfBN#Uyfn%eU%pWekKDtVEa$|i3AU!6a4}W(%Z695VMw3zqq%>s z32e!t=5W%13(Wsq25^DF8JJ!ZgibKLDNoaIg;mPBHJk{C3$st1*Dh3`n#m>Mx#7B1 z57un1=PcE|vL(pXxDAQY-w^p4lT2J^Q#Aqd`yBHr%J&1bY_4*J8}*G z{*|NXmEyVF|K?f)&LwQ`N!q^LVHRR3XYThH`v1!@1 zXOBQx5-wjZp*3SP0`A{8YTxC{8iPTB!GKYg8bT1dUBbbG0x!Ifpx2YZJgR^BOt=dg z^WDfjJniwedwJFnX7z$_wkV1&UP+THQ`pA+l*2l|$b+;<5kQYNFG6N$6u{3dks1iurI8I%3g`^YNK`Jxk zUNdooR&}fl zXq^a?byHI&FfP`NTRodWB2!42CWRQE{_)9S`N#B-@2e?>m&+cU4d2Hmm^RW`Khb^ZhjT9vGksS?)7zK zD|zLqY>+$-)xH33u9|ff9~++6=9X=Y!&+DO9FUiQrUdH~-fKe%^z#t`DXi2#aAQuv zF+Z8VhrR0^eD%|V5CMOedM@_A=1Q)6D%h&;B&6-u!}WsTeut>b9P0>1JUX5@0mKyY z*L>W82uKoO*DisX8OEMHgri4O5SdKirKJ+bj-^;%XMFNWi5oXGcJCILpBEU9frSNu zW5-hTdb0IHV>6{LBynxAf76KGbeHzi52yH1Db9iTEErwIRXl&56cvea zP%4K^`o67NUJfxX){RmIMj|uQ!NaK?9Mt^-BQHlL$s(Ke#-^Lj+E~IIr5Zu$62p8A z!gd2OS+>F`xM94NNG<6bn&cCkh@x55^^)2*^vbOagg=2^HU}wElq$#C=%LMQ?jaGW zsa1%|)oGMB38H_*y0c3NDeH=*yJn+|MIsVVHj7a{z;L{ZZZ>1;7A74eGEItPeELT( zj>}6g@Zw9?)$s7$;!LOH#91o8%nkA!-0VMmLRIxXseX4~huM%# z*ZNVq9@~Fh+buhtF8j_RkqAa?9Z#G9Hs7?N%XJ!2$}+;SV=1~_fjnnCc%abfnApE8 zBkbEJF+a~3jTo0Nm)NxnIB+1rg9i#HPbS#4OV+-@H3{d&F^JRMw_8yHpIzdIvjDoL zb{!+nhXBLG-31C(B2qx4h6=KVAc0Y_7AOtmKkk2&F0npdh7iJ(MzN&HbmTB?&J-8O zi*+QjW0XKkEKNPY(h@f_t`GvHDxmc`PykY-_Mgex6(m7K=%jtS>GlF(SVC!h8knS-C zLqLC`m(5{RtYKWNp_9(oH8b&$iOiBR$xr|IrM$d!G+BJ`E{mh&d!z+laE~s z;Z>VZO%7agm3^%%l>tWqQP6(OwFP4aYXyIjCP1HHTo4sEcXT9lS-Q1oY^{ADyFWz# z>cA?l{>fT=9sx#iatbOnzamV$WNNX2;p1q2wlyZ_iA)f;SKR>DvvJ*8nT?rH7X92? zyeM_TZ?0PijlVkhDR$)#Hko=rk*kgq-Y9Iw)5UMX+rl5ax z%o>i^BAz$_L<>RMOd%s8%+5+A3E}>Ig@+F{?%pji9%~Q*D=P&6;|eYcU}=dl8Y!e{ z82eOVn(8-=7`7>Y&AD%dFv1dE*P7^Q!8;$kyO1WGw^7J*MB=Q?Li6`ms2rspqhnP) zc=bVBLsfO?$daBZ-69fXNw?<4>34s2n=Tq!fx*zagwmxcy}}Bb6-r$ol^p;Cr3#G8 zbudgJXK3~WP!K^>DqhBptM3FO(&5K_mP()y$pwYE>r_edpi?*rd{x@CoXOsn)35iepDm=th9e=@8_~KQ5E?nznAPMF-g|UBgyI*{i_3rl7khm?l|PZ zCZ5x+H`NGKNaCtcg}T~Tdpx{G@S5{83tY6p%2$)3s;*?^?hQr`6->XDUiPh%%SMLr zAS>|y9lnL#!wh@JE-rRw?tk;XnlA2&dpF+ywmv5b2}nSza)NMH-yVNWL21oV5scUv zPXz(ot}5oF|87^{&>_Ns0}N)eg`62m0ZIX*k;2lF#*cqo;MOh1$&&(UN;cVJ@*7&+ zz|}u|Hk)Ti{My{W(@5>pME>6S;N1lM&IO$=PHSy|FE?c+#7 zu_+l7#@{t#HxrrJ;|k>E2%0srq>FAki&3$PQWqfW1{N%>VKDdS;s%{dN^xnrhfs=4 zb|FXtWbV-^57LsfEa^h&0^?#G>*HnrnsBuM&CNR1#@QrS^U#0QN2{!fyDwo2M~|%% zh=gqnq&Y@FqLcPPB$7cnJpF?gQC>aXTRe5M93H+?8X_o!Q8`=(6N6=dE`X3})~^W? zo$yU!Ty4&PH8VH4Zsfv%r%L7mK+wu$CHo?|)N+`Mn-qcD(8gcE^(D5(*!M45rdCv`yO ze)j|~AXYVs9jJ7nsz+g;avw&}rX2=K+LY@cAR`rlL$D^*Yt^rx&-rPTk#V1=!FU|3 z^PT=W{@-Ia@Qo|S(f|M1d$V83j`U9K_eGo~Gw-dHwQ+x`B70#k>?Vquw(Oo73a|%; z1YJyl{@NWq+4yyly7|p|C3;3`8pa1>TF5mkft?B+3BK6(6nohK; z#dhx65x|VG119wbj2*D*_ni7s)fkvDm=$`gJh-c%Ncn#le!T-#UTxdzS&Z8!K}0Z) zHawtGEhdeNx93#89gOK+=oi|L89j`3;Z{)POkElyieNLaknr|^ZMA__zlW~hcXokI z9laI%-Z7Dr`Un&e3=c6jVO!5)D!Ry&c=jO7LuX^CQR^0i?a>cQtol6{P6oiT+5^M- ztS8FzrYe6LtcRk)W)M`=p-qlmC9H;hfXD^07BLVN5wy#;Qgy(~KY0nm+t2BDzkJOu zp1*5fsh6hm#mxcQV%P>=)muO^v6*EXOavd%!3Swmi}q-O337Ib)@MKoqt7TBjO@ko zUjzphzwv72SY%@|^<}pChK*IZK8`Wn#GFfLMreo|hk>9`JCX-x+X!C7z{ZBcm%m(LIt5OiRH$n; z3jSo-WtkzfFk8p-&)LtaGFov$I>e>)Z002OaW5ZU)}?=iS~>sbSm$q=bd2#r8L@V5;C4tgX&)X*-QQK&U5zNm#^^r{EgnYlx-Zn zdZU^?Zm1&N79nOWh%8dbohnH{AMVGcq)SW_n-rfBIqb^-y9Bz)Y(O5E{8}{@q_tCx zu}$MZvJb;PEdXg)>;Avw>lah#!5e?x2f)DAm1Y^FIQ<+$-+cT#4MVDKdPlgwTQ(>cM6169A`bCg3!j9q9&W*aRE2-8Bo3u5dtGZ;7^RSqeM z_68Ifp8xw(w=nA~eCPU^&(HX$CE=G-8CS7Du5z=ttpW4}F29UHEyBAh*2;nXP&r3h6u zB48h(KJnE000)sVwei^XFtzY!ef{CT{^zIA=-06_Kltw7E}EY|uQxtCfy(L%O*KQM zlBpPZgXqC@V7AzpoItHx&j^1GP^yM8J@&h~i`(aO=fbl>#`Nfih4W4j4;}WqIX2o8sJsJ7rE2W0?nCPeO*KVR&7et-cdR6`iYsP2QI&sp4w<2;XAwLp z59){%jO~5alP*51RE0^s>C@n87YsXQC7FSU(DnO3<(y9tg4mMseE{F43VPA)oxHz$ z_v}4WgVnwQS4_}Rts8QfB5jsQRYl3h%$jvOq`>G{1}Hh`6qHkDqqVL^4(nsRKhxS4 zb@S=8$j2FUyJi6}$%AJFsd^R+Px_S9gls&+RA~^aEI2l(OaT@)>-E8J?k+LCwwIix z3UHPh8`Pdk^m%^hl#DB9AWHmJ0KB}6;9)OgW{NsUmGqcBpQw2@Y7)S5+4t+^%4Zi{OReT$2~;N@3Z zb@{y)tM=}><{|@Cloi$mPhNSa2gi;nAF_qf_X{-j6iqe3YS@QTE_HufIPMx%!SWE* zzgpF>Fg})_^81&w6|~l%H%rfId4L(xs($O&XPMF>7Lvrc`5$H02rZe+Xw-;L% z-ri}N&b&sXS`dSYmaudgWLp9*g1Jh&yHIDPT{CS?{XSQGDt~PAujealT-gQnCNh0lhK>;%y{I}*P&k4$$q0h-5Jzh)pOm9f z{vm{aqThX* zS>%g(J$3;2AX~cf_lJR}l36IVQ`C*ny^iFg4t*<6}S z-+F6*x%{BJeC4Ih_STu%MMJi7juTGp+fu%AJV9zbcxlwvu6#KaEBE6;M0+UuA=VA<`Vsi)Cn zv+B(J?48Bdi|_6>_0qfsLYt}9m?t2<#K4kRc_2s^nYlt-gEEtdoWC4Wf5c5q0v3M? zY)J$k!A7YJ!4dcJ6#SO+4WC8HaSle?DC;*vifZbpdJcQM=t0*m0kT3cW6`ciq!=4u z3)t8-29r5=J_rC;F9yu6>_RVx9PCLDm@ze!gF_+!3KkknQ$Wwas)2>}o~J#?>_OQ* z5DduY4vX&!V<(+K0uvSGq727VYBYaRotfF^_Z5H%$yQD>mRbL0>kbigW)d*QpiFRf zr|oe0*^ltdVv1Q`J(1%d-{xfnv+#V+4n9ch2q{Q=e2X}E0m<$*5bGR(Wu_iaYtjKf z-eMx})sGgz$tJ9S;0*$vrkMMJU5_0AKFakdc6Vby@ln;g2bFhFIll}T{8fK~zd!up zzdD80A_Bh<&LwJ3vbzZco=o@6rLX<;{_?_mJD1AyZ z!yzzjB2tuK|Ge5hfMKcZ&A=-X5TV@lF%N~4`jI3s1-rdo31@|{*$NODKxxLlBsh@z zGccFLsRot-RcHb-Z&C;V45)swkU<)8=(D!w;aU*TFm~ji*H|iq8xJO(uKh(l@tumKP@a^7}7sw0F*_ix#Lz zI5-f6)N1=MJj5&GT3)Ner!8A7605U^}e( zJ>M2*njZM?ePu%IYUjA@snkBzRKpVYGA8~*D8GH$ZB|IYt;36|BBF9v) zu|BR}pzgv}>{;_*OJxylw3JppcB4%uN@C*-03kA;f)z<>!eUdGs`rfXSr5aJew6Au z*)KV}gxD706hpy2G9sqD3~~T@dUYSoy=4MCp6#QeCSxNKzGTv1HN~KhW6_+(etR54 zHGv_8%B+9T4l_)k0R}2_4`jEay;p1*37TkZ^fSaEn8-1p>OqGD@kB+T#g|!K1SKeY zO#;HiBDx9ni{tn3%-Jb^{iAbF&iIG#WM6o;H645skcB+xi~?*DK;El^A#E9xM?DB& z!*kNK1+5w~mTwd=0Hyw!O#13C;)%p7!WF*D;}oOeH1YDuyPKni+s;P z-#-i-ew^|?>E%?t&FdEC2g>s63_C$&qk`b0>?|DXQbe-%LU^*Vw3l9aYiGIl!T#l| zFCA@foSs}{MOBb*4v1JRRy&~fh!6eZ7`?sKJyj~O==G$z&U0sjWu;&9CZ$j$| zC1Zc)E+^a+v`-yplR>p_RaLbK#KnGPSZjSiX$xk9flX2|a!N6W%GIm4JqEKxr5hZp zU3eJ72K}&r)ed;AdS}dEdA4rN&aXIHCwnAUC&L4j(lNFmkwT?w;hCK0L9TQIt!r3o zV0m!iWcrnhkEm;xWyEg~O>gI?ZZEekyt{whG%M?E{Cv*XPdNS{z67ErK$n%`mMvcd zT#C8iiReIt19)s~+~{54UT^cn*1dtq*-^&O79(bGp5c4eXr}b z|KyMU;CKJHt~Q?n!Ozk4*a09BeXO{84+4f`WglcW$Ue4T`TWBey|MQlq@I2du>CaI zzud-;UnkHcsvB4cIk*4qy181&jbJ3x{4jur}}n{_oW%S}$Gf;|&x?EoT;eptm! zB_ZPokiefD27=2Wtl*qOoYTk(OV0|N;3^pxW zTm+~Jj9u^?j_K{9lLrd~z<}~hm`)yxDcElSEEZsY9XDYPEGmo5PIP-(Pq_^mMuGyT zHYSEFZ03@@i8gelcO}+iw#nXW?kq6-a1UgK+!E^7IFk$T7wx(L02+o{nCc{!)90~0 zJ%vRz#j0vBkaI}rEJN!lx@v+tB?Ke@03ZNKL_t)cYM{&ty1xmsJ&03OkG$N}F3(5h z44to&$Y2x!L6hBJ7k|~_OY@_Ldi*mGDjb@mrT|`L9o5H@%?xFY$-RuB41M5j{J>jG zE}Rn)eFp2F-T>o!z1e>X1V2aDV+Vj^_I)KF8?$u^4BkP^+rt3XgKYc)C>^Wo*!^XB zWAz(T*Ws5;1($pEDsSVL0-TPYvpLz2WD7mCBWqO>GLF5QOn-KVOJ9F$dwKr-?aLp$ zxY^z~J-t}#wi-<5ZP>I=Q#SX`7mS_79aO48+ib=ZZ?$SsSCc#(i~ldPpcOa>as?ud z!Sr4RTl9l-;HY&g1b3`?RMEzbfL!>O08T?ZLFeV$qV}O=f)LiKMpMmPwha%$2Ghgx zfJL{BS$hncYJY#APoOXLY1r7^zk_k!$dzs|*dCK+(}&0DT$(s9n8QYpZ5jb&F{AQf zaMb>4e&W{d)>q!&Y1)pxjb9q)&tm)mb%{tXLH07SZ5a*-TI)QHiJW?vVUhSOu{OM| zzVnRK!YeY}&75r6*g$OTVN))GMGHnKwLM^ov?fQ@Uw=|d7y3rbMrIq0_~rZxHI}xe z)!u-~m0eJ0BFKx6iJZQfIyR^kWz9*0X@*`O!+v`l^Y$n@UBi%00i!iQY%vf3wwN|Y zVEUs_LkGpHg3*zqFPXpmd!Y304r=%`l}bm~nhD3aLd^;l0~4;Gp|GR@+tj0jMep)x ztbvQ@^nX!!(4(BWMA&J1{N?i>;rOb?iPiK_j(=8j$qsVRT5$I2yect;N_3Wyt0G$i zL_WMG&q3_Gdf`;PpZWT?c!L5X_|!)5iN78@0K^Djl2@5|<3X(6qh4c-qrArI@o}!P z`YEN>e*2`CbMEL~2lxj7URNY?^~TLnsu0%O5`XSZ#{2S==>APA26<|=V5KIrC0+X3 z&$gG(zqfn&{R`9f{p0FlZ&sBHknC*c*gG@yW{JUe-cC@Xtv7vKzNDrKCwQkNqzL>V z#@yK(+L$ZY1&iLu)W^BN&w*grh`V7KgF6pqg<4OXO4o;K2ux&9!4e3|ehE!0cJ>0U#-mi^zG%= zi|_8NJ9qqw#-EhB#1>0fr0_A;R?y0^CIZ;WwlH(Fp(3RsTO8k8svJoM*^X62?3f~x zL%HE6tRn&f(>gc`03y^OV=}FEY>ov0VSi^vg6-`FY`nJ(y&OuIBdS|?_-1L>60K!X zVbI61YK~*2Cl~_wEAyC>f>jlaZqZj0^wlOR-UG}I2qqi-5)LGrGFr32lMEn4UDK>` z?XEyLXD2veYG@{$;1(@vbZh})%=Ho1mMPO4}X9D z!d3j!_h0m$!G~x3SulB_*PR)IiS_4fS{I{ofTk$`z973m04(MVY=Ni&<26Op#y0%Q z*1vv(t$k`E_=I1F0sxkq_CcyzdHpgf)Uoo)G9RQ?4ghkDMLejCgH+2Ohy9C;-)i*( zt@Z0{?L?|jq=9sPA}$W!Qr#ARM1OovDatm2c-|!+Lys*O3Z!VVxv-aB@y;SYf39n9 zoM|t%?PjH^LN_e1v)GTR+=vL1<_L%g-LQ!EV2UbKx&o1o^3_!*fi@yStsC^Z!G5=m zTDNHHjhO#83d}4EM`|9i6Y9NLV$p2_AZXOyIi+!+3_19Nhih8bm|z3luzvuvMO$w` z8K(-~TQO$M(Wo{?*bIarI|#6LfUzCw$~mm`#@qN&gML_HupQcJI)$#Jx6b<=!dCTmK8jB!Le0VMx@#n0~N_dZ$Yp{0Oj1 zdd=h@z+$Z9kf;`YeGH5Gh-dy3ScDddEFLoqY4l2?*A0eh3Om$Mttlr!2L9qS5bAk3 zRg_4>MycL0JsK$xGtSr+FAYa~NUyL4vGxy0G%kr&XFsxt;L0KM`G{oI)q_J5Z5005KbNKENA>c}BZ z^#p=eHQGj_>-RC36)N38kw!P{V}CWrq}lX!ld;4Cn`bfD9+oX8)dXO;T*995t8|Ti zSh*nEtdgyiuU0eI`Kenjj$gGLUQI z4<5muIaDslH-D^+nKXcaie6W+$nE$ftLG~MOBz-+0M*%j z5`>bdTLc@B8$IGZ=`ilUmyROLIKef(WRBo$zkwse1b;JbFdJG_tk99OK^*h|#ROY3 zKA?RJU|2FRa?WwlH_--AII4(#V`lv1%pFXJ3jfvhbB}-gIS=gvBoN0TjiwA2BSBUX zKQJBk62l1RTr+3bEhg14^J|K@jq~NOtbfKE?8C=AWdxs`>#+hr$@o30%5}`nPJUnB z_ps+5bbs$yStVO}P`e(+2!_uG*&9MKeh8U6coKLiwnp5^QPf5C10|I@iQuHt{-=~% z!MHi?3jtWA#UE9146reN)7HK|G}+j|)&>skG8q^({Id zPj4`tf0xT`>pXbbJ4zTZcd+cdc-hFbZVJlh1%DoFp8#BN0+BX^qP<k`-}4UM+mKyQ}l`UNUoqpdb#=o$Ck+y;~398daT6;rW+DF%H8 zxzue7vxC9(F3p}FuR3Jzcz361gsS&2k3Ybd04!l}naJ4)5;-};IVlx4LH9BXHXfWP z1%Il1@LwP5C)6smVSV`}NW@{o^8ZFPt@7!%Lf+zn{)*#o*)wiIMJqi>k=_A9b9aU5 zhkNdstS%$yqIAee(-nGHp{}Q`XtitYZFO!K!5^Y!R*??AvTXP%#-h zyUk)U+Z!(Z+B;b8T^}xgc%f@=o}FE6>sb{-vP_yIAi$?->*ISuh!jPw7s%}G{rZ?8 zV=$}enM*NShzrnMsXAs3ak+>Gbbn@vuHQpbZD7)D#Js@FF1Tx8ZX_#`u^=+_nh&-d zyn&UfQ0pm-?a&PiAC4x^65{GUps9|y>?y<Q{1%Ux@SP+7p<<5a(}jd4z{0dMq6{gcI<_ z4zRXI+Z=KBf*i7OAb*t?55`bI58~z;Fjm+Q$`S2N0F^8-VrMJZhf> zB`+szueF}Qtaj#SZ|!b<<;uc4cent~geQ0WiR>i{EETECh+e~7$<0)5-hmEcYn>xW z*u}Jp`JhSmpzH^swu~w_DOZ?X0BfyXVCvwIBJWX@!p$IWD}RZXhBR+#F~qo%vZvYq z5&J)?cq#i1f&@(R$3nqCvw@27?g~#~@th(+vw`Lnh*!C`U8AUn=|Du_ z*iQoTL|_=e;D6o8694Ii5Ai>|{bkJh>Q_4cas*<=kPyGpas)#eh$IODvzCFFK%{&) z7jofT;Jo^u?DfxYSm1m8Q?KDec|CRj$PDzo_qeQ_ZAAJlXV>Jvc^T_~s$}6xHS-u- z_pnO>NeM(H@LN0WXC7VabyZ4X=hoXN{_qce=X)-52Y%k*dEj7C}!mkT@iu4%7ic> zC1uyD#-w&&kI6B9)>_n6i{7kIg;aIHThJF%_jZ2zrVHoNfAstsh}yIpeLlyZh%PZa z5LDb+i;F~DA+i|G%aB4Sj#wp^Q<#;H=jc-bA_9d}??|vgv`KslhWjzdZ|D?x1&S(5 z_vMnYPOk2wy|;qPidQ&!gwI~hdypiNwUT}5GT#l*W`WkOurxh%HHq;d#Xx|-sLg(b>;_{Ka_5z9iX}5CSQ#BcziF zXZ4#i(-sH~5xoY+7h(NJXOX8s@bO=V0stDrxOS~af7=4bk0WCNOIr&R0!-dFW{)SI z8@uo00L%yd_ONFUVjNB19fRrrF>|tiil;OlZx_KiCrFiLYDZeM%+8xKcvm81UJybz zmPvs1r?_!dM}87c0wf6PAYH<{1uFxW`GJBh3iD)h$(MfZ9a?_vn!Wt~i`3pY(_9>2 zDr0*Pe|oRR1vF{T5E6*A57gWU`#|SVvb(yA!FJH(Qmi$40L85Vv*@9u-xX)(twdz^dOzXBJp?JE*D_)8>fVAib?&V|ae* z=Kj`;K63{VwTN~@UyShw@g=rc64Ygavk_!Qe-+>9H|Dt62ZtOR_EGO0?Aw?&DXBJu z=tpVt;p%UVO|b}d@V*Xl-URpw4Yxphdx_cgeIM-FwT;K9qP2R+o)mR~=r;enLJvJ` zqgicYQXj?Av|zYcfEh!^7LDmJ>G#pB=4kr+P-fvb;xvL8*o=KEo0rOzqn;V%`OgZ3 zefz{c|CRjNCZr$PQ`ZP z#(<3tg|^KBU};--5Tkbx$a)YMEY-T}fA#z1@dnHKjg{-n!_qydDWPAY`-Zt+sDl1soRFfQp`SxYmcVTaR26b zIflAwqaY0`+^EWk%_>gT9BlqXhzCl}9~uW;N#)bf3|iILTi(aY?tuqjFg-L?s0W^( zzO{$}oDq$?8Enc!&1XOURx>mQCz!`G{vhkZ$1q(cVh02*SEMM~Q&C_YWM6x>j7Wi% zYnKB>(z{YNL)dV6R1`KoIY&5ne~40Wgh;Zby|=>jgWa_ld!?NnC&Ur&BPjzYdFjT_ z5)g8Ss=tSprdSOp(Nq&Rc3LI&iWvT)TA(w#Q*`0GbEbelB|pJO!;gfz+>q1 z@OV!Ke|_c#j;w0DbpP0AGXCZIlye^0+MoiE#r~cX@fHIO7_R~RSl9nykpBQbWdtAN z_1FO*0JJUP>{*Rp{9?fA)0541Cx5Z`#@~w*X`tW%>%C9i0!*=-xDYI%K;M3$mJ4r? z-e!q8ePD~dP)O=T33PX3u;n|{L#qFAk~b47cl3P&pJVw+i}PLdake#^6WXjMV$8h^9)7_7DE z_wUcoZ+BZ?xw3MMpYoYIBAHQ|+JE-r-;>3aXYb-$*G{9e3@g#?V;FxBJP`B&rI{{* zROOb19k<2us$s{%<$y8uVQ53B>saU?2C>haK?>+WAecc^l~UbonVN{ z0U>#aD6|=|qY;^s_&g8Lynl;kxR2@TJ}gyO*$#uM!QLafVuRMMFk9WnWOWnua3A17 z5M$Dd9T8jx1~9`y8FM7sAVHun(-5PB#Xu%bQEAhfN)>%fj6qrS%A%(*kO{z%cwap5 zi|NBc#ay-x-cf}C?6e&&KYs%!mQx&GHJ|GEhniA|56EHg(^`nyf`9dE4)7L8Ij>&j zOg$dw`af*)AD}lF{4}%3ulPEc)cB0A-}}AaJFb-aUjZCdicr^t-Ccvlf^p=CLS2u~ zs<6;hi4eu_;X3G^k8{bBABlj~zw8wmOFLlq`dhI5GQ6;?f!pA+Q=k;z<#$OaC;N<_XbI|W5MzSNp{ zw)Hj68DbKi!KKhNc7Wj?gXv+c`~OjWWd7nE_2Yl^*06o=dQC zh>#fZW@&aIFk@io$iGAN1{?2equS{bSP{dOjfO<30zjql5aUbhy&`7@;Mldw_NeR% zwOye$OEhL5(|`UxX8moE)mMP==dW- z4Z;a-aKyG~OcVPltRAA&-vF?xdfcz~akbgSZM8y2CfNXrxhmys>XT#$AfS=xFVSN} z*sD71P6nLcJ%Wbyr!xNTJ8w&u`JktDQL2}Hb>;y7*na}sV0sn6p;`Z__J>RU1Nb(9 zzHiL(8~^M#zPb9{|NgsI{_j8i+W}9n&*VB301yDQc8lkocLvlou(6?_HHuB#T@Pa4 z%HKW?Q+Lq40Zed_$s<=Ye7yI@1!D&6T-$;fJOC6jJN;3nH_8`bRAc1gTd-Y(81E{a zt}|N}e}7N7Uub>+2*Hq<0~PH_?~F#uY9u95xHxS@&RZ?BW2u^+&!4)rJbCKY{+pc| zZf>`HhIFm8s=TMK3-_W(gTd(feHTAa)jn`(a`1?oHZunAAq@83#3Y4N)~oC7TLX)Z znH+3~)vym^9gBc&Ie+mE{rKY6V*Bik)vL9o7k`LQ<@>ML)OcM!ewO3^cV}+l^0Ob| z1PHJEVgv2f9$W!tR!2nhxW^xa^I$#+;7vui$?Sk&YBS|84qaotI!{TJp0j;Q_JKvf z@3LNk?NJt(eXxh-?h=ZNG-)Wt(bp#poe1G0>nhZ;IVwqjmWV;zL)itC*@H$0#Y@y? zg@4BEp&9O>8SbF&??9V5i2L>K2tY;x0#QeM0{H1y7PzAypAcHJ&q5!NU`XkQgg0Yl+3whA<|J<9b zP}>UU_BNbN;V&`%&J;nX;;o-g1!F3iw0{8nKx!L|R~4y4wf>(3`R{-rzHiLx8~@@r zzPbATQy}=6T!%sh3_pQRp42#bQsMpg4K_9uPM@xz)Hv;(Kbzb5m7fo~_fh^X%NYB+ zJi$Ipy)2)Rr!>T1!{T%nS6qJlO>!!HNSg=Z+6o&C))%6v-uiF3P^I`lnM)JmyMMgk zAjos|QYpL;J=H)d2rH#~C$l|s>DzBDmS37xm#GK{wyVpOVeHi1N_s|kpd^Azq@sC5Ian#d?Z2+=G6G(vt=QFXTHhGk3*H|1vj z%#FRRue>)jP3N3D0*f&wI1>o?)hUhtyT`Wi*Jo~^Q_ky|hb6EACLeaNim`fTa;V0i zEnl+a14?Ud+0w<6k9`?`xw((_#-0yzA!5^IEY&(Q6@M#1o_sE<=n^Q4DrII6Sr9K# zS%w;b$}Rw^!3-$7gyMZDv+vcQ85f$_{2|CHN&ru*r}my!F-E=ZMDMPYJrJu zp{+)3tE@kW07C}Ls>iNgVvjluu;^f5AjUzUACfY)tlL`Wiclth(qY#>_}6DXLS+g6 z=;pakKK@~>eAW#c0c1J=W|Jk__yy+v`?%$e-T$bdue?`^<#3V=7CTXH$DJlmd@gDs zUz8SY6g)Xdm1{A7|4nRZ{&WTq*ci`D6ah&^A7n+Z877ZyJN_@fVUyB+!%lgM{Bx6y zeRJuXTf55(6S{omr6cX_bL~Y7R2Bnzvw~7CPjFpLN5@qHxk@+Cs)|`ix^5R*X=v@T zh-jsAA(#&o;8nh>VIS5SY|vzW_QtUFrFZW{;1|+Cg+9%H1wT^0QDY(bmd|qh?>8%4 ze*QYP+b-G%u{D4t=p|$N;U3Ji!Z523-S|7N;S@)Zfr|`Og75Hk<>*bxV34KM4n_z^ z;hPsWN3k(0^7dvH?d=67S9ZL2r!)gdV=ae?6RiE?)86w=@$jfF9iZJaVOPZ z>nBT!8$tp-@;SG#mDcGLDSr#kM*+!R1tM)hkWSC>#5Yz)Dt=3qWhs1Oeo32zPIg#~ zr`oE2F*twf*7D?;TZ=b)M1)JL001BWNkl6cM0^vVGd}sM+n{_pudulXS}j$NqE~U~FQpPlbfIM|>ibJbPj_t6b!%v2t!QyMqrFgfb5+T-J}DkTNmcI#m~Nf z>QumzjY{}0^kJH}Ai@BK0x+T4Ww3xnAvyLe&ZWQPi+K$$?H%6!0???1g#0vsXGXK_@P^b(h950&px{OQ}PlV@*rZ`uksSDTYFbv;#+u7V+d0;|RR{B8B)U;Br} z_SqZVtCi&!;0%~k7mkh%MZp=fi&%HkC;9uQJpM*m{LR^0_{r%z+2hYx!Ygmjpzpaa z6adv*kg@2GwBF+GaE?ES&jUCKCIJLvJ~GdcMAQHKpIKlmk-K++SrgNgUV4PQAdf2MgStp-X4=*5^zdjN@;SMBIGkhpgQ zh|13lp!1*)#2AzT$ifn%!+=%QV_Pq9tJ=ezYJvNDiI4OGa~d*bpagH(`-=7me_8)r z`a6NZ@LbL&E~^3CZHEinM^GDjr16JkQA1wq2j|sGKW6YYHkcgnJH+e%^CI(^X^>+as)8?=%og_2Yj0z@f33Ux?uG64qto?8>pktHU~?yUmB!gR zp{7+;oW5OV4@D_JG{d4FmN5G}^K-ZRt#4kXrs?T50Br*M@^qXw)MyYd_HRl*7Teor zGyebO%x(P5*_(;c@Qi<0n)71qSjP0`5@u3iadrmMbg0Ll!Izk^B={6_po?rx#lfa1 zuoQv4U;xA}WtQI%nSAOw%fMi;d1VKBdzrTd$?h*+LM6CnZzumQXd1ayN<<{f;TS`= zh=VHYz-csn1zVME*Yu{lyEhHeAl)G?CEeYfN?kN4-5}DXbP3Yk4bm;$-Lb!YKkxDV zhB;%_S~IgmxZG<}7kV3r6+SXTi>IJE&IMms=L^^fjJw(%BF?Z~@L_Iyv!O)p?4^my~CP_nX6N9nhhdEp#97&r}~ zxsjB8glWp_8NQEzI+T|@n<>-dbYqI%Rdph)RPS(1Czlzj1sTdYqouQEQUWKVoe!U|wK$|laJIZq8y{`>K-Ako!Zdd)$2sjgkk>1erq@BZW}iAqlE zZ0E36fJgIEj=DYz5$E!+FT{L85xU;Y8-{9jsS_Kt^3pLNp4+)n9g zdua}Ab%JBoCt!8`Lma`Q8a-W@jo3u)-a}`AdmQAxN9$&!ii^FpqNgd4OWF&dSp4e; z_gSOc@vmy%L#S&G94+#y7Yw}tO1_@khNGXlqE9&B7F{`VHd)`WWz&Y)?Q z25azuKvQaD00~+FAk7{Wrv{;Kk=}7fB?Lu^GF6Xmlmg zl5(_b<{t<7taItI2UiF33PglG|2?>d2}*U`3O&L;3&6j0-KuZ<|nk{Qy*7Up_06?#=ZhpyaoZ_P~Uy@y5#2%(LIe z`i6<}g%#YYmH4z=>M#-9(R`^!B=)eSQt`JY==vqqNh4`FhIUC#TKB5zxxA(fqorUc z{3nZ3JZLw^(7b?NuSMC>z}nE#mEgE2%!elY3LU`5`!1}c>~bbt8viG>_{XGX)us6- z*~`ow(sUIXT5xTO+E%t3bQfGaZn4ZfbNoFciISj_f(V|~^w27C77-59lMtJ!DZVt% zHs$RfISN+dXUjZYGq5aGd*CNz3Y4M+mdtynJ}JGR16Yx|2eA|iR)hfiX8uW|LCc>P zrv|`eMJ%8XF@GPm7qkZJ53(sp`;AT+FGqAgUx@_-mg52@2&on_~zMJ%OyEK4WHXo{5CNplfHf;Z)(R5($d za!|SJ&ryIWwzwSQXdvgG;W`*r;&f7G??aug{!6;14 zab^71vrTDSR%AH(YGP@6;&q>W8dLXkyx2=JK1mx`TnS3%o;`3JQ397QysKHPw7_iA z{lWty3f;|&skaqTtH~VaC*Ohrs=o9J9SoK{s}M9QS}Y&^e!22zr7^KZ1Ya_wCU~DE zefHpug9An|V=gr?6~iMv0$%_(T9n9b;quLq7KgR(o4^GV(Q_1jh#`tbMCD}e%P&m6 ziO#sE8!{5eI(bdMcb)25q{ytCBjE5T*w8penB=9V1{dx3(wSWcbqeykHaNJN1->T( zV3xXL1aTfyoOarMb1R^@q(eaKH7}aHFEz)tWkFw=go4Q}JM(z+olxpY%!rAp0uNNE zoRn-=M63)^z=Ks>x9mLK`U9Mx0eL~KJ$!vbXo|qrvoeyIueyzGmo`RtJlHo9c52 zv?g3#5%UUw%#Ca!&|CqD&!dK!!@`{6-AX}V`g~$IsylE_7f<1(N#G08I5bI`pxdJfDd=T{!exhYcIJ0EA zZxK2%!PvlOB?T1vlbg47{aa&oA$Vn&Yjt~(d*b?h9mxx>{@e*_aUbj1Pvu**^ZT(O z9AP~rChvJtDJUV1IL%idpoJrvcntaVLUc@Z;{@8^FL@s5e28@s(ZV2FuxNroH!~do zrTr-SD80A{wgoV5L@k80#0-XdXX{e!bsvW9&5!+=Exk!JJ8aV*-04ghM+E+yY|2)_;FBF5@ z^=|id?K;l_0H5cZ+gBZy?KWR4^)D0!K?*%{XcndVSFfzaLXRCEhJZ{*9}Oyhp>4>* zNL2nus7T7?-%fK;$4);Gg(D$$@1AS z^%~jTCqVXT$I{tfeV=&Mpug!PQNz`|LFqd0%D_Ac8gHU^dh;LBCdoy4m9Xi8bu|M} zIW}8Uqlk3c_#<&2H`G5M)h0^&%f9K|8F*u%MAUwE;Uj|6zv6ej^lOttSCkccs=ogY z^E}=)dG4s@grB5Sy@q&QF7vry0rKgwb6$ra$OQ<^@x@4A$XA0&xBv7g`eOO>9W?5L zH2G_fdAHa{L+3#?V>52uECxGJfRRnDA@|)q$^9A0YKK#8(_qFp@}y{KZEYf|=uq4R z`1eHy+do~w;%^E$X+=ZIPATWt=iE@MY2m=qQ)mkM!}kM-#EKFF_=O);m7wh+thSDe z>lMH;Kx9?{24lmo=_$fPS64#@LOg=o8~t`9+VR^YkSP_}hyAeqsRL6|VbrMMF;z>R zdyA``#?$w!PYgTUx1uymeJ`P!J!8`Ix$?eY!{y*%yjG&3i#vgshiZ|_WTFykIGCs| z1}h?FgIl{8i0Z`ZK-PX$FDl23V_c<=8{lif$A}w5jmW@%XUb>qS!xp$=suWhE@9{K zC4))S4{&R2?(~f_+DE<12l>p95!IFTRB@2?!ed*hrra~`Sp-z5iO>!*iL%VKv}sSC z1oSkryTH}?(vW2pA@7)5Tcgu^@WrKI8MC_xP(gloj564qQIJ!`@R@%wJ$RVt0w%w{ zT~0{IbUhFH9F#^s&ihnR=JII5?H$ZL(^W%CuOQUNCh#e5K9D`1x7XXlY{)||)!QKv zA+i|ML-(`M7nJwA$8*G%vO?~BXHTKvI-l|qY|fo< zgl-PQC?7^MY4x96ivq&TW$&X>dEPJx3U51XFhla%U|C>r+H-cK)!7aMue{U_kPVn;o{nV9ngrc5?kOoHv=y9n?+1%9=p$o$}o|KmmjbVP@`HP~8^ z_L$00ocJqZ4Xn!U&yqs!DNK9rm7dae@POOky1_N$Q^bgr~yzSi|gf^+dc=yZf~*hBnKspdLhZ7g9J1U;|%MUYjP_ zRbP@R6G?!9Go?v9!Ih2`C)uHjhUUYJev3im!FUHpXM1Iaurfuw zQr0H_g^XS#l+u*Y93uK+JO=?iU$W@;TeS?}p2PP#xkIzL{2~)VT;eH%2uj7fRl?0z zU1xMZ@$=qCIq6%zvF)guZ%2!xe5?^~e!MH`ZTSR5huzElR%y7tFrGVkkFS96Pi0$@ z9|v9s8&i^v8fwn`&zpH=8~{edV>3JC9%_U)g!iETRi`^i$9o+cCxz{YLxnahAVT*6 zYY8Fb8$*2|Y~ZiUTz-}p=x1hDddlrhcVp8c?(|b|PSepU$?Xc(q#E5?$Gb+jl1o{u z?HN!YfplnGJ4~vsclZX@AKAaM(KP&gANXRxfiC{cXtVyhoNHoY_;C2D!{8@PKc|@~ zl!~y))E3J1@0KbT&(VmOY_xe94_3rl;tcFcvPjWMZJoz4K>v~Bh0{|mFJFm&{kcR3#lV-s4c%fQs#qnm&LFUM# z{w;R|qRI;C?3L+Usf5~FAWyFwZ`;E}=*X1sKo6z~GR960)9=}J8$QA9!}7ya_jOci zPYj&zeT??IXKi5kAyn*oRb=tP$4{`VonOWjGK#$_So6iA5g~J269<;TA7XnN2YmEQ z=7aCt@$dG)zy3AO1!6YnB$jI9O4Y;)p-uq85wcXYXL2+?%VZ@uuJ2Z{s@9CnJP4rt zdEhI44d}V9T#Q`(<~11!uDoQEx{wOnMMiSK459xNZ`sfV73L}Lv_DNrG059^H(LkO z*Itpq7+LPUYtLQatFBm2d18�BTTBH@jOlL{byc{y|%!&$mHTq7WG8u{#Y+3&JA_ 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 ax}={QNhjDAxpM}fzPIx4MV|2G9pF1ZmhEG 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

    OI;)0PyC?{O~uzpxJ%ouOe#THfF@VXob=loTu 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 Br)K~F delta 100496 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 renderMapToPng( - TiledComponent component, -) async { + TiledComponent component, { + bool? useGameCamera, +}) async { final canvasRecorder = PictureRecorder(); - final canvas = Canvas(canvasRecorder); - component.tileMap.renderTree(canvas); - final picture = canvasRecorder.endRecording(); + late final Canvas canvas; + + final Vector2 size; + if (useGameCamera ?? false) { + final game = component.game; + final camera = game.camera; + final viewport = camera.viewport; + canvas = Canvas(canvasRecorder); + + canvas.translate( + -(viewport.position.x - viewport.anchor.x * viewport.size.x), + -(viewport.position.y - viewport.anchor.y * viewport.size.y), + ); - final size = component.size; - // Map size is now 320 wide, but it has 1 extra tile of height because - // its actually double-height tiles. + //final oldPos = camera.viewfinder.position; + //camera.viewfinder.position = -oldPos; + canvas.transform2D(camera.viewfinder.transform.inverse()); + //camera.viewfinder.position = oldPos; + + camera.renderTree(canvas); + size = component.size; + } else { + canvas = Canvas(canvasRecorder); + component.tileMap.renderTree(canvas); + size = component.size; + } + final picture = canvasRecorder.endRecording(); final image = await picture.toImageSafe(size.x.toInt(), size.y.toInt()); return imageToPng(image); } diff --git a/packages/flame_tiled/test/tiled_test.dart b/packages/flame_tiled/test/tiled_test.dart index a3a2d4c918d..e6cd6489a84 100644 --- a/packages/flame_tiled/test/tiled_test.dart +++ b/packages/flame_tiled/test/tiled_test.dart @@ -1196,4 +1196,60 @@ void main() { expect(renderableTiledMap.getTileData(layerId: 5, x: 1, y: 1), isNull); }); }); + + group('parallax rendering', () { + late TiledComponent component; + + Future setupMap(FlameGame game, Vector2 offset) async { + Flame.bundle = TestAssetBundle( + imageNames: [ + 'images/diamond.png', + 'images/box2.png', + 'map-level1.png', + ], + stringNames: [ + 'parallax_test.tmx', + 'tiles/samelevel_tileset_1.tsx', + ], + ); + await Flame.images.ready(); + game.camera = CameraComponent(); /* CameraComponent.withFixedResolution( + width: 320, + height: 320, + );*/ + + //game.camera.viewfinder.zoom = 0.5; + + component = await TiledComponent.load( + 'parallax_test.tmx', + Vector2.all(16.0), + images: Images(bundle: Flame.bundle), + ); + await game.world.ensureAdd(component); + await game.ready(); + game.camera.viewfinder.position += offset; + game.updateTree(0.166); + await game.lifecycleEventsProcessed; + } + + testWithFlameGame('no camera offset', (game) async { + await setupMap(game, Vector2.zero()); + final pngData = await renderMapToPng(component, useGameCamera: true); + + expect( + pngData, + matchesGoldenFile('goldens/parallax_rendering_offset_none.png'), + ); + }); + + testWithFlameGame('some camera offset', (game) async { + await setupMap(game, Vector2(496, 272)); + final pngData = await renderMapToPng(component, useGameCamera: true); + + expect( + pngData, + matchesGoldenFile('goldens/parallax_rendering_offset_some.png'), + ); + }); + }); } From 22ce55d24784c9d24bf29246f3970458d4abc146 Mon Sep 17 00:00:00 2001 From: TheMaverickProgrammer <91709+TheMaverickProgrammer@users.noreply.github.com> Date: Mon, 15 Sep 2025 22:23:14 -0500 Subject: [PATCH 28/28] sync with upstream. TODO: update goldens for est_shifted.tmx. TODO: solve canvas recorder fringe case failing to capture the offset scene due to camera transforms. --- packages/flame_tiled/lib/src/renderable_tile_map.dart | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/flame_tiled/lib/src/renderable_tile_map.dart b/packages/flame_tiled/lib/src/renderable_tile_map.dart index 0ff7abed93b..06a0066a556 100644 --- a/packages/flame_tiled/lib/src/renderable_tile_map.dart +++ b/packages/flame_tiled/lib/src/renderable_tile_map.dart @@ -5,8 +5,8 @@ import 'package:flame/cache.dart'; import 'package:flame/components.dart'; import 'package:flame/extensions.dart'; import 'package:flame/flame.dart'; -import 'package:flame/rendering.dart'; import 'package:flame/game.dart'; +import 'package:flame/rendering.dart'; import 'package:flame_tiled/src/extensions.dart'; import 'package:flame_tiled/src/flame_tsx_provider.dart'; import 'package:flame_tiled/src/renderable_layers/group_layer.dart';