diff --git a/README.md b/README.md index 1a1bd67..27c9769 100644 --- a/README.md +++ b/README.md @@ -82,6 +82,26 @@ scarb build snforge test ``` +## 🧰 SDK + +The TypeScript SDK can fetch Beast data from Summit API, fall back to Voyager, and finally to RPC using the onchain data provider. It also renders the NFT card locally. + +```ts +import { createBeastSdk, generateBeastSvg, toBeastSvgInput } from "@lootsurvivor/beast-sdk"; + +const sdk = createBeastSdk({ + apiBaseUrl: "https://your-summit-api.example", + voyager: { + apiKey: "YOUR_VOYAGER_API_KEY", + }, + // RPC defaults to https://api.cartridge.gg/x/starknet/mainnet/rpc/v0_10 + // and the mainnet Beast data provider. +}); + +const { beasts } = await sdk.getAccountBeasts("0x0123..."); +const svg = beasts[0] ? generateBeastSvg(toBeastSvgInput(beasts[0])) : null; +``` + ## 🏗️ Architecture ### Smart Contract Structure diff --git a/sdk/.gitignore b/sdk/.gitignore new file mode 100644 index 0000000..b947077 --- /dev/null +++ b/sdk/.gitignore @@ -0,0 +1,2 @@ +node_modules/ +dist/ diff --git a/sdk/__tests__/client.test.ts b/sdk/__tests__/client.test.ts new file mode 100644 index 0000000..e7cf9e3 --- /dev/null +++ b/sdk/__tests__/client.test.ts @@ -0,0 +1,59 @@ +import { describe, expect, it } from "vitest"; +import { + normalizeStarknetAddress, + resolveBeastRenderData, + toBeastSvgInput, +} from "../client"; +import type { BeastOnchain } from "../types"; + +describe("client helpers", () => { + it("normalizes Starknet addresses", () => { + const normalized = normalizeStarknetAddress("0xabc"); + expect(normalized).toBe(`0x${"0".repeat(61)}abc`); + }); + + it("resolves render data from on-chain fields", () => { + const beast: BeastOnchain = { + tokenId: 77, + beastId: 29, + prefix: 2, + suffix: 1, + level: 4, + health: 10, + shiny: 1, + animated: 0, + rank: 2, + }; + + const resolved = resolveBeastRenderData(beast); + + expect(resolved.name).toBe("Dragon"); + expect(resolved.prefixName).toBe("Apocalypse"); + expect(resolved.suffixName).toBe("Bane"); + expect(resolved.fullName).toBe('"Apocalypse Bane" Dragon'); + expect(resolved.tier).toBe(1); + expect(resolved.type).toBe("Hunter"); + expect(resolved.power).toBe(20); + expect(resolved.shiny).toBe(true); + expect(resolved.animated).toBe(false); + expect(resolved.rank).toBe(2); + }); + + it("builds SVG input from render data", () => { + const beast: BeastOnchain = { + tokenId: 1, + beastId: 1, + prefix: 0, + suffix: 0, + level: 1, + health: 5, + shiny: 0, + animated: 0, + rank: 0, + }; + const resolved = resolveBeastRenderData(beast); + const svgInput = toBeastSvgInput(resolved); + expect(svgInput.beastId).toBe(1); + expect(svgInput.rank).toBe(0); + }); +}); diff --git a/sdk/__tests__/images.test.ts b/sdk/__tests__/images.test.ts new file mode 100644 index 0000000..7e37813 --- /dev/null +++ b/sdk/__tests__/images.test.ts @@ -0,0 +1,105 @@ +import { describe, it, expect } from 'vitest'; +import { + getBeastImageUrl, + getBeastImageUrls, + getBeastStaticImageUrl, + isLocalBeastImage, +} from '../images'; + +describe('Image URL generation', () => { + describe('getBeastImageUrl', () => { + it('returns correct path for static regular beast', () => { + expect(getBeastImageUrl(29, false, false)).toBe( + '/images/beasts/static/regular/dragon.png' + ); + }); + + it('returns correct path for static shiny beast', () => { + expect(getBeastImageUrl(29, true, false)).toBe( + '/images/beasts/static/shiny/dragon.png' + ); + }); + + it('returns correct path for animated regular beast', () => { + expect(getBeastImageUrl(29, false, true)).toBe( + '/images/beasts/animated/regular/dragon.gif' + ); + }); + + it('returns correct path for animated shiny beast', () => { + expect(getBeastImageUrl(29, true, true)).toBe( + '/images/beasts/animated/shiny/dragon.gif' + ); + }); + + it('handles multi-word beast names correctly', () => { + // Beast ID 66 is "Nemean Lion" -> should become "nemeanlion" + expect(getBeastImageUrl(66, false, false)).toBe( + '/images/beasts/static/regular/nemeanlion.png' + ); + }); + + it('handles various beast IDs', () => { + // Warlock (ID 1) + expect(getBeastImageUrl(1, false, false)).toBe( + '/images/beasts/static/regular/warlock.png' + ); + + // Kraken (ID 51) + expect(getBeastImageUrl(51, true, true)).toBe( + '/images/beasts/animated/shiny/kraken.gif' + ); + + // Fairy (ID 21) + expect(getBeastImageUrl(21, false, false)).toBe( + '/images/beasts/static/regular/fairy.png' + ); + }); + + it('handles unknown beast ID gracefully', () => { + expect(getBeastImageUrl(0, false, false)).toBe( + '/images/beasts/static/regular/unknown.png' + ); + expect(getBeastImageUrl(100, false, false)).toBe( + '/images/beasts/static/regular/unknown.png' + ); + }); + }); + + describe('getBeastImageUrls', () => { + it('returns both imageUrl and imageSmallUrl', () => { + const result = getBeastImageUrls(29, false, false); + expect(result.imageUrl).toBe('/images/beasts/static/regular/dragon.png'); + expect(result.imageSmallUrl).toBe('/images/beasts/static/regular/dragon.png'); + }); + + it('handles shiny and animated flags', () => { + const result = getBeastImageUrls(51, true, true); + expect(result.imageUrl).toBe('/images/beasts/animated/shiny/kraken.gif'); + expect(result.imageSmallUrl).toBe('/images/beasts/animated/shiny/kraken.gif'); + }); + }); + + describe('getBeastStaticImageUrl', () => { + it('always returns PNG static image', () => { + expect(getBeastStaticImageUrl(29, false)).toBe( + '/images/beasts/static/regular/dragon.png' + ); + expect(getBeastStaticImageUrl(29, true)).toBe( + '/images/beasts/static/shiny/dragon.png' + ); + }); + }); + + describe('isLocalBeastImage', () => { + it('returns true for local beast image URLs', () => { + expect(isLocalBeastImage('/images/beasts/static/regular/dragon.png')).toBe(true); + expect(isLocalBeastImage('/images/beasts/animated/shiny/kraken.gif')).toBe(true); + }); + + it('returns false for external URLs', () => { + expect(isLocalBeastImage('https://example.com/image.png')).toBe(false); + expect(isLocalBeastImage('/images/other/image.png')).toBe(false); + }); + }); +}); diff --git a/sdk/__tests__/index.test.ts b/sdk/__tests__/index.test.ts new file mode 100644 index 0000000..1eac0c8 --- /dev/null +++ b/sdk/__tests__/index.test.ts @@ -0,0 +1,140 @@ +import { describe, it, expect } from 'vitest'; +import { + getFullBeastName, + isGenesisBeast, + getTierColor, + calculatePower, + getBeastInfo, +} from '../index'; + +describe('Beast SDK utility functions', () => { + describe('getFullBeastName', () => { + it('returns beast name with prefix and suffix', () => { + expect(getFullBeastName(29, 'Apocalypse', 'Bane')).toBe( + '"Apocalypse Bane" Dragon' + ); + }); + + it('returns beast name with only prefix', () => { + expect(getFullBeastName(29, 'Apocalypse', null)).toBe( + '"Apocalypse" Dragon' + ); + }); + + it('returns beast name with only suffix', () => { + expect(getFullBeastName(29, null, 'Bane')).toBe('"Bane" Dragon'); + }); + + it('returns just beast name when no prefix or suffix', () => { + expect(getFullBeastName(29, null, null)).toBe('Dragon'); + }); + + it('handles unknown beast ID', () => { + expect(getFullBeastName(0, null, null)).toBe('Unknown'); + }); + }); + + describe('isGenesisBeast', () => { + it('returns true for token IDs 1-75', () => { + expect(isGenesisBeast(1)).toBe(true); + expect(isGenesisBeast(75)).toBe(true); + expect(isGenesisBeast(38)).toBe(true); + }); + + it('returns false for token IDs above 75', () => { + expect(isGenesisBeast(76)).toBe(false); + expect(isGenesisBeast(1000)).toBe(false); + expect(isGenesisBeast(99999)).toBe(false); + }); + + it('returns false for token ID 0', () => { + expect(isGenesisBeast(0)).toBe(false); + }); + + it('handles string token IDs', () => { + expect(isGenesisBeast('1')).toBe(true); + expect(isGenesisBeast('75')).toBe(true); + expect(isGenesisBeast('76')).toBe(false); + expect(isGenesisBeast('1001')).toBe(false); + }); + }); + + describe('getTierColor', () => { + it('returns orange for tier 1', () => { + expect(getTierColor(1)).toBe('#ff8800'); + }); + + it('returns purple for tier 2', () => { + expect(getTierColor(2)).toBe('#8c00bf'); + }); + + it('returns blue for tier 3', () => { + expect(getTierColor(3)).toBe('#0066ff'); + }); + + it('returns green for tier 4', () => { + expect(getTierColor(4)).toBe('#00cc00'); + }); + + it('returns gray for tier 5', () => { + expect(getTierColor(5)).toBe('#cccccc'); + }); + + it('returns gray for invalid tier', () => { + expect(getTierColor(0)).toBe('#cccccc'); + expect(getTierColor(6)).toBe('#cccccc'); + }); + }); + + describe('calculatePower', () => { + it('calculates power correctly for tier 1', () => { + // Power = (6 - tier) * level = 5 * level + expect(calculatePower(1, 10)).toBe(50); + expect(calculatePower(1, 20)).toBe(100); + }); + + it('calculates power correctly for tier 5', () => { + // Power = (6 - 5) * level = 1 * level + expect(calculatePower(5, 10)).toBe(10); + expect(calculatePower(5, 20)).toBe(20); + }); + + it('calculates power for various tiers', () => { + expect(calculatePower(2, 10)).toBe(40); // (6-2) * 10 = 40 + expect(calculatePower(3, 10)).toBe(30); // (6-3) * 10 = 30 + expect(calculatePower(4, 10)).toBe(20); // (6-4) * 10 = 20 + }); + }); + + describe('getBeastInfo', () => { + it('returns complete info for valid beast ID', () => { + const info = getBeastInfo(29); + expect(info.name).toBe('Dragon'); + expect(info.tier).toBe(1); + expect(info.type).toBe('Hunter'); + expect(info.tierColor).toBe('#ff8800'); + }); + + it('returns info for Magic beast', () => { + const info = getBeastInfo(1); + expect(info.name).toBe('Warlock'); + expect(info.tier).toBe(1); + expect(info.type).toBe('Magic'); + }); + + it('returns info for Brute beast', () => { + const info = getBeastInfo(51); + expect(info.name).toBe('Kraken'); + expect(info.tier).toBe(1); + expect(info.type).toBe('Brute'); + }); + + it('returns info for T5 beast', () => { + const info = getBeastInfo(21); + expect(info.name).toBe('Fairy'); + expect(info.tier).toBe(5); + expect(info.type).toBe('Magic'); + expect(info.tierColor).toBe('#cccccc'); + }); + }); +}); diff --git a/sdk/__tests__/lookups.test.ts b/sdk/__tests__/lookups.test.ts new file mode 100644 index 0000000..e2ac7b4 --- /dev/null +++ b/sdk/__tests__/lookups.test.ts @@ -0,0 +1,188 @@ +import { describe, it, expect } from 'vitest'; +import { + BEAST_NAMES, + BEAST_TIERS, + BEAST_TYPES, + ITEM_NAME_PREFIXES, + ITEM_NAME_SUFFIXES, + getBeastName, + getBeastTier, + getBeastType, + getPrefix, + getSuffix, +} from '../lookups'; + +describe('Beast lookup tables', () => { + describe('BEAST_NAMES', () => { + it('has 75 beast names', () => { + expect(Object.keys(BEAST_NAMES).length).toBe(75); + }); + + it('has correct names for T1 Magic beasts', () => { + expect(BEAST_NAMES[1]).toBe('Warlock'); + expect(BEAST_NAMES[2]).toBe('Typhon'); + expect(BEAST_NAMES[3]).toBe('Jiangshi'); + expect(BEAST_NAMES[4]).toBe('Anansi'); + expect(BEAST_NAMES[5]).toBe('Basilisk'); + }); + + it('has correct names for T1 Hunter beasts', () => { + expect(BEAST_NAMES[26]).toBe('Griffin'); + expect(BEAST_NAMES[27]).toBe('Manticore'); + expect(BEAST_NAMES[28]).toBe('Phoenix'); + expect(BEAST_NAMES[29]).toBe('Dragon'); + expect(BEAST_NAMES[30]).toBe('Minotaur'); + }); + + it('has correct names for T1 Brute beasts', () => { + expect(BEAST_NAMES[51]).toBe('Kraken'); + expect(BEAST_NAMES[52]).toBe('Colossus'); + expect(BEAST_NAMES[53]).toBe('Balrog'); + expect(BEAST_NAMES[54]).toBe('Leviathan'); + expect(BEAST_NAMES[55]).toBe('Tarrasque'); + }); + }); + + describe('BEAST_TIERS', () => { + it('has 75 tier entries', () => { + expect(Object.keys(BEAST_TIERS).length).toBe(75); + }); + + it('returns tier 1 for T1 beasts (IDs 1-5, 26-30, 51-55)', () => { + // Magic T1 + expect(BEAST_TIERS[1]).toBe(1); + expect(BEAST_TIERS[5]).toBe(1); + // Hunter T1 + expect(BEAST_TIERS[26]).toBe(1); + expect(BEAST_TIERS[30]).toBe(1); + // Brute T1 + expect(BEAST_TIERS[51]).toBe(1); + expect(BEAST_TIERS[55]).toBe(1); + }); + + it('returns tier 5 for T5 beasts (IDs 21-25, 46-50, 71-75)', () => { + // Magic T5 + expect(BEAST_TIERS[21]).toBe(5); + expect(BEAST_TIERS[25]).toBe(5); + // Hunter T5 + expect(BEAST_TIERS[46]).toBe(5); + expect(BEAST_TIERS[50]).toBe(5); + // Brute T5 + expect(BEAST_TIERS[71]).toBe(5); + expect(BEAST_TIERS[75]).toBe(5); + }); + }); + + describe('BEAST_TYPES', () => { + it('has 75 type entries', () => { + expect(Object.keys(BEAST_TYPES).length).toBe(75); + }); + + it('returns Magic for IDs 1-25', () => { + expect(BEAST_TYPES[1]).toBe('Magic'); + expect(BEAST_TYPES[13]).toBe('Magic'); + expect(BEAST_TYPES[25]).toBe('Magic'); + }); + + it('returns Hunter for IDs 26-50', () => { + expect(BEAST_TYPES[26]).toBe('Hunter'); + expect(BEAST_TYPES[38]).toBe('Hunter'); + expect(BEAST_TYPES[50]).toBe('Hunter'); + }); + + it('returns Brute for IDs 51-75', () => { + expect(BEAST_TYPES[51]).toBe('Brute'); + expect(BEAST_TYPES[63]).toBe('Brute'); + expect(BEAST_TYPES[75]).toBe('Brute'); + }); + }); + + describe('ITEM_NAME_PREFIXES', () => { + it('has 69 prefix names', () => { + expect(Object.keys(ITEM_NAME_PREFIXES).length).toBe(69); + }); + + it('has correct prefix values', () => { + expect(ITEM_NAME_PREFIXES[1]).toBe('Agony'); + expect(ITEM_NAME_PREFIXES[2]).toBe('Apocalypse'); + expect(ITEM_NAME_PREFIXES[69]).toBe('Shimmering'); + }); + }); + + describe('ITEM_NAME_SUFFIXES', () => { + it('has 18 suffix names', () => { + expect(Object.keys(ITEM_NAME_SUFFIXES).length).toBe(18); + }); + + it('has correct suffix values', () => { + expect(ITEM_NAME_SUFFIXES[1]).toBe('Bane'); + expect(ITEM_NAME_SUFFIXES[2]).toBe('Root'); + expect(ITEM_NAME_SUFFIXES[18]).toBe('Moon'); + }); + }); +}); + +describe('Lookup functions', () => { + describe('getBeastName', () => { + it('returns beast name for valid ID', () => { + expect(getBeastName(1)).toBe('Warlock'); + expect(getBeastName(29)).toBe('Dragon'); + expect(getBeastName(51)).toBe('Kraken'); + }); + + it('returns "Unknown" for invalid ID', () => { + expect(getBeastName(0)).toBe('Unknown'); + expect(getBeastName(76)).toBe('Unknown'); + expect(getBeastName(-1)).toBe('Unknown'); + }); + }); + + describe('getBeastTier', () => { + it('returns tier for valid ID', () => { + expect(getBeastTier(1)).toBe(1); + expect(getBeastTier(21)).toBe(5); + }); + + it('returns 5 (default) for invalid ID', () => { + expect(getBeastTier(0)).toBe(5); + expect(getBeastTier(100)).toBe(5); + }); + }); + + describe('getBeastType', () => { + it('returns type for valid ID', () => { + expect(getBeastType(1)).toBe('Magic'); + expect(getBeastType(26)).toBe('Hunter'); + expect(getBeastType(51)).toBe('Brute'); + }); + + it('returns "Unknown" for invalid ID', () => { + expect(getBeastType(0)).toBe('Unknown'); + expect(getBeastType(100)).toBe('Unknown'); + }); + }); + + describe('getPrefix', () => { + it('returns prefix for valid ID', () => { + expect(getPrefix(1)).toBe('Agony'); + expect(getPrefix(2)).toBe('Apocalypse'); + }); + + it('returns empty string for invalid ID', () => { + expect(getPrefix(0)).toBe(''); + expect(getPrefix(100)).toBe(''); + }); + }); + + describe('getSuffix', () => { + it('returns suffix for valid ID', () => { + expect(getSuffix(1)).toBe('Bane'); + expect(getSuffix(2)).toBe('Root'); + }); + + it('returns empty string for invalid ID', () => { + expect(getSuffix(0)).toBe(''); + expect(getSuffix(100)).toBe(''); + }); + }); +}); diff --git a/sdk/__tests__/metadata.test.ts b/sdk/__tests__/metadata.test.ts new file mode 100644 index 0000000..becd353 --- /dev/null +++ b/sdk/__tests__/metadata.test.ts @@ -0,0 +1,111 @@ +import { describe, it, expect } from "vitest"; +import { + parseTokenUri, + decodeSvgDataUri, + parseMetadataAttributes, + buildTokenUriFromJsonString, + buildTokenUri, + encodeSvgDataUri, + validateMetadataJson, + parseTokenUriDetailed, + parseTokenUriSafe, +} from "../metadata"; + +describe("metadata helpers", () => { + it("parses token URI with literal newlines in description", () => { + const rawJson = `{"name":"Beast","description":"Line1 +Line2","image":"data:image/svg+xml;base64,PHN2Zy8+","attributes":[{"trait_type":"Token ID","value":"1"},{"trait_type":"Beast ID","value":"3"},{"trait_type":"Beast","value":"Jiangshi"},{"trait_type":"Type","value":"Magic"},{"trait_type":"Tier","value":"1"},{"trait_type":"Level","value":"42"},{"trait_type":"Health","value":"1337"},{"trait_type":"Power","value":"210"},{"trait_type":"Rank","value":"5"},{"trait_type":"Shiny","value":"0"},{"trait_type":"Animated","value":"1"},{"trait_type":"Genesis","value":"1"}]}`; + const tokenUri = `data:application/json;base64,${Buffer.from(rawJson, "utf8").toString("base64")}`; + + const metadata = parseTokenUri(tokenUri); + expect(metadata.name).toBe("Beast"); + expect(metadata.description.includes("Line1")).toBe(true); + expect(metadata.description.includes("Line2")).toBe(true); + }); + + it("decodes svg data URIs", () => { + const svg = ""; + const dataUri = `data:image/svg+xml;base64,${Buffer.from(svg).toString("base64")}`; + expect(decodeSvgDataUri(dataUri)).toBe(svg); + }); + + it("encodes svg data URIs", () => { + const svg = ""; + const dataUri = encodeSvgDataUri(svg); + expect(decodeSvgDataUri(dataUri)).toBe(svg); + }); + + it("parses typed metadata attributes", () => { + const rawJson = `{"name":"Beast","description":"Desc","image":"data:image/svg+xml;base64,PHN2Zy8+","attributes":[{"trait_type":"Token ID","value":"1"},{"trait_type":"Beast ID","value":"3"},{"trait_type":"Beast","value":"Jiangshi"},{"trait_type":"Type","value":"Magic"},{"trait_type":"Tier","value":"1"},{"trait_type":"Level","value":"42"},{"trait_type":"Health","value":"1337"},{"trait_type":"Power","value":"210"},{"trait_type":"Rank","value":"5"},{"trait_type":"Shiny","value":"0"},{"trait_type":"Animated","value":"1"},{"trait_type":"Genesis","value":"1"}]}`; + const tokenUri = `data:application/json;base64,${Buffer.from(rawJson, "utf8").toString("base64")}`; + const metadata = parseTokenUri(tokenUri); + const parsed = parseMetadataAttributes(metadata); + + expect(parsed.tokenId).toBe(1); + expect(parsed.beastId).toBe(3); + expect(parsed.beast).toBe("Jiangshi"); + expect(parsed.type).toBe("Magic"); + expect(parsed.tier).toBe(1); + expect(parsed.level).toBe(42); + expect(parsed.health).toBe(1337); + expect(parsed.power).toBe(210); + expect(parsed.rank).toBe(5); + expect(parsed.shiny).toBe(0); + expect(parsed.animated).toBe(1); + expect(parsed.genesis).toBe(1); + }); + + it("builds token URIs from raw JSON strings", () => { + const rawJson = `{"name":"Beast","description":"Line1 +Line2","image":"data:image/svg+xml;base64,PHN2Zy8+","attributes":[]}`; + const tokenUri = buildTokenUriFromJsonString(rawJson); + const parsed = parseTokenUri(tokenUri); + expect(parsed.description.includes("Line1")).toBe(true); + expect(parsed.description.includes("Line2")).toBe(true); + }); + + it("builds token URIs from JSON objects", () => { + const metadata = { + name: "Beast", + description: "Desc", + image: "data:image/svg+xml;base64,PHN2Zy8+", + attributes: [], + }; + const tokenUri = buildTokenUri(metadata); + const parsed = parseTokenUri(tokenUri); + expect(parsed.name).toBe("Beast"); + }); + + it("validates metadata JSON shape", () => { + const ok = validateMetadataJson({ + name: "Beast", + description: "Desc", + image: "data:image/svg+xml;base64,PHN2Zy8+", + attributes: [{ trait_type: "Token ID", value: "1" }], + }); + expect(ok.ok).toBe(true); + + const bad = validateMetadataJson({ + name: "Beast", + description: "Desc", + image: "data:image/svg+xml;base64,PHN2Zy8+", + attributes: [{ trait_type: "Token ID", value: 1 }], + }); + expect(bad.ok).toBe(false); + }); + + it("parses token URIs into detailed views", () => { + const rawJson = `{"name":"Beast","description":"Desc","image":"data:image/svg+xml;base64,PHN2Zy8+","attributes":[{"trait_type":"Token ID","value":"1"}]}`; + const tokenUri = buildTokenUriFromJsonString(rawJson); + const detailed = parseTokenUriDetailed(tokenUri, { decodeSvg: true }); + expect(detailed.attributes.tokenId).toBe(1); + expect(detailed.imageSvg).toBe(""); + }); + + it("safe-parses invalid token URIs", () => { + const tokenUri = "data:application/json;base64,invalid"; + const result = parseTokenUriSafe(tokenUri, { validate: true }); + expect(result.ok).toBe(false); + expect(result.error).toBeDefined(); + }); +}); diff --git a/sdk/__tests__/svg.test.ts b/sdk/__tests__/svg.test.ts new file mode 100644 index 0000000..f0cbed2 --- /dev/null +++ b/sdk/__tests__/svg.test.ts @@ -0,0 +1,37 @@ +import { describe, it, expect } from 'vitest'; +import { generateBeastSvg } from '../svg'; + +describe('SVG generation', () => { + it('uses PNG data URI by default', () => { + const svg = generateBeastSvg({ + beastId: 1, + prefix: null, + suffix: null, + tier: 1, + level: 1, + health: 1, + power: 1, + shiny: false, + rank: null, + }); + + expect(svg.includes('data:image/png;base64,')).toBe(true); + }); + + it('uses GIF data URI when animated is true', () => { + const svg = generateBeastSvg({ + beastId: 1, + prefix: null, + suffix: null, + tier: 1, + level: 1, + health: 1, + power: 1, + shiny: false, + rank: null, + animated: true, + }); + + expect(svg.includes('data:image/gif;base64,')).toBe(true); + }); +}); diff --git a/sdk/__tests__/utils.test.ts b/sdk/__tests__/utils.test.ts new file mode 100644 index 0000000..a9820a1 --- /dev/null +++ b/sdk/__tests__/utils.test.ts @@ -0,0 +1,22 @@ +import { describe, it, expect } from "vitest"; +import { calculatePowerClamped, isHigherRank } from "../utils"; + +describe("utility helpers", () => { + it("clamps power to u16 max", () => { + // Tier 1 => multiplier 5, max level before clamp = floor(65535 / 5) = 13107 + expect(calculatePowerClamped(1, 13107)).toBe(65535); + expect(calculatePowerClamped(1, 13108)).toBe(65535); + }); + + it("calculates unclamped power correctly", () => { + expect(calculatePowerClamped(2, 10)).toBe(40); // (6-2)*10 + expect(calculatePowerClamped(5, 10)).toBe(10); // (6-5)*10 + }); + + it("compares rank by power then health", () => { + expect(isHigherRank(50, 10, 40, 999)).toBe(true); + expect(isHigherRank(50, 10, 50, 9)).toBe(true); + expect(isHigherRank(50, 10, 50, 10)).toBe(false); + expect(isHigherRank(40, 100, 50, 1)).toBe(false); + }); +}); diff --git a/sdk/__tests__/validation.test.ts b/sdk/__tests__/validation.test.ts new file mode 100644 index 0000000..8ab5a4c --- /dev/null +++ b/sdk/__tests__/validation.test.ts @@ -0,0 +1,51 @@ +import { describe, it, expect } from "vitest"; +import { + validateBeastId, + validateBeastAttributes, + validateBeastInput, + createGenesisBeast, + GENESIS_DEFAULTS, +} from "../validation"; + +describe("validation helpers", () => { + it("validates beast IDs", () => { + expect(validateBeastId(1).ok).toBe(true); + expect(validateBeastId(75).ok).toBe(true); + expect(validateBeastId(0).ok).toBe(false); + expect(validateBeastId(76).ok).toBe(false); + }); + + it("validates beast attributes", () => { + expect(validateBeastAttributes(0, 0, 0, 0).ok).toBe(true); + expect(validateBeastAttributes(69, 18, 1, 1).ok).toBe(true); + expect(validateBeastAttributes(70, 0, 0, 0).ok).toBe(false); + expect(validateBeastAttributes(0, 19, 0, 0).ok).toBe(false); + expect(validateBeastAttributes(0, 0, 2, 0).ok).toBe(false); + expect(validateBeastAttributes(0, 0, 0, 2).ok).toBe(false); + expect(validateBeastAttributes(-1, 0, 0, 0).ok).toBe(false); + }); + + it("validates full beast input", () => { + const result = validateBeastInput({ + beastId: 10, + prefix: 1, + suffix: 2, + level: 10, + health: 100, + shiny: 1, + animated: 0, + }); + expect(result.ok).toBe(true); + }); + + it("creates genesis beast defaults", () => { + const genesis = createGenesisBeast(5); + expect(genesis.beastId).toBe(5); + expect(genesis.prefix).toBe(GENESIS_DEFAULTS.prefix); + expect(genesis.suffix).toBe(GENESIS_DEFAULTS.suffix); + expect(genesis.level).toBe(GENESIS_DEFAULTS.level); + expect(genesis.health).toBe(GENESIS_DEFAULTS.health); + expect(genesis.shiny).toBe(GENESIS_DEFAULTS.shiny); + expect(genesis.animated).toBe(GENESIS_DEFAULTS.animated); + }); +}); diff --git a/sdk/client.ts b/sdk/client.ts new file mode 100644 index 0000000..364d052 --- /dev/null +++ b/sdk/client.ts @@ -0,0 +1,1060 @@ +/** + * Beast SDK client + * + * Provides data fetching from Summit API, Voyager API, or RPC fallback. + */ + +import { + getBeastName, + getBeastTier, + getBeastType, + getBeastIdByName, + getPrefix, + getPrefixIdByName, + getSuffix, + getSuffixIdByName, +} from "./lookups"; +import { calculatePower } from "./utils"; +import type { + BeastOnchain, + BeastRenderData, + BeastFetchResult, + SummitBeastListResponse, + SummitBeastRow, +} from "./types"; +import type { BeastSvgInput } from "./svg"; + +const DEFAULT_RPC_URL = "https://api.cartridge.gg/x/starknet/mainnet/rpc/v0_10"; +const DEFAULT_DATA_PROVIDER_ADDRESS = + "0x00a23b848b296094b592b6a1944fa72de64fcd620b33403b22a2414a76b0a964"; +const DEFAULT_BEAST_NFT_ADDRESS = + "0x046da8955829adf2bda310099a0063451923f02e648cf25a1203aac6335cf0e4"; + +const DEFAULT_VOYAGER_API_URL = "https://api.voyager.online/beta"; + +const DEFAULT_OWNERSHIP_BATCHES = 8; +const DEFAULT_RPC_TIMEOUT_MS = 300_000; +const DEFAULT_RPC_CONCURRENCY = 8; +const DEFAULT_API_TIMEOUT_MS = 30_000; +const DEFAULT_PAGE_SIZE = 100; + +const TOTAL_SUPPLY_SELECTOR = + "0x01557182e4359a1f0c6301278e8f5b35a776ab58d39892581e357578fb287836"; +const GET_BEAST_OWNERS_RANGE_SELECTOR = + "0x01ce5018d4217224edbb53a2cb09e8aac71c3bf9a108f07e4133207bf2161a45"; +const GET_BEAST_SELECTOR = + "0x0385b69551f247794fe651459651cdabc76b6cdf4abacafb5b28ceb3b1ac2e98"; +const GET_BEAST_RANK_SELECTOR = + "0x021d56a4b44096b9487419b2c0f193d1813e09b7737e8f4a1a0de093224281e4"; + +export interface BeastSdkConfig { + /** Base URL for Summit API (e.g. https://api.example.com). */ + apiBaseUrl?: string; + /** Timeout for Summit API requests (ms). */ + apiRequestTimeoutMs?: number; + /** Page size for Summit API /beasts/all (max 100). */ + apiPageSize?: number; + /** Voyager API settings (fallback between API and RPC). */ + voyager?: { + apiUrl?: string; + apiKey?: string; + requestTimeoutMs?: number; + pageSize?: number; + }; + /** RPC settings (final fallback). */ + rpc?: { + url?: string; + dataProviderAddress?: string; + beastNftAddress?: string; + ownershipBatches?: number; + requestTimeoutMs?: number; + concurrency?: number; + }; + /** Custom fetch implementation (defaults to global fetch). */ + fetch?: typeof fetch; +} + +export interface BeastSdkClient { + getAccountBeasts( + owner: string, + options?: GetAccountBeastsOptions + ): Promise; + getAccountTokenIds( + owner: string, + options?: GetAccountTokenIdsOptions + ): Promise; + getBeastsByTokenIds( + tokenIds: number[], + options?: GetBeastsByTokenIdsOptions + ): Promise; +} + +export interface GetAccountBeastsOptions { + includeRank?: boolean; +} + +export interface GetAccountTokenIdsOptions { + /** + * @deprecated Voyager is always attempted when configured. + */ + allowVoyagerFallback?: boolean; +} + +export interface GetBeastsByTokenIdsOptions { + includeRank?: boolean; +} + +interface VoyagerAttribute { + trait_type: string; + value: string; +} + +interface VoyagerNftItem { + tokenId: string; + attributes?: VoyagerAttribute[] | null; +} + +interface VoyagerResponse { + items: VoyagerNftItem[]; + pagination?: { + next?: string | null; + }; +} + +export function createBeastSdk(config: BeastSdkConfig = {}): BeastSdkClient { + const fetcher = config.fetch ?? globalThis.fetch; + if (!fetcher) { + throw new Error("fetch is not available; provide BeastSdkConfig.fetch"); + } + + const apiBaseUrl = config.apiBaseUrl?.replace(/\/$/, ""); + const apiTimeoutMs = config.apiRequestTimeoutMs ?? DEFAULT_API_TIMEOUT_MS; + const apiPageSize = Math.min( + Math.max(1, config.apiPageSize ?? DEFAULT_PAGE_SIZE), + DEFAULT_PAGE_SIZE + ); + + const voyagerApiUrl = config.voyager?.apiUrl ?? DEFAULT_VOYAGER_API_URL; + const voyagerApiKey = config.voyager?.apiKey; + const voyagerTimeoutMs = + config.voyager?.requestTimeoutMs ?? DEFAULT_API_TIMEOUT_MS; + const voyagerPageSize = Math.min( + Math.max(1, config.voyager?.pageSize ?? DEFAULT_PAGE_SIZE), + DEFAULT_PAGE_SIZE + ); + + const rpcUrl = config.rpc?.url ?? DEFAULT_RPC_URL; + const dataProviderAddress = + config.rpc?.dataProviderAddress ?? DEFAULT_DATA_PROVIDER_ADDRESS; + const beastNftAddress = + config.rpc?.beastNftAddress ?? DEFAULT_BEAST_NFT_ADDRESS; + const ownershipBatches = + Math.max(1, config.rpc?.ownershipBatches ?? DEFAULT_OWNERSHIP_BATCHES); + const rpcTimeoutMs = config.rpc?.requestTimeoutMs ?? DEFAULT_RPC_TIMEOUT_MS; + const rpcConcurrency = Math.max( + 1, + config.rpc?.concurrency ?? DEFAULT_RPC_CONCURRENCY + ); + + async function getAccountBeasts( + owner: string, + options?: GetAccountBeastsOptions + ): Promise { + const includeRank = options?.includeRank ?? true; + const normalizedOwner = normalizeStarknetAddress(owner); + + if (apiBaseUrl) { + try { + const beasts = await fetchSummitBeasts( + fetcher, + apiBaseUrl, + normalizedOwner, + apiPageSize, + apiTimeoutMs + ); + const ranked = includeRank + ? await fillMissingRanks(fetcher, beasts) + : beasts; + return { + beasts: resolveBeastRenderDataList(ranked), + source: "summit-api", + }; + } catch (error) { + // fall through to Voyager or RPC + void error; + } + } + + if (voyagerApiKey) { + try { + const beasts = await fetchVoyagerBeasts( + fetcher, + voyagerApiUrl, + voyagerApiKey, + beastNftAddress, + normalizedOwner, + voyagerPageSize, + voyagerTimeoutMs + ); + const ranked = includeRank + ? await fillMissingRanks(fetcher, beasts) + : beasts; + return { + beasts: resolveBeastRenderDataList(ranked), + source: "voyager", + }; + } catch (error) { + // fall through to RPC + void error; + } + } + + const tokenIds = await getTokenIdsByOwnerViaRpc( + fetcher, + rpcUrl, + beastNftAddress, + dataProviderAddress, + normalizedOwner, + ownershipBatches, + rpcTimeoutMs + ); + const beasts = await getBeastsByTokenIdsViaRpc( + fetcher, + rpcUrl, + beastNftAddress, + tokenIds, + rpcTimeoutMs, + rpcConcurrency + ); + const ranked = includeRank + ? await fillMissingRanks(fetcher, beasts) + : beasts; + return { beasts: resolveBeastRenderDataList(ranked), source: "rpc" }; + } + + async function getAccountTokenIds( + owner: string, + options?: GetAccountTokenIdsOptions + ): Promise { + const normalizedOwner = normalizeStarknetAddress(owner); + + if (apiBaseUrl) { + try { + const tokenIds = await fetchSummitTokenIds( + fetcher, + apiBaseUrl, + normalizedOwner, + apiPageSize, + apiTimeoutMs + ); + return tokenIds; + } catch (error) { + void error; + } + } + + if (voyagerApiKey) { + try { + const tokenIds = await fetchVoyagerTokenIds( + fetcher, + voyagerApiUrl, + voyagerApiKey, + beastNftAddress, + normalizedOwner, + voyagerPageSize, + voyagerTimeoutMs + ); + return tokenIds; + } catch (error) { + void error; + } + } + + return getTokenIdsByOwnerViaRpc( + fetcher, + rpcUrl, + beastNftAddress, + dataProviderAddress, + normalizedOwner, + ownershipBatches, + rpcTimeoutMs + ); + } + + async function getBeastsByTokenIds( + tokenIds: number[], + options?: GetBeastsByTokenIdsOptions + ): Promise { + const includeRank = options?.includeRank ?? true; + + const beasts = await getBeastsByTokenIdsViaRpc( + fetcher, + rpcUrl, + beastNftAddress, + tokenIds, + rpcTimeoutMs, + rpcConcurrency + ); + const ranked = includeRank + ? await fillMissingRanks(fetcher, beasts) + : beasts; + return { beasts: resolveBeastRenderDataList(ranked), source: "rpc" }; + } + + async function fillMissingRanks( + fetchImpl: typeof fetch, + beasts: BeastOnchain[] + ): Promise { + const missing = beasts.filter( + (beast) => beast.rank == null && !isGenesisToken(beast.tokenId) + ); + + if (missing.length === 0) { + return beasts.map((beast) => ({ + ...beast, + rank: beast.rank ?? (isGenesisToken(beast.tokenId) ? 0 : null), + })); + } + + const ranks = await getBeastRanksViaRpc( + fetchImpl, + rpcUrl, + beastNftAddress, + missing.map((beast) => beast.tokenId), + rpcTimeoutMs, + rpcConcurrency + ); + + return beasts.map((beast) => ({ + ...beast, + rank: + beast.rank ?? + ranks.get(beast.tokenId) ?? + (isGenesisToken(beast.tokenId) ? 0 : null), + })); + } + + return { + getAccountBeasts, + getAccountTokenIds, + getBeastsByTokenIds, + }; +} + +export function resolveBeastRenderData(beast: BeastOnchain): BeastRenderData { + const name = getBeastName(beast.beastId); + const tier = getBeastTier(beast.beastId); + const type = getBeastType(beast.beastId) as BeastRenderData["type"]; + const prefixName = beast.prefix > 0 ? getPrefix(beast.prefix) : null; + const suffixName = beast.suffix > 0 ? getSuffix(beast.suffix) : null; + const fullName = formatFullName(name, prefixName, suffixName); + const power = calculatePower(tier, beast.level); + const rank = + beast.rank ?? (isGenesisToken(beast.tokenId) ? 0 : null); + + return { + tokenId: beast.tokenId, + beastId: beast.beastId, + prefix: beast.prefix, + suffix: beast.suffix, + level: beast.level, + health: beast.health, + shiny: beast.shiny === 1, + animated: beast.animated === 1, + rank, + name, + prefixName, + suffixName, + fullName, + tier, + type, + power, + }; +} + +export function resolveBeastRenderDataList( + beasts: BeastOnchain[] +): BeastRenderData[] { + return beasts + .map(resolveBeastRenderData) + .sort((a, b) => a.tokenId - b.tokenId); +} + +export function toBeastSvgInput(beast: BeastRenderData): BeastSvgInput { + return { + beastId: beast.beastId, + prefix: beast.prefixName, + suffix: beast.suffixName, + tier: beast.tier, + level: beast.level, + health: beast.health, + power: beast.power, + shiny: beast.shiny, + rank: beast.rank, + animated: beast.animated, + }; +} + +export function normalizeStarknetAddress(address: string): string { + const trimmed = address.trim().toLowerCase(); + if (!trimmed) { + throw new Error("Address is empty"); + } + const hex = trimmed.startsWith("0x") ? trimmed.slice(2) : trimmed; + const value = BigInt(`0x${hex}`); + return `0x${value.toString(16).padStart(64, "0")}`; +} + +function normalizeStarknetAddressLoose(address: string): string { + const trimmed = address.trim().toLowerCase(); + if (!trimmed) { + return ""; + } + const hex = trimmed.startsWith("0x") ? trimmed.slice(2) : trimmed; + if (!hex) { + return `0x${"0".repeat(64)}`; + } + if (hex.length > 64) { + return normalizeStarknetAddress(address); + } + return `0x${hex.padStart(64, "0")}`; +} + +function formatFullName( + beastName: string, + prefix: string | null, + suffix: string | null +): string { + if (prefix && suffix) { + return `"${prefix} ${suffix}" ${beastName}`; + } + if (prefix) { + return `"${prefix}" ${beastName}`; + } + if (suffix) { + return `"${suffix}" ${beastName}`; + } + return beastName; +} + +function isGenesisToken(tokenId: number): boolean { + return tokenId >= 1 && tokenId <= 75; +} + +function toHex(value: bigint | number): string { + return `0x${BigInt(value).toString(16)}`; +} + +function toU256Calldata(value: bigint | number): [string, string] { + const big = BigInt(value); + const lowMask = (1n << 128n) - 1n; + const low = big & lowMask; + const high = big >> 128n; + return [toHex(low), toHex(high)]; +} + +function parseFeltNumber(value: string, field: string): number { + try { + return Number(BigInt(value)); + } catch (error) { + throw new Error(`Invalid felt for ${field}: ${value}`); + } +} + +function coerceNumber(value: unknown, field: string): number { + if (typeof value === "number") { + return value; + } + if (typeof value === "string") { + try { + return Number(BigInt(value)); + } catch { + const parsed = parseInt(value, 10); + if (!Number.isNaN(parsed)) { + return parsed; + } + } + } + throw new Error(`Invalid number for ${field}`); +} + +async function fetchJson( + fetchImpl: typeof fetch, + url: string, + init: RequestInit, + timeoutMs: number +): Promise { + const controller = new AbortController(); + const timeoutId = setTimeout(() => controller.abort(), timeoutMs); + try { + const response = await fetchImpl(url, { + ...init, + signal: controller.signal, + }); + if (!response.ok) { + throw new Error(`HTTP ${response.status} ${response.statusText}`); + } + return (await response.json()) as T; + } finally { + clearTimeout(timeoutId); + } +} + +async function fetchSummitBeasts( + fetchImpl: typeof fetch, + baseUrl: string, + owner: string, + pageSize: number, + timeoutMs: number +): Promise { + const beasts: BeastOnchain[] = []; + let offset = 0; + let hasMore = true; + + while (hasMore) { + const url = new URL(`${baseUrl}/beasts/all`); + url.searchParams.set("owner", owner); + url.searchParams.set("limit", pageSize.toString()); + url.searchParams.set("offset", offset.toString()); + + const response = await fetchJson( + fetchImpl, + url.toString(), + { method: "GET" }, + timeoutMs + ); + + for (const row of response.data) { + beasts.push(parseSummitBeastRow(row)); + } + + hasMore = Boolean(response.pagination?.has_more); + offset += response.data.length; + + if (response.data.length === 0) { + hasMore = false; + } + } + + return beasts; +} + +async function fetchSummitTokenIds( + fetchImpl: typeof fetch, + baseUrl: string, + owner: string, + pageSize: number, + timeoutMs: number +): Promise { + const tokenIds: number[] = []; + let offset = 0; + let hasMore = true; + + while (hasMore) { + const url = new URL(`${baseUrl}/beasts/all`); + url.searchParams.set("owner", owner); + url.searchParams.set("limit", pageSize.toString()); + url.searchParams.set("offset", offset.toString()); + + const response = await fetchJson( + fetchImpl, + url.toString(), + { method: "GET" }, + timeoutMs + ); + + for (const row of response.data) { + tokenIds.push(coerceNumber(row.token_id, "token_id")); + } + + hasMore = Boolean(response.pagination?.has_more); + offset += response.data.length; + + if (response.data.length === 0) { + hasMore = false; + } + } + + return tokenIds; +} + +function parseSummitBeastRow(row: SummitBeastRow): BeastOnchain { + return { + tokenId: coerceNumber(row.token_id, "token_id"), + beastId: coerceNumber(row.beast_id, "beast_id"), + prefix: coerceNumber(row.prefix, "prefix"), + suffix: coerceNumber(row.suffix, "suffix"), + level: coerceNumber(row.level, "level"), + health: coerceNumber(row.health, "health"), + shiny: coerceNumber(row.shiny, "shiny"), + animated: coerceNumber(row.animated, "animated"), + }; +} + +async function fetchVoyagerBeasts( + fetchImpl: typeof fetch, + apiUrl: string, + apiKey: string, + contractAddress: string, + owner: string, + pageSize: number, + timeoutMs: number +): Promise { + const beasts: BeastOnchain[] = []; + let cursor: string | null = null; + let hasMore = true; + + while (hasMore) { + const url = new URL(`${apiUrl}/nft-items`); + url.searchParams.set("contract_address", contractAddress); + url.searchParams.set("owner_address", owner); + url.searchParams.set("limit", pageSize.toString()); + if (cursor) { + url.searchParams.set("cursor", cursor); + } + + const response = await fetchJson( + fetchImpl, + url.toString(), + { + method: "GET", + headers: { + "x-api-key": apiKey, + "Content-Type": "application/json", + }, + }, + timeoutMs + ); + + for (const item of response.items) { + beasts.push(parseVoyagerBeastItem(item)); + } + + const nextCursor = extractCursorFromUrl(response.pagination?.next ?? null); + if (!nextCursor || response.items.length < pageSize) { + hasMore = false; + } else { + cursor = nextCursor; + } + } + + return beasts; +} + +async function fetchVoyagerTokenIds( + fetchImpl: typeof fetch, + apiUrl: string, + apiKey: string, + contractAddress: string, + owner: string, + pageSize: number, + timeoutMs: number +): Promise { + const tokenIds: number[] = []; + let cursor: string | null = null; + let hasMore = true; + + while (hasMore) { + const url = new URL(`${apiUrl}/nft-items`); + url.searchParams.set("contract_address", contractAddress); + url.searchParams.set("owner_address", owner); + url.searchParams.set("limit", pageSize.toString()); + if (cursor) { + url.searchParams.set("cursor", cursor); + } + + const response = await fetchJson( + fetchImpl, + url.toString(), + { + method: "GET", + headers: { + "x-api-key": apiKey, + "Content-Type": "application/json", + }, + }, + timeoutMs + ); + + for (const item of response.items) { + tokenIds.push(coerceNumber(item.tokenId, "tokenId")); + } + + const nextCursor = extractCursorFromUrl(response.pagination?.next ?? null); + if (!nextCursor || response.items.length < pageSize) { + hasMore = false; + } else { + cursor = nextCursor; + } + } + + return tokenIds; +} + +function extractCursorFromUrl(url: string | null): string | null { + if (!url) return null; + try { + const urlObj = new URL(url, DEFAULT_VOYAGER_API_URL); + return urlObj.searchParams.get("cursor"); + } catch { + return null; + } +} + +function getAttributeValue( + attributes: VoyagerAttribute[] | null | undefined, + traitType: string +): string | null { + if (!attributes) return null; + const attr = attributes.find((attr) => attr.trait_type === traitType); + return attr?.value ?? null; +} + +function getAttributeNumber( + attributes: VoyagerAttribute[] | null | undefined, + traitType: string +): number | null { + const value = getAttributeValue(attributes, traitType); + if (value == null) return null; + const parsed = parseInt(value, 10); + return Number.isNaN(parsed) ? null : parsed; +} + +function getAttributeBoolean( + attributes: VoyagerAttribute[] | null | undefined, + traitType: string +): boolean { + const value = getAttributeValue(attributes, traitType); + if (value == null) return false; + const normalized = value.toLowerCase(); + return normalized === "true" || normalized === "1"; +} + +function parseVoyagerBeastItem(item: VoyagerNftItem): BeastOnchain { + const attributes = item.attributes ?? null; + const tokenId = coerceNumber(item.tokenId, "tokenId"); + const beastId = + getAttributeNumber(attributes, "Beast ID") ?? + getAttributeNumber(attributes, "Beast Id") ?? + getAttributeNumber(attributes, "BeastId") ?? + getBeastIdByName(getAttributeValue(attributes, "Beast")); + + if (beastId == null) { + throw new Error("Voyager item missing Beast ID"); + } + + const prefixName = getAttributeValue(attributes, "Prefix"); + const suffixName = getAttributeValue(attributes, "Suffix"); + const level = getAttributeNumber(attributes, "Level"); + const health = getAttributeNumber(attributes, "Health"); + + if (level == null || health == null) { + throw new Error("Voyager item missing Level/Health"); + } + + const prefix = getPrefixIdByName(prefixName) ?? 0; + const suffix = getSuffixIdByName(suffixName) ?? 0; + + const shiny = + getAttributeBoolean(attributes, "Shiny") || + getAttributeBoolean(attributes, "Is Shiny"); + const animated = + getAttributeBoolean(attributes, "Animated") || + getAttributeBoolean(attributes, "Is Animated"); + const rank = + getAttributeNumber(attributes, "Rank") ?? + (isGenesisToken(tokenId) ? 0 : null); + + return { + tokenId, + beastId, + prefix, + suffix, + level, + health, + shiny: shiny ? 1 : 0, + animated: animated ? 1 : 0, + rank, + }; +} + +async function rpcCall( + fetchImpl: typeof fetch, + rpcUrl: string, + method: string, + params: Record, + timeoutMs: number +): Promise { + const controller = new AbortController(); + const timeoutId = setTimeout(() => controller.abort(), timeoutMs); + + try { + const response = await fetchImpl(rpcUrl, { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }), + signal: controller.signal, + }); + + const data = (await response.json()) as { + result?: string[]; + error?: { code: number; message: string }; + }; + + if (data.error) { + throw new Error(`RPC error: ${data.error.message}`); + } + + return data.result ?? []; + } finally { + clearTimeout(timeoutId); + } +} + +async function getTotalSupply( + fetchImpl: typeof fetch, + rpcUrl: string, + beastNftAddress: string, + timeoutMs: number +): Promise { + const params = { + request: { + contract_address: beastNftAddress, + entry_point_selector: TOTAL_SUPPLY_SELECTOR, + calldata: [], + }, + block_id: "latest", + }; + + const result = await rpcCall( + fetchImpl, + rpcUrl, + "starknet_call", + params, + timeoutMs + ); + + const low = result[0] ? BigInt(result[0]) : 0n; + const high = result[1] ? BigInt(result[1]) : 0n; + const total = low + (high << 128n); + + if (total > BigInt(Number.MAX_SAFE_INTEGER)) { + throw new Error("total_supply exceeds MAX_SAFE_INTEGER"); + } + + return Number(total); +} + +async function getTokenIdsByOwnerViaRpc( + fetchImpl: typeof fetch, + rpcUrl: string, + beastNftAddress: string, + dataProviderAddress: string, + owner: string, + batches: number, + timeoutMs: number +): Promise { + const totalSupply = await getTotalSupply( + fetchImpl, + rpcUrl, + beastNftAddress, + timeoutMs + ); + + if (totalSupply === 0) { + return []; + } + + const safeBatches = Math.max(1, batches); + const batchSize = Math.ceil(totalSupply / safeBatches); + const ranges: Array<[number, number]> = []; + + for (let i = 0; i < safeBatches; i++) { + const start = i * batchSize + 1; + const end = Math.min((i + 1) * batchSize, totalSupply); + if (start <= totalSupply) { + ranges.push([start, end]); + } + } + + const normalizedOwner = normalizeStarknetAddress(owner); + + const results = await Promise.all( + ranges.map(([start, end]) => + getBeastOwnersRange( + fetchImpl, + rpcUrl, + dataProviderAddress, + start, + end, + normalizedOwner, + timeoutMs + ) + ) + ); + + return results.flat().sort((a, b) => a - b); +} + +async function getBeastOwnersRange( + fetchImpl: typeof fetch, + rpcUrl: string, + dataProviderAddress: string, + startToken: number, + endToken: number, + owner: string, + timeoutMs: number +): Promise { + const params = { + request: { + contract_address: dataProviderAddress, + entry_point_selector: GET_BEAST_OWNERS_RANGE_SELECTOR, + calldata: [toHex(startToken), toHex(endToken)], + }, + block_id: "latest", + }; + + const result = await rpcCall( + fetchImpl, + rpcUrl, + "starknet_call", + params, + timeoutMs + ); + + if (result.length === 0) { + return []; + } + + const count = parseFeltNumber(result[0], "owners_length"); + const matches: number[] = []; + + for (let i = 0; i < count; i++) { + const ownerIndex = 1 + i; + if (ownerIndex >= result.length) break; + const tokenOwner = normalizeStarknetAddressLoose(result[ownerIndex]); + if (tokenOwner === owner) { + matches.push(startToken + i); + } + } + + return matches; +} + +async function getBeastsByTokenIdsViaRpc( + fetchImpl: typeof fetch, + rpcUrl: string, + beastNftAddress: string, + tokenIds: number[], + timeoutMs: number, + concurrency: number +): Promise { + if (tokenIds.length === 0) return []; + + const results = await mapWithConcurrency(tokenIds, concurrency, async (tokenId) => { + const params = { + request: { + contract_address: beastNftAddress, + entry_point_selector: GET_BEAST_SELECTOR, + calldata: toU256Calldata(tokenId), + }, + block_id: "latest", + }; + + const result = await rpcCall( + fetchImpl, + rpcUrl, + "starknet_call", + params, + timeoutMs + ); + + if (result.length < 7) { + throw new Error(`RPC get_beast returned ${result.length} values`); + } + + return { + tokenId, + beastId: parseFeltNumber(result[0], "beast_id"), + prefix: parseFeltNumber(result[1], "prefix"), + suffix: parseFeltNumber(result[2], "suffix"), + level: parseFeltNumber(result[3], "level"), + health: parseFeltNumber(result[4], "health"), + shiny: parseFeltNumber(result[5], "shiny"), + animated: parseFeltNumber(result[6], "animated"), + }; + }); + + return results; +} + +async function getBeastRanksViaRpc( + fetchImpl: typeof fetch, + rpcUrl: string, + beastNftAddress: string, + tokenIds: number[], + timeoutMs: number, + concurrency: number +): Promise> { + const ranks = new Map(); + if (tokenIds.length === 0) return ranks; + + const results = await mapWithConcurrency(tokenIds, concurrency, async (tokenId) => { + const params = { + request: { + contract_address: beastNftAddress, + entry_point_selector: GET_BEAST_RANK_SELECTOR, + calldata: toU256Calldata(tokenId), + }, + block_id: "latest", + }; + + const result = await rpcCall( + fetchImpl, + rpcUrl, + "starknet_call", + params, + timeoutMs + ); + + if (result.length === 0) { + throw new Error(`RPC get_beast_rank returned empty for ${tokenId}`); + } + + return [tokenId, parseFeltNumber(result[0], "rank")] as const; + }); + + for (const [tokenId, rank] of results) { + ranks.set(tokenId, rank); + } + + return ranks; +} + +async function mapWithConcurrency( + items: T[], + limit: number, + mapper: (item: T, index: number) => Promise +): Promise { + if (items.length === 0) return []; + + const results = new Array(items.length); + let nextIndex = 0; + const safeLimit = Math.max(1, limit); + + const worker = async () => { + while (true) { + const currentIndex = nextIndex++; + if (currentIndex >= items.length) return; + results[currentIndex] = await mapper(items[currentIndex], currentIndex); + } + }; + + const workers = Array.from( + { length: Math.min(safeLimit, items.length) }, + () => worker() + ); + await Promise.all(workers); + + return results; +} diff --git a/sdk/image-data.ts b/sdk/image-data.ts new file mode 100644 index 0000000..f33d572 --- /dev/null +++ b/sdk/image-data.ts @@ -0,0 +1,343 @@ +/** + * Beast image data URIs extracted from on-chain Cairo contracts. + * + * AUTO-GENERATED by scripts/extract-beast-images.mjs — DO NOT EDIT + * + * Contains inline base64 data URIs for all 75 beasts in 4 variants: + * - PNG regular, PNG shiny, GIF regular, GIF shiny + */ + +/** Beast ID (1-75) -> data:image/png;base64,... */ +export const BEAST_PNG_REGULAR: Record = { + 1: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAAAXNSR0IArs4c6QAAASFJREFUSIm1VW2uxCAIVE/dI+yt3/vBBu0wfLVZstlQhAFGxTF+IH+frc+HYVc1aj1Al0+wgKeuVjugcGkfXhGJX1r+KT2K0oqkp6KzW1cjst5BXdrlQ6TV35ZDsYJ9BiEUaXAKUTlL01rn9dVVGfcjD7hwGyBkqVX9VKekx23ZkHVmO3PQYDqOaEO6OsHppMV+gsiq/ivUaVlevaM8MhURsoosMckvQN8tM7vNsR28isAyzOmie+CluWE9uKUSRW9P6T0ABnawuRy26sa4tuxXHtG8A0rxqcRSpYiia9ZXCbwNuKH4OUp78Gb6NyhyIUKK8g7s+QH0OH2VIjoqFD0aiCk0iXGqpo327kEXfaQUwQa4I/Nyh1iDIvumDsYhtPIPgYPBCOPyCoAAAAAASUVORK5CYII=", + 2: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAhCAYAAAC4JqlRAAABfWlDQ1BzUkdCAAAokX2RPUjDQBzFX1tLRSoKZhBxyFCdWhAVcdQqFKFCqBVadTC59AuaGJIUF0fBteDgx2LVwcVZVwdXQRD8AHF1cVJ0kRL/lxRaxHhw3I939x5374Bgo8o0q2sM0HTbzKSSYi6/IkZeEUE/BIQRl5llzEpSGr7j6x4Bvt4leJb/uT9Hr1qwGBAQiWeYYdrE68RTm7bBeZ9YYGVZJT4njpt0QeJHrisev3EuuRzkmYKZzcwRC8RiqYOVDmZlUyOeJI6pmk75wZzHKuctzlq1xlr35C+MFvTlJa7THEYKC1iEBBEKaqigChsJWnVSLGRoP+njH3L9ErkUclXAyDGPDWiQXT/4H/zu1ipOjHtJ0SQQfnGcjxEgsgs0647zfew4zRMg9Axc6W3/RgOY/iS93tZiR0DfNnBx3daUPeByBxh8MmRTdqUQzWCxCLyf0TflgYFboGfV6621j9MHIEtdpW+Ag0NgtETZaz7v7u7s7d8zrf5+AFeScpwisFufAAABh0lEQVRYhc1XUa7EIAjEpofuEby1+/HWDYVhQL4eSbONIkxxGF0RkXXyrNmbi55LGrZmbaxiLQA6aTfxtiF/pThODIM9PRD/hwO7pJWyap+qfxR7renRR1/TqQCK/RvTk/vd/kYBdaCKr/VbU9bNyjYeXzJNNEQ65o/sx4E1vbMeG48HZPd0++s1CJAeczqAgCA7JSECAwFYIBYQA2f9dIzIbpSEgarMZ7FsTsjgrC13B5y0cODj2+lEEzq9r9/Hd+BVHltuPZaV91XaQtxb74m27sFSjbHnnBAxojnyGNJVWI+stKdi9pZJOFtrfaAORF9glXEbU74spruQWJJE3DgZR2R85bRP1t9MN5heIH94GmbqeNI1KNZeuybogiggOvXsPAOB4ogoDjAdRwRiAI98JFDCEHGjz9m94LIT7JyvMPrkljSe730AfXUlOapEdl7YuQsJS7Yo89FXs+wyQ4UILWJVqGyRNdeGUcKo5Jn8sqNZJPlvmJ2MUeBql4yHAOgmj9ZH4D7THTIdDRz0OAAAAABJRU5ErkJggg==", + 3: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAlQTFRFAAAAAAAA/4AABnhFZgAAAAN0Uk5TAP//RFDWIQAAAJpJREFUOI3Nk0kSwCAIBIH/PzolYRkWbznEAyXY4kACcVvSfIIjWAkDkJfFLpzNHZCZgeEBf6UDgYFIdCWMZzwZQDcAHiWXe4xG1JoxDaZXq1LEXB5AqW8FXPEdgGoK8GoDNqU4IPUzZog4UoBAjgQGtA4alMBQBmz9YdpmZpDo5QVY5FA9n86HQJsH+SXA2F/ZysTphWCZrG09N3IEyUneHIcAAAAASUVORK5CYII=", + 4: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAhCAYAAAC4JqlRAAABhGlDQ1BJQ0MgcHJvZmlsZQAAKJF9kT1Iw0AcxV9bS0UqCmYQcchQnVoQFXHUKhShQqgVWnUwufQLmhiSFBdHwbXg4Mdi1cHFWVcHV0EQ/ABxdXFSdJES/5cUWsR4cNyPd/ced++AYKPKNKtrDNB028ykkmIuvyJGXhFBPwSEEZeZZcxKUhq+4+seAb7eJXiW/7k/R69asBgQEIlnmGHaxOvEU5u2wXmfWGBlWSU+J46bdEHiR64rHr9xLrkc5JmCmc3MEQvEYqmDlQ5mZVMjniSOqZpO+cGcxyrnLc5atcZa9+QvjBb05SWu0xxGCgtYhAQRCmqooAobCVp1UixkaD/p4x9y/RK5FHJVwMgxjw1okF0/+B/87tYqTox7SdEkEH5xnI8RILILNOuO833sOM0TIPQMXOlt/0YDmP4kvd7WYkdA3zZwcd3WlD3gcgcYfDJkU3alEM1gsQi8n9E35YGBW6Bn1euttY/TByBLXaVvgINDYLRE2Ws+7+7u7O3fM63+fgBXknKcyUKElgAAAQ9JREFUWIXFV0EOwyAMC9Me3Sf01+wwsTGrJHaCukiorVqIsZ2gNjPr9sd4Zif283vfjhqIro5++s/KeNSwv6Mdv4wokQYwEmYTlwEM3av6mxX1x3cJP+jJoyQKCFmCftZMhyEDGMl3gkjRH8khyKCbj/ECC6DkgR0ypPoAgqjGNg+wZWqqBEjzTgYoAJiE9QDrj21VkJGAAuAlv8UDH6outL+lCiLKo3feoBnwKsH7Lgq6CiKqZzBKeYYAlB2hL5i5IQDFZLhzZm7pLIi+YSLViplgZZAYyLTgiCkXwFho3o1CPfPv4AKYk0WLrfoEriMBwMVHP0CKkSmlDM2INjz/cMzXVSsW27J0dKbHCsQLNgcL7AwMt80AAAAASUVORK5CYII=", + 5: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAAAXNSR0IArs4c6QAAARJJREFUSIm1VkkShDAITKh5dJ7gr51DLIwsDWQcyouEppEl2Jsv5/F47QPY1kV4n5r5vOxdOH2HQ3vZ5ugewW2hUo9PhZAJm8gJ1vGuTsNPIbZbYX1cyKnkV1NS6coY6WprpZYP9rjGbqa7MBxmO/6ambXIXNJ8aBkO2aai2s1vymQohA59vK52isAz5ZnwJNupyZLq+seXR6lhyvfdX70TttZN1YqbhwAGt2yBoBRRdXG6d1EpfH3EWJvATH2Llo/W99EIh4bdhcDzaH1dLLfWSTQbg60pWElcoklhp2YTG/Gt4xNORjKaafmYAzMDHjiUa597MNDvumw7grve/DMrz3meA9Vve60zRzwcr3B4S/QLQlDU0fk/7DIAAAAASUVORK5CYII=", + 6: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAATRJREFUWIW1V1sOwkAIROPFvJPH6J16NP2RBCkzwLJOQuw+Wl4Du4qIvL0ccl7mkHT2RnIXgENOtNTak+H2taSk4CXPnzU7nqAcVp2364ecl/3RHBGuBCnzSnQcvcfkJwU+rDqOcq3zO9IAQ+Y99GurXjup5zxLz6IReX2zjzKjKvKIcmJzjp53leSlEakSSzJLxH/0AhjaiHiV504aYCuOvNXfrDzt/lEEsmc77nqeRgDltjtfAbWw4tXkSKYcUFTKchVhH/AKfBlGJTnBOKyTFMAI+DLb5W2EZS+Hp2CdhBF2EFAkOAs6StmlRDtmBloFzIhMuW/JjEMjDlS5QXhSN4BdSJnBCVnrjGVHdPWo9t9sc4BdSLLOidCq26nHgfSbB7qKr9wN6H/DDCi0nbY9MmAHPiTeytgXlEBhAAAAAElFTkSuQmCC", + 7: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAVdJREFUWIWtVsERwzAII7ku1p06RnbKaOmn9FwsgXDKna+xDbLAYGpmdqnjsPPWPhq7iXLYOc19ZHqKSJ67d/EXrTUj0Q99RoLN2ZiugIVWDS+zY5hTBKJXzEv1O4sSjMAoL3u2ooD2EEaU8u7YfUYPV3AeiLF7UrFXvDOzEk/K/k5pdey2jxL1So2G6jU6q2SserSIgx+R7GHpkizw8ixXALMDhCrJS2rlfc9swDnrtV1dlYK7OYsorDIOO2lFxL2sulwoAUTGQbrzTG5FAB18KwKVQRb+SifDlh6YzruQJXLU3yvWaM+9Gf9kxFbsTY21aF+fuuEI1n3/0UEV3peA0pDGfbQWbXwtEpkIZHUdATpJGO2RLSxDFLJ/r41SZm+nHzT7wG8zygArvY7u1IxUttG7UUdt3RGLlmFVCSjZ0F6VwFIZsjUkTA+VrpnYDUdBRJWmw+QNAAMBDX21h8UAAAAASUVORK5CYII=", + 8: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAxQTFRFAAAAAAAAAP8AjAC/THy84wAAAAR0Uk5TAP///7MtQIgAAACnSURBVDiNjZILEoAgCERx9v53rpTPAmYxjTrygAWT8WHyLDgDwPOpAWjAnYD9hSglMKEGhM1yHYC70SQzsNSWHAFgpdd1mJjoQoN9V7Fi6Lyf7Iq2QgaoWxGSIq4+xgXuR/wqHVQWA4NGEFgHXL1BYjEcNehQNKR8BHgLL2+RYm3GCQC7s8nuEg3ICg9/VO1xUyI9SgWQtpPIDtBD74HPDO8S/g7qYBdzqwU9vZyI5AAAAABJRU5ErkJggg==", + 9: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAxQTFRFAAAAAAAAAP8AjAC/THy84wAAAAR0Uk5TAP///7MtQIgAAADNSURBVDiNhZNZEsMwCENhdP87t2OQWJymzk8cNM9CJuZ/lvEFwKsA53kT4CDgvnQliNLFMR6fFp4EcTxOCZcX40fQCLaHLJVXegqUDaQ+p93v3ryQcFS39NwISEW2ktpJiJZpGkEggn0GQZ2bKtUu5AYjqKC34FZQGFlmIMi7EBFyGS8UjOVSLAHB9fCIpWgMDox6gnLQ8CxCyzr7tPKoC2seuoAhMYA2MGVsKCBBjcODwsY8SVHjZ+2fk1Uy4rrbIDcjAtvc3st+VnJ9AOFfBvtWFc+xAAAAAElFTkSuQmCC", + 10: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAABVQTFRFAAAAAAAAAP8A/4gAjAC/AAD/////XlWhuwAAAAd0Uk5TAP///////6V/pvsAAADISURBVDiNjVIBDsQgCMOk/3/z7QRKu7lkLjOipZZKrGvg+h6jNqMChaHjAvwX2Js2ITGxHJHhnOcVQNM3aENEQ5/VWCJ6AJ0iixtg0rRoAixNguCW+MHYRRrDFw1ZkALG6jUlG8A04MAwAODM0FaDKm4MXssOYhFrIqHP3Yh6LnlKqNVyuzz6MFRe1ia90xqeDDUJwBj6Y1eTFBKTgT26S8j+7GuCCbU5FUDa3vxz54OcB6sTgLLvlYEFleN4BwDzqwZJ8Ibeqx90awciQiXInQAAAABJRU5ErkJggg==", + 11: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAAAXNSR0IArs4c6QAAAQtJREFUSImtVkkSwzAIM3lJp2/o/79GD+l4AYRR4xwyMQbJFkvbGvFoa8rY/3kQwXl0dctHcCE64ljsgtH9Vn5MmQLD8CrWVqi9XFsPdW/Dt0GgMoacf/aLwaLQ70wEBPv8rDokZUJurLso1Zs05MWTJ1ABfYkgbDrEl2lQHzUGvS/pAn06cHICNGqMkSBGifKCaF0Wj5KMYlol02g9vo/GvO9oiebISsnS0JUArvDN9SuDCEHHgRScB51B2MMdID6DcrLVifS+X5/7QyJXWS0ViQ3TgL1AsL+4rJbwr5F3G52MamO+YmXsWL5rPaDhF1zp3n+2jLFo1t6jGzX6TiwWJKwQ8zuM3gmOfgHWEqIKfpZ+TwAAAABJRU5ErkJggg==", + 12: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgAQMAAABJtOi3AAAABlBMVEUAAAAAAP+IZVZCAAAAm0lEQVR42gXBoQrCQACA4f82PGGWBQXD0AkGHWuiLG4+gWHNMnyCewFlIGZf4YKC0UeYNqNt8art4oQJfh8AuMIqxFM3iP2khUfWQpk0COkrpBdB4PchQkLIApbTWcngdQVvl1V4J7eEoTaI3zul+7mnjLeNJj7WIbk8GzajdcH826twLiuLcztYHF0bxMZaoEgAFYCrYuiYHIA/ZYspAbnAyoMAAAAASUVORK5CYII=", + 13: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAxQTFRFAAAAAAAAAP8AAAD/0o8flwAAAAR0Uk5TAP///7MtQIgAAADeSURBVDiNhVMBDsQwCNLw/z/frYpgl9w12boNqwgu8s8KPaIunIcr4PvxgXD2Z3tlOHA2fpcAkzSmCJwAHUAzaDJ1D5JCXqGdMXiwKKazBEiS0KZZW3Suk9NI4qxUCYAkMGhnULxqUzKWqNq2utvuggaQHqFKEcK7w2mmIqLta/0oIuZc2BsbluKQDsRHDmYN82eIDVfjoBJmG+126Wc2aHmQovFfc6mRWyOhuaTdV7djPnVIOyzCq004qJq022h7JzCSS5/REfyzZup6tmaS2QWc4vr54nofGZYOv9YHt/cGjd5fhNsAAAAASUVORK5CYII=", + 14: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAhCAYAAAC4JqlRAAABfWlDQ1BzUkdCAAAokX2RPUjDQBzFX1tLRSoKZhBxyFCdWhAVcdQqFKFCqBVadTC59AuaGJIUF0fBteDgx2LVwcVZVwdXQRD8AHF1cVJ0kRL/lxRaxHhw3I939x5374Bgo8o0q2sM0HTbzKSSYi6/IkZeEUE/BIQRl5llzEpSGr7j6x4Bvt4leJb/uT9Hr1qwGBAQiWeYYdrE68RTm7bBeZ9YYGVZJT4njpt0QeJHrisev3EuuRzkmYKZzcwRC8RiqYOVDmZlUyOeJI6pmk75wZzHKuctzlq1xlr35C+MFvTlJa7THEYKC1iEBBEKaqigChsJWnVSLGRoP+njH3L9ErkUclXAyDGPDWiQXT/4H/zu1ipOjHtJ0SQQfnGcjxEgsgs0647zfew4zRMg9Axc6W3/RgOY/iS93tZiR0DfNnBx3daUPeByBxh8MmRTdqUQzWCxCLyf0TflgYFboGfV6621j9MHIEtdpW+Ag0NgtETZaz7v7u7s7d8zrf5+AFeScpwisFufAAABKElEQVRYhcVXW44DMQgj1d7/yukXErJ42Emq9U/zYIIHJoYuM9v2j/jMJio/zX4gsM1sJWsb5hFLIiFGQB3PIOiefCIYtRpEBPCwFdZWsc9DS1hrqjl2EBF46xDxd+fYx11kfC8nLEYgy1h1VSdiRwRYINE6XSSB+EZ++IY52s3OM6oDATdfsJe98S7sZQKZ885ZXJ9B1IJsPNnyaAiwB1Yh5p5vCGSHVhnLSFynIB7qmj8JTrS/jkDmAHEvxw+E6I7EAwKo9dW1lAgwIhIdnEdBkGKsgr72sxRkOo+34b6jF76BrA9g0vOEQKyAVvw+l2J0jmNHl5r5+xCkuOuEp2ePCCCqyig21hyBqhBl88r5k36gw70ICQQyPTCY961XBfJ/AVsJdRJfR89eOWNH3K0AAAAASUVORK5CYII=", + 15: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAZQTFRFAAAAAAD/iGVWQgAAAK1JREFUOI2VU0sWhDAII/e/tG+0CQGpji60hRjCL+LDAz0b93yW7fH6h+EN8BgTewCkGQ1z3pXLdbwBEChwS/702T8/H0L14TsZopF14zonLzU1AJViBWkA9BAuwW4CoHUUVjlUsVbYFLnpJpXO3XHSewBxcCLHqfRCTX5XPwVovakzTq+liZCcJY7qmYF5LyNqJQGtjz7gbOb2GV/0ShZOrmyK9CWGLTUiE1imA6McAQ1K/xEJAAAAAElFTkSuQmCC", + 16: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAZQTFRFAAAAAP8ANkNEvQAAAKhJREFUOI2VklESxCAIQ3n3v3RnqyABnM7qRytGCAlm/y6Yozv++6zfCG3EG/fQutRUbJR8KoK8O5Vcc9PomNhx6GWC3gTYAewKEPo0olDkqNeRnKmLUx6zQSr3gCRmAbjCxIF6Hw85GVMBU4nVTxJ/XGrxBtVQOssELReHXOD4A+mlUkD9Hrz099wAttLPXpSRHDPUvNPcSn9fgDZxR9uZZPTHPK639QDYDQDku/dd4QAAAABJRU5ErkJggg==", + 17: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAlQTFRFAAAAAAAAAP8AEEcUsgAAAAN0Uk5TAP//RFDWIQAAAMZJREFUOI2VU0ESxCAMUv7/6N1JCGLipU6r04oQUNd+NMSTbY1J/CejawCcxdHqczBspMJg6CJWAzogi3gyAMcCMeueZ3WmcgOCnEups9wkFeoNqDNkPPE7aYzBE9AY3QTkWhkZAL6oH81FlSIjL4Bli5FD5SVbPckKgy6REj3g+K4qVq0TQEcGrMEqLm/MC8mgLdZIvdRZafukqwPLwRguL0J8Byil7RKeogWNCbi1yHBtXw+ee6FDaBeCifR7Aa92nIdX+wEw9wT/I1DR0wAAAABJRU5ErkJggg==", + 18: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAlQTFRFAAAAAAAAAP8AEEcUsgAAAAN0Uk5TAP//RFDWIQAAAMtJREFUOI2FUgkOwzAIA///0dNK8BGtWiK1aSHGNlT/WcUT+j7CEvDdOIeJAIGAfQDz2t8q0QMyEMqqiAqJiNVXhioCU2IvLraTxSBgqzPluW8qFvCwW6q3TPgmnfLwgskmOSkroWwvIXbyG5FA9rLFjYJuqV30YXXBNLBvxc6sGpIc18ohvaPrdx15Nk8PCPtR3Vf4wKxtMTDRbuQ8QJ3uAC2/Y8NGZdss0QorwkkfNLGpjm/CZ4lQiRTOgXlbRY0vSS7zZ079+BfrA1ViBPF/yQ1oAAAAAElFTkSuQmCC", + 19: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAlQTFRFAAAAAAAAAP8AEEcUsgAAAAN0Uk5TAP//RFDWIQAAAKhJREFUOI2NklEOwzAIQ5N3/0NvWlOwgWrNR2uBYwJm7T9nBWLDQV/YCb8gF9rCSIUdyaEEE4EkkLcaXMo2AlaCjOLUooBB7QKJKQ4FTiqGRFG4wwI6gVuBgaAp1A3tgvLzElnf/Xhp1lsCV/s8EE4Os9RWTiY5rtzOOYyDKm3SCZlRieUC+SmTdIN08QsBE0tCuKMPwAmYUTlQXzl5ia2cbn3d++JmPx+LjwSp65nJ7wAAAABJRU5ErkJggg==", + 20: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAABlBMVEUAAAAA/wA2Q0S9AAAAj0lEQVR42qWQAQqAMAwDvf9/WpBj0WagYJC1mixpPT4Cj/V4BCCHhZ0LIrengdCiDartiKuG700AaoMy/uHgngoaYH3h0xWN2EmYM7BbYbw0jyjF+wfG78MpOqBDIuB+gx56RhAFKxSxRuIpj2VMQ9TUUhE8IoZgrgEhMuCysJUQpKYNsqUB9euNC3D5DzgB3rAA//5ZKD0AAAAASUVORK5CYII=", + 21: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAxQTFRFAAAAAAAAAP8A/////zPWCAAAAAR0Uk5TAP///7MtQIgAAACxSURBVDiNlZNbDsMwCARBe/87N20wDNhVlPxYggmwPMwfPpsGPQEXoQ2QxKcRFlGFpxG2sob1JqQdSO6byosooBEVA0DmuGMcAFSRAVNFERSiCQQBPdGoRqilMd8IlcwEoDsKmICje70OTlOUeQLSquhUqmASVaifwZp3zQnlGEXECORTZg1cFDBbXUM4rRz/P65cJh3+BbSl2dYeXeaqFODNPW6LnST1F5inebjNt8AHUyUFa2pdeGkAAAAASUVORK5CYII=", + 22: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAMNJREFUWIXtVssOwyAMc6r9/y+np2g0BZaYFaQKn/q24zoBAaBYiGMl+RawBWwBAPBhX1S9jg8RmSdAVW+EtWsRvOcXsBAsXgtSDkSrzmQh7UAvbEwQ6S4AvpWO5IES4KscEUKFsEU0ZQ6U5CJyIX3cgTJkrVGcDWLYAftwr8rIM7SAGpEhSzoswAgtA+xCBBAZ8CL8sZ1HkXKg1v+tmfCIgB7J9A3Jv0A74LuAdWD5jogW4NtwioBf/c6IGVqMMvdaOAHZ92xVz90wqgAAAABJRU5ErkJggg==", + 23: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAxQTFRFAAAAAAAAAP8A/////zPWCAAAAAR0Uk5TAP///7MtQIgAAADBSURBVDiNhZMLDoMwDENTvfvfeWP5OS2wIqBSXxPXBlt/huWEV4ACrhn3AE1yX8EfeyvzdYj7kBMVUgFHjWqRh9lVNkAT2sRknWyDECZ8WbG3yJ2l46lFA2cFpgwpZ1KdeRQ9ZnShPF9sQIXBShIFiN2LNd8dVksgex0iM0uPgwPoXZm9+ICuO/IbDnjN6Xh8FwQgDWao33n5sGdBXPtn365GIFaalhBhJcw0c3V4Z2mN1Kclyr+pg8z1CVC1r8A1Pnr9BbUUk/lCAAAAAElFTkSuQmCC", + 24: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAA9QTFRFAAAAAAAAAP8A////AAD/tOJkVwAAAAV0Uk5TAP////8c0CZSAAAAkElEQVQ4ja2SCwrAIAxDK7n/nYdiP7FVGZsgin3EpCrtMuRPAMAR6OWCMGCUT4AyHwB0l/kWSlG5oCvWoEgAC2BVaMj1pVERAXsYAcbUSGxSA1orTEmC/GwFyK44rx5AcVVhvhVSGPNAzjIwZYovEwFynwHQkgHPUAPwMjYAls1bwI93HhyoFOJfQtnq/bgCDz8WBQVaYwgSAAAAAElFTkSuQmCC", + 25: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAARBJREFUWIXVVtsOhTAIA3P+/5d3njQMYS1ostgXlwWhK5dNRWTIRhw7gz8iMMY7wn1TgfP0b6jwPQX8qZ+q8D0FthLI5H6SBpoACtIlobJ5FP+QQftkqpydFBQYY4iqXt9srwKogA3uA4rItO4AKtAJVFEiVMAGqjizaWH/vymAcpmpkP2D/E1zoFtIK6DU3QZRZIwkjaRf+QsJWMNsHZHw64qfiYB1xqRBVXGBEf4Oa+xrwA8cBD8jMr8W6SDKBg/bBWxBTwQ82yinq3bzfhgity5AklnHmSr+ECtQo5i9bOzYZkHdhpUBVSXReg+sCtFf0wjUk8y3pt3LCpZF+VF6njKq8s47of0oXVW57RCEP+Hu8Rtg2L0sAAAAAElFTkSuQmCC", + 26: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAlQTFRFAAAAAAAA/4AABnhFZgAAAAN0Uk5TAP//RFDWIQAAAMxJREFUOI2FUlEWwzAIUu5/6C0JKGZ9a37SZwmgGPly4qGGCcADAvgP+NbQgIW3IxF9xyWZp4z6jhwUen5UViGm7VU6gCQ4VB8UaK89B9wUKZMJGI1eogHVE5pCRmtQJLZGdM1JOni3SUCp191Gwpo6T8kgyki4RpoJcA4T4B1tE79hXbN0gHkZDIXAoEFn0dHcM+E+KCdzyMEyC/0vD04XLWBuoQgtzWFSee4ubD2cQoFHi8PbqInfEm6UJm0B2d7hYvJRknOOtg8v5wOFywUbW3VO1AAAAABJRU5ErkJggg==", + 27: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAxQTFRFAAAAAP8A/4gAAAAAdvBh7wAAALBJREFUOI2tklsOBSEIQ8nZ/6JvMkopqH/XmcxDSqHFiD8u1hN4A3bwieDE3ooIe4FQ7++mUUN+UiQGX6+lgiJRS4E3AU79hYGpDxXb5syus2iZN12sEvsKpheYOinyemJOhUpW/RJ+m42cTNZTRphHzSmbRPlJT8WhnPEmmGXXyPUMN+IC0G9OzU5Is50O742OczEAmgc+kk6EmvV59dNJyHH3DgVqI3nC9+d67c/1A9PdAgWNYwqJAAAAAElFTkSuQmCC", + 28: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAABVQTFRFAAAAAAAAAP8A/4gAjAC/AAD/////XlWhuwAAAAd0Uk5TAP///////6V/pvsAAADESURBVDiNjVIBEsMgCJPL//88a0kI1q3zej2FACEw4uWMPwD47sUNgL27fwHmXxBs7vlliQWBI2iZGW4rEbBcl2tlIPryo+BgBo8Hr7QP3TIKCaJVHKKzjRMH0+PIQV3o4RwyUBRMatchz1MH5SdAfuNgXZbqTQdX0nWINszqIu2DgdIj+2cqrdwyq81aom0ni8MRsHFoAITKog2MJNl6vzWSlK5WZi+hIdXCJACWWOCUo5XQ1NBLIDhBccjJchY/zyvgA0eqBfsWjmxzAAAAAElFTkSuQmCC", + 29: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAlQTFRFAAAAAAAA/4AABnhFZgAAAAN0Uk5TAP//RFDWIQAAAN9JREFUOI2FUwESwzAIUv7/6F0iIOtuW3ttUkVUYqv/XPX4xm8APhGVzvMCvgCg5YEgAGPGWYEMqbHrOX6XAQJuxDUrHK2wA2AQ/YvgtjDREIBkNpa2KsMpia8GkgEuj6lLjaFNIUnvXfCeFMtxYSqSWd2khKMObo0cijop7GcjyqCNAOxkGHQuV0n5VfUe5jCXjodiB8WYar3RyIo9gJQvGJpS64PXgmdgNh39TkEl1UFIZBgHRv6Ogdy6Stk7ETHbBZshZGqugUEciXXcoY2koQKlzqAcnu3iTaKPn7tf1nUFaqrjsNoAAAAASUVORK5CYII=", + 30: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAlQTFRFAAAAAAAA/4AABnhFZgAAAAN0Uk5TAP//RFDWIQAAANhJREFUOI1lk4ESwyAIQ0P+/6N3KiShc7eeQgoPpKhZZMXSAdd1Vu01FhzxnzcksJ9abeFJdAT3PKp+cBLfCKLgUtwftBUIS0o25OMQKTfkSk9nKJXZ9gcaFS9BvGoUWhDNqU8IeJtVeIco7JNdZTqfg70S2QKmK3BuaVBHMgZ1f9PqdJrpQmYbk4P9InzZ6u46I+3f67qQXBZ7erSGYc9AVg4Ozf5TE8Vow2qFBEw6p2gz4Y/Go15UhhZwB48AT9BzwixhPgQIeIGYCNOQaHYUxGHIaUxk8geWOAU3PiV9ywAAAABJRU5ErkJggg==", + 31: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAxQTFRFAAAAAAAAAP8AjAC/THy84wAAAAR0Uk5TAP///7MtQIgAAADTSURBVDiNhZMLDsMgDEMT+f53bktwbIK0MamM6uVjh0b+WdH/8P5qT0BHAesFavsQzAwM3LG4ShRSoUowAEHr2QAYaUjtBawj4FnYBD5gZRw62UUBkn46klUCVM7KTaIyWG0wrskBqD8942yf4lQrcrSQo+WwERQFGiOr+RJtATXS6oS13WLqEDowxa4Pyjy1uQUrKNwid4N1TqCnJVNDBekG2oU9rLZInlqf4dFyW3oj+wZiILLaxiQGBrQEeCWz+hy4X+nUtc97QbPAD+L+ssZ6AJpoBiX1LtEcAAAAAElFTkSuQmCC", + 32: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAUFJREFUWIXFVlsSgyAMXDu9mHfyGN6Jo9mPFpvGPDao08wwgCZk2UDCBGDDH+U5YrSi7eMF830AVrQfB5bj/u0MkC1qK9re+lz2Uidby2mxcw/QVSAeGT2SduBNtUX3LSGQO/V2qL8NsFCjTNOeAcpaGgLgGwYdjqukdAv0P88mW1c0nm4LzNkwhIlIn+yzWc+S0hm4QygAmWQAVzRXZ6gYaccL5hSE1JGhnPA5iaNOvIWtQiYLWB9TIehOupHs2WoYsUTlAeBYCbMCFKXpPi4xAByzYrRzbeexQOf+UV2LKTG/xnlk470fwIagUyj7ESmH4Mr679mVGWCSjtRnpHyF9JytiNZZoAA4hikYC7SxRj2BZE5YVmGdAZ3DtfRXcRTj6k2hds+EZISZ8nsgY6gqNABdCSOpgqSvlqXLhCha6wW5/qpme8KK6AAAAABJRU5ErkJggg==", + 33: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAxQTFRFAAAAAAAAAP8AjAC/THy84wAAAAR0Uk5TAP///7MtQIgAAADXSURBVDiNhVMJDsMwCAP5/3/eFvDRVlOzrlLBss2R6pdT3z/m/AXg/NqIC3wZJhp5IUqBjeEQ/t5YAI4ISHSeDVJiAutiCIYjJJpWbFYS6Z2ZcFmRFk/WUbfKIfE2IIpiIQ+JlO9WjdcqhFsaAuKL8tsQM9DeItTbZBjzO9SdXjBsFtKDnHFYTgcdBgBBWuYgF9U38gFB7+pIeAu8gwa0YSIIBrjFsBBnAZOG02HSVseg3egBxPS5lBwJtlFyFMWwjrIB77sswhcnWn3dct0LFni/xtUv5wPa5watFtZaaAAAAABJRU5ErkJggg==", + 34: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAWxJREFUWIWtV9mtAyEMHFZpLD2lDHqiNPKR8GS844u8kVZBYOzBF6QBmCiiY9zmXnhW1QAArqWMKbWMS2NrXNkv0QDMpVQuWifyDGX2aJnWMeYynjmNJFrdZ2F2jIlPLmxj78vKRfIP74Rsfp2EnUiHUo8ZbgQ84SxYklpoX9dQYR1fL9ZaTleLhcfa7Lndk5FkpVzWi64HPAOaqJapYHYMN6vluiUbrVvflXGXXme54q17uDxFFnT7/qVqrljE7v+/lutGwFOWNVTJ/j8COquzYdCGT/eHrZglYNQzqrmxlRAOSpDpKJTj3ZBlgBmJfiMSbbHIus56vLB5CUvnrQyjns+uWOsCSucAsMcRSfexh8zax0LGPrMRvfB0vcFcnrktNdKdkBE8dblJwKtxRsQyeHwZRZCKs/8novZcIsDIeI/TDEICLCwdY/NA9h3IvEVfxRlSbHyC4xBEOaDLM90Js/ivR8kxgSosT70BoEuLXJFOBDgAAAAASUVORK5CYII=", + 35: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAxQTFRFAAAAAP8AjAC/AAAAP8G7HwAAAKVJREFUOI2Nk1sOgDAIBJu5/6FNlAK72Gh/tDCwPHSt34c/RIcAdQaAWizcgE48AZgOHu8IaxIdQZOROlEAOwNFh8p9uhTks8pQAarJqR+ZDx32q8/2iO+O1G+7ec1WQlKPDyQhXhJkp7LtZ2pk6rhr17mAWxG00B0cs07DaDVXuiaAWmECiN+BfamvQoH095wFtFHSbbRwjm86j+rShtBb/f6J9Vx4BQHDcvQx1gAAAABJRU5ErkJggg==", + 36: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAZQTFRFAAAAAAD/iGVWQgAAALZJREFUOI2Nk9sOgDAIQzn//9MmMigwTNzDLkza0qHZ78HnIWLwTpztBuFxWAH8pq03gGfmZgMIDTt63OWhVYWL01RpHNfZY6q1kroIk2hSD9wQKZKTnC7lISBUvIxCbBKNNKCydJHqTYqTECuUiR+FQpetopRYXLidyLX0w/a8NJHLqyPzl44Lm6oPI1mO14LLtclN7i/mA9A4wi4Z0Twxq9Qzku0yaemlyKcmvLbc9a8soa/xADySARv8YLy2AAAAAElFTkSuQmCC", + 37: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAxQTFRFAAAAAAAAAP8AAAD/0o8flwAAAAR0Uk5TAP///7MtQIgAAAC8SURBVDiNnZILDsMgDEMT+f533gSx49DPpLVSK/DDJIbIH088KoADqKHJNRVz2HLWVFD/fn11rhcb4GqYWRELWP/Fb19utokw/VILAdKlGgSwiyrMHnpE69rCCG4BJNpKLXoXULhqsqNWcZ45PWOzUEwj7ulgy+w4Vw0+raXDYepW7c2FUb14AOgHazO9CBztRt4Rdl4CjlPWsIHz2h7AtMAd0NPwQLtNBTp0z4EXZuhnUJjndQVeuvgb+AA3cQYBxBXi6QAAAABJRU5ErkJggg==", + 38: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAAAXNSR0IArs4c6QAAAMhJREFUSInNVlsOgDAI24z3vzL+Gh6lwBLlwyzbbAsIuNZhk9dC0MUZ+qqii1lMrk3ROwRpQPvhtrpcrCaBDU4UroiAIrZYPDoicI+VBwBC77sysQTK/Su7uuPTzRDcEBpzswbqqF8777dSFKaSk+IAHOQXGR7ZHKisUplkWMkQl/qdqF2G41jP+ZKjTNCYoqSjOgclq7XrSHtpM6eUOFx44FD6ABx4si09ahWkH3ZWO44yvw6uOiBuZGD6l8qWpSHpT1o14L+1B1zYk3wE/fgqAAAAAElFTkSuQmCC", + 39: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAxQTFRFAAAAAP8AAAD/AAAAzac3gQAAAKxJREFUOI2VUwEOxDAIIvz/0ZdUhzjtXa5Z0rUgKnPAP4sAebYdZcDn5RYf8EUjI68CSrLi54oJxN5Y5LlUCt1Y/NMf1a1pRGqWDzq2+lOjrKDj0q1sxXB+krpEZaiufhBWBXgXuClQpiwEpHkU7AR4PEabZUUvCK8qH8aYClVZjJUQddqh+5KfUBvexsnMStUmhobouw8Jf7bJVooNYo1pO1ifcx6u+LcfdKwPg6QCS8mAL9AAAAAASUVORK5CYII=", + 40: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAVRJREFUWIW9V1EWwyAI073e/8ruZ04EAmG142edJRKCou2ttdEok26dgxB21dxnYJaMl9vuTxIYH+CcsKt3zJhPqLujMLhWoCsf/YwDT3yigM58Af1gmixSYpEKCMjJs0WHhES45QsIRDLKcZ1ltqHsHK8E8QF5hKRFmQ7xbMeBAln9UDC9WLVa2t8QkEHvNpusNF2/jbaZfh8FYogvv2sfmL8REW1ehmj7Ssz3aQx/70rHKDNv73v19vFgF7AKoOBy9bcWqQFKkEmoiXoEGXxrF58dY1kprKkSeEAuk92fxzlrAB0+FRI8rjhztTtKXGkXIJs9AvX4uhUJeERY831/JCCJVMySuElgkoiU0Kfj3qQOEIgCo8W3SBev5ZXgXHkeVMAz2yUPEZDrIMrenjMPKBDdgOwh9+cSSDtaguzLSAbd1TlAQF+3M+vm371mDj/bOHsDJrB6SwMuoZ0AAAAASUVORK5CYII=", + 41: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAlQTFRFAAAAAAAAAP8AEEcUsgAAAAN0Uk5TAP//RFDWIQAAAMZJREFUOI2Fk4kOwyAMQ4P//6PXksMOZBtCKoInxzlq68+y4Q57F4DfxKMAXw3AyhuGECw/CaiAHxBxEApQgXyMMKaaflCLKA8qUAS6yRJIoExShM8YgLL2FXgjoLgJ2C8hISbf2JGDOgjO/P2IkFnCgdbQXgfcQPmIPQCRAW4FcqBLy/40QLSaAjgNZdWYNgpiVx8gMz8MIIthvXflDYmYXLQsafICFku/ZxLaGi2IK00AR9iH9iTA3yo8IAeWZaLe9He39QFNtQUDkNPYpgAAAABJRU5ErkJggg==", + 42: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAlQTFRFAAAAAAAAAP8AEEcUsgAAAAN0Uk5TAP//RFDWIQAAALRJREFUOI3NUksWhDAIg9z/0GP5hlqdrS7UvnwIBdE/j3yCAPvihbAwvBAWissBZ5IYHuCJYSUW7Iw7xUJ6iXPYVaIdjgTXln6v4l2UENHUVoLQ+GuOh4wqpCyGDC17h4s8oPUWOk19MKQSYBP7EMkhg4IPETJuGjnYFCEcQgjuFjm8XDmT5u6wRxOUytOWSQUE9UZbVBnIddyWjCvAmFM61LQ3PB36buYiQCmDUnuN6yQ8PD90jgS9NRkeyAAAAABJRU5ErkJggg==", + 43: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAZQTFRFAAAAAP8ANkNEvQAAAKJJREFUOI2FkwkSwCAIA7v//3SnWjRBVHo5EMLZ57kLXOztFvgnW0SYdghUZwjCPejbBwfo8yuZfIjL5BAKsxXJK1nUasUVzRJdKtPJUmDEl7pr2pcicw+PAZb2p3cm0qlSxsMp8BqJ0c0+/MNIu6MEGgOLyxpwHDHN0BLjIhpGTtBdMK5Rgq0y4tCPugFGsf4Wup+My3Y2zeiI6MWdOW6ALC+zUwDnmYksPwAAAABJRU5ErkJggg==", + 44: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAUJJREFUWIXFl1sOxCAIRdHM/rfsfExN6ZWLiDZD0rSxFg4P0RYRafJHqdMZL+ONAE1dIiJFPb8AMwKU60KDTY0fhHkCaM87DEJYMFsAaJAZ1xDsXQqgK7M8ZXKwFm5frKLDmWjci0QwRT8VM49QGUsbzglAVFNJgTsajqyGYJ3wRoQQmcoPQNRBOfMOayDaE3SRG/M+lNRrPDi3f+9FiDgwRgA9xLZsyUp6eqdtGsBrOgjDQCJpMMbqY4ApswwXWS9KA2y+HVuGmSQ65NgJPePaEAurJ0atPIswosB6jhgnUgcqr+16hpMblF0DFoS3Qa0sQdAzb8Ur7xJR8FeBrgt2RygWrRQAKl8J9cLUduSMF9FBl+HsoxclloITQiI0B4icbDZSmIvAalocQH87ZnLop+QG2JHN9MT7wOzAkTAuIvIFbsdiOX8KB4MAAAAASUVORK5CYII=", + 45: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAlQTFRFAAAAAAAAAP8AEEcUsgAAAAN0Uk5TAP//RFDWIQAAAKZJREFUOI2Vk0ESxSAIQ0nuf+i/qAQi/OnUTWt9hgRt4GXEF4DPAP8qJEAuAJOohwG2wkZEiWMlohe/zVzAjCPgFuhELAK2JfosMTaJMIGni1qfAI7QrpAi8mgAsKRwwEJgB1gABkAZmEAeZVmsjx1QzF6oDkvbD3QmBlQPZJi6MMMCTm905SpGNVQmTcXeHOh1sAFVavsvRLiXG2BDJ4AXDy1qU/gB1Z4FJkIxQpEAAAAASUVORK5CYII=", + 46: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAxQTFRFAAAAAAAAAP8A/////zPWCAAAAAR0Uk5TAP///7MtQIgAAACqSURBVDiNhVPREoAgCIPb//9zZwlshNWDh2MMZ2L+8xlvgFqFANwgIkJhi7AibDAVbmhFtuOnnpaAmQAuJ0IyonJHTwW7kEOqzTxcKQTNvBhRKZtoUTkoIgrlYlBotXnf5QKo5vQ7iOBxRQ4/ENCMKGE0+WrxpSDPZCBAsrNCuZwJfFXfLWYXf4SWL+BEOCrk8ZoCwRgJNDNt/izzSFA28aohM5vD2KZ7+i6bwwVnShVyQwAAAABJRU5ErkJggg==", + 47: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAxQTFRFAAAAAAAAAP8A/////zPWCAAAAAR0Uk5TAP///7MtQIgAAACxSURBVDiNhZNBEsQgCAS1+v9/TsXACIi7OSSRaURGHfPPM7ogFQCyxgoKeH83sUYoNoTuOSglyvzMNIwAIgKZ1tDoRxe7RAQ6D/z7EyADVL2dAYKZDfDpVKB4c++CaEQDpPRzDceefa+RA6HVUoKcyOFD3HK1egOibgDRiXxsRsiS3jnpujqIwE5gd1uBlYQRZKstZJrSdXHwy6I65hN27HF/sQs1lYHP4BZ4nX43L88DwwwFYW4O0c4AAAAASUVORK5CYII=", + 48: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAXtJREFUWIXFV9mOAzEIM9H+/y+zTxkxLuboPixS1U447CFAUgPg+Ec5SuHucM+5xXX1W8VjG0OSAXeHmT3GZtYS6Wyi/sYHkgxE5f3O3ozXlI2ZSXIA8KPAr9xMsK4KqgiVBDJwBuN0xq1SNp3IItwQ+RYcAM7WicH4ewMOhC6otkDpsi2Y+EVd2obK4WGdgHLrXjv25/p5dYECU/pJK1brgJgDnXTdwvGy9bv2MQfYKBsmKt1qWxQpd+/bkIGmMpkrrxrI3p5JRMfqbStwlsPganbHkVxJB87+q0l4iURCEXSSdpYzMYr6rEW30y9KOgeUZNUfiW1Sf+VMjDIS8TPx//MWxFH6TVsqWWVApXpyEiqbVRGyDd+UurMgi3+mwBlAd9/rwB8C0XgyaKYgk6152rC7WEQ7RWQL/iLQkeBgVfutzwIFkpFjoOx5MxnbK1l25lektgQ+TkMFHoNPqr+TG/vwQvbc3mwX/5g+Yru7V+1TtRjrtzXg7vgFKKGDVGX90zEAAAAASUVORK5CYII=", + 49: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAUtJREFUWIXFlksSxCAIRGFq7n9lZqVlSDcCJjUu46cfDWhUREz+OL4nm804u6qmzlBpOhCJV0A+b4pn1pYBKuKqKqoa7jmqgUhY5AprZjAdpRrIRL+L2EO0aqArLnIPIg2wO5iJjzpg4xEHInEzo/m/AFSquyK+nk+LcF2IFnXh2Fg11MzMt032Gu2A+bOnAxEEszg7P9bAFKz+I4hM9XuQiqMzBdnIV+FIIOOKiLsJs5F7cW8vcwKBXIpwFwGCy+aawcE27L71qJjZuvGdPkaRA2w9szyEGACIOMrdTpwVs/9+ScFtElQ6++5BECSCmPcAE/fC/rCxN9t2tyJEXXDS36X8syKsvP27dyPKvwj5H5j2oJuL2D3e/ahwEcy2DZl961w3/yHA2JBpJwYYBbB1wEOc/Cu0bsInRgbi0d9yP6L2HHOvAngINPcDboFfHhnxxOIAAAAASUVORK5CYII=", + 50: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAZQTFRFAAAA////pdmf3QAAAKVJREFUOI2VkoEOhCAMQ3n//9MXFVjb4V2OGMS1dt3GGP8t+IrubfhJQ6z4UYv1XPhZ4GFw4UmYkXu/GWFo/uAWFe91IATDLZsDUiHxjs7glhoelZOJ1BZyNBozUSlgoqwa9EsZuyNTQWT71He1uzOEYSJ/Vm8GKEUibAYfDpwJlPkXBdxLEFpDhhbOON/msrZlODFkhJ1Rl604SXmm25HIxQ9GXx+dOADM9pAiNAAAAABJRU5ErkJggg==", + 51: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAASxJREFUWIXFVtEOwyAIxGUf3U/wr92TCSUcHNRtJKTWqhwIV4aILPmjvJ9sXvP+Pq7mOR1dk5vL9NVCPLG3NiqZlK9gG/AMjesHALahUwIBaE+swf3NeuwB02uhLatr3hMKjdFee4Y9T+sQkgeikkP5wErqkUWPPEJzUdTCJNTl5kVgf0c5oSMRli7yPBpvz/S79yQ0TyZkHIW5AgIyoVd6es4rwSoJiYi0qDgSnRcsKOrHw3ADU/eOcgCqa44B6LBgBcDRHMg4wRMaQEQkTyQE8C2jNAANhJXqNaQA2Ch4pMQCp7KV4frGf4CrgmouVGm5VdtM50NGgjeO2C66ngxEiYhQc/JEykx4mhsggKgdQ3Nsm5YC8IxnXnsGGRBuW44aUD22zWa0R89Z+QCqlz2k0H53+wAAAABJRU5ErkJggg==", + 52: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAAAXNSR0IArs4c6QAAAS1JREFUSImtVlsSxCAIQ6eH9gje2v2w41IeAbbLR6fVEBEDlci3NcFk1vp79o1c03ZpL9mJqA1a834WzIsIRFPYwXFowyAieoyfKTEYL6ApHp7PtU32Ndkhhwlpw2bx3PdI5x9vdGkm7V6Ab9BbYwPMWS0hTtjPR7iGecg6+5pQTmcEqmHlJAuo5gJgboFMsToPBqgrxc67jdhKLG7A7inv9hxfTK2SD5q/mDL19IPM61wnGydRZn6MMxMTPHAvNND1BFUQNYjLLAKAR+x81iTVqeN2nbeqljX+x2rYVirsv1l4eETUcH/mXLgyCvnRB+X9BjJU8l4E+ntYVmab6gKBq1+XmBargF34MqL/XHzQu2zZ414IGTMb1H65gE/SAv1oLeepMx2p/9LTK8gPlrMBMRnvjvkAAAAASUVORK5CYII=", + 53: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAlQTFRFAAAAAAAA/4AABnhFZgAAAAN0Uk5TAP//RFDWIQAAAM9JREFUOI2tUkkSA0EIQv7/6GRasHEuuSQ1FRV3bNSPH1qQ3PgAsNUIRzgEE03BLQbG49FXbKXVk/EEcLtfIQV3VlRPOFARZDaJCMXBHk0fSkdAI6v/zCbsWyFGjMJ3zFmzhhqmX0TF/snHIWolVXZvBeWr3EVD472F6pPucm9RHoPmwWpfc0j1rmMcHCY4V5NxgrBe0Zb3ReWR1tEOD1RW7zL/hrHMqGMY17gsju0ZJpMhBCNz4g5T788V3tIBe/UkpYmyGo+9bhoiafMgxwcWBAVgSaxWswAAAABJRU5ErkJggg==", + 54: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAAAXNSR0IArs4c6QAAARFJREFUSImlVkEOwyAMg2mP3hP66/bAxJCT2IblULUQbBISl9aU3Ve7LzFC7CXRnRHC17fQf8s+6DNHwN4EPa6JuUrR1/E8goE+/NKtAdPqA6x4BiOhA314pImqEhJj6jBH9sIRxQ78sqtWjdBjRXVCsJZKfIdMAk4ZgbMpcF6fjbQF+HFvyaGZztBXaKEoEt3k6HCAq6X9mbb3PO28e2L2uaJVChgjyBFNBXU4ttEdTwz0LBsOh1AHUmQVfVpF4o/GbUr6+hn1ozQZQeqzlyU5JVudpcgK8/+Fu4W0h8XdHCncpvf7LqeVu0i1WgK65ojSOQ0khPfztB7nqptW9dv4AhWlqW8VwMqjjjeMfngatj27QywUyyWIVgAAAABJRU5ErkJggg==", + 55: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAW5JREFUWIXFV1uOwyAMNKs9dI7QW9OPypGZzNh4o02REI3jMIPxq8PMpn1x/KgX8/VlAk+ROAkwsHE8Q2Ka2Zyvz/Rnl8UVp5J35nIFeOL4jJaIz3esdBJwMGb2caxAvjLdLplhEIaRBAIjKaWD71oEFGAFHsHQQhmR3x1gFQ0MqLLcZW8jV5B+UIQmswoj5+OSiFwBVwaO7xxMgftY9rBGLWDgKmxRhvouv1gAQy2u0Sp4UtRhMv8did7yAZU7lBNSn0ACikR2/1U+UHuN448+oDy6a43zendmLExZkYoy1y2+rYEZ4G6lrEikV5BlRmbynSuJ5k99oHJEFdeMCNtP5oEMHIGzBMP6CBY5W3kgq2ZVAcv6DLOiKa1G5SNRR+kuBDqn3ylKTC4JoAN1zL7T/WAtWQioDKd6vqxkZ8SY1WhTWp0iazAQoNqz/Ge001gyXVUJKUnbSK1MJ9Nl38Y0HGbvn8wdEmy2yvF/jDfxpN91/a0m7AAAAABJRU5ErkJggg==", + 56: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAhCAYAAAC4JqlRAAABhGlDQ1BJQ0MgcHJvZmlsZQAAKJF9kT1Iw0AcxV9bS0UqCmYQcchQnVoQFXHUKhShQqgVWnUwufQLmhiSFBdHwbXg4Mdi1cHFWVcHV0EQ/ABxdXFSdJES/5cUWsR4cNyPd/ced++AYKPKNKtrDNB028ykkmIuvyJGXhFBPwSEEZeZZcxKUhq+4+seAb7eJXiW/7k/R69asBgQEIlnmGHaxOvEU5u2wXmfWGBlWSU+J46bdEHiR64rHr9xLrkc5JmCmc3MEQvEYqmDlQ5mZVMjniSOqZpO+cGcxyrnLc5atcZa9+QvjBb05SWu0xxGCgtYhAQRCmqooAobCVp1UixkaD/p4x9y/RK5FHJVwMgxjw1okF0/+B/87tYqTox7SdEkEH5xnI8RILILNOuO833sOM0TIPQMXOlt/0YDmP4kvd7WYkdA3zZwcd3WlD3gcgcYfDJkU3alEM1gsQi8n9E35YGBW6Bn1euttY/TByBLXaVvgINDYLRE2Ws+7+7u7O3fM63+fgBXknKcyUKElgAAAUtJREFUWIW9V1sOgzAMC2gX404cgztxNPZVFGV2GrfVLE0aXRu7eZFtZvaYgMtuuH7aoZh5sSkCGnkkY+tLBXiS6AW/por4KJsReRM3GoJdIc/AcmOZAERy2jF88wYpCb2IFo4moJcjSwV4csX1SIiUhJ4sGutVwmU3TNayAJb9VbEsDFISVsBuz7BEQCONCVkV8VQ/l93lvegsOj/lgZZYFWSl+DcPIBtlD7C4+vXs+5QHvOoWS7QWz7Bbh2fN7ZUwRHHZ72kIottR+2V7qoACfGx9bVcMR4G998VPK45EM+NWBaUQREGx440OI10BkRyJY88M0cNwHuhNvz2wYQXZNBvsgr4fZKXWK2NpIIm3ZFByY1hAlcDvRaLlPyYqUF/woB5Y8Zqt9JDXAysImYjszJ6R+1ELDZYzDchjaAhhZabYMGUgmUH2QvoC6Kp2/lujcjkAAAAASUVORK5CYII=", + 57: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAxQTFRFAAAAAAAAAP8AjAC/THy84wAAAAR0Uk5TAP///7MtQIgAAACpSURBVDiNrZONDsQgCINH+v7vfJmApYK5XHLG+fuNleoe+1KeHADwrkwEeJffitUOEXzTSyU0Ako3AK4AkKX/ArmFWxYrgew6sNKLLAtRgHTCxCpanS67iGY1dgbxYAIADg7AhW0N5TwEsHx3BuKYgmhALIQDzFQjlGbUkEleNfA0Rw0SoWsgxol+wqReIuwsbBBpR1WANtAIBSwuUvtzfry0x0ABVIDEBxciBgM4SLpkAAAAAElFTkSuQmCC", + 58: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAhCAYAAAC4JqlRAAABhGlDQ1BJQ0MgcHJvZmlsZQAAKJF9kT1Iw0AcxV9bS0UqCmYQcchQnVoQFXHUKhShQqgVWnUwufQLmhiSFBdHwbXg4Mdi1cHFWVcHV0EQ/ABxdXFSdJES/5cUWsR4cNyPd/ced++AYKPKNKtrDNB028ykkmIuvyJGXhFBPwSEEZeZZcxKUhq+4+seAb7eJXiW/7k/R69asBgQEIlnmGHaxOvEU5u2wXmfWGBlWSU+J46bdEHiR64rHr9xLrkc5JmCmc3MEQvEYqmDlQ5mZVMjniSOqZpO+cGcxyrnLc5atcZa9+QvjBb05SWu0xxGCgtYhAQRCmqooAobCVp1UixkaD/p4x9y/RK5FHJVwMgxjw1okF0/+B/87tYqTox7SdEkEH5xnI8RILILNOuO833sOM0TIPQMXOlt/0YDmP4kvd7WYkdA3zZwcd3WlD3gcgcYfDJkU3alEM1gsQi8n9E35YGBW6Bn1euttY/TByBLXaVvgINDYLRE2Ws+7+7u7O3fM63+fgBXknKcyUKElgAAARpJREFUWIXtV1EShCAIfTV7se7UMbyTR2t/loZ1AUGsfvbNOJMJ8XyC2gLgwINYnwz+JwAAr4hxQT2fd2z3EaDAPOhMMofVCqo5TjYeO6XFCFiBRkiEkpDLLmHH1rWRMF3eiL2pQEE9E6ygDs2uh0v2gchShAl4P+wloRIg+TP1Tv4WkWlLoAXZsZlERAKSYXa340R+CGgB2/e8Kjz2HpwKkPOsUgtVAa916meST1NKSuy1dbCkHJVZ+s4XAY1da2zByg9rfG2NRoJn8JUDdwcnpE+63p2B+pLv8J2QI1s16XPeq4A05j4LIrUdwS33Ad6XyA7Jz69qUpJJz9K7YQXodIv6tLNfPoxc6FVBS0irDL4cIQJX4PGf0zcw000xKtIqzwAAAABJRU5ErkJggg==", + 59: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAlQTFRFAAAAAAAAjAC/MJKlOQAAAAN0Uk5TAP//RFDWIQAAAN5JREFUOI2FUwkSg0AIg/z/0a1CjtXO1PFYXUhCwOo/R8Ua+F4/A7jhCDwDsI/r6PgUAVdycGhVN/LmAbtk9EuD2ZRU83Lra1BbkNUI2HgxYPOEcINMHWQ4jCK+BTJ+qxhWLAK373tYnT4+nKRwLDmrklFHKxDO28k2swDmrKwJlieIauYNxGSHa+UKm+BQYxbBKtQYm1byABIBCRIFohACxMC0HHK71PKgAA4FEtkR4n5rpW6uUISvtBrCJIo865cPHAj3vjTFp9Ac+6ia0+mR9H+x8IbKX0/7TI+Z+wAytgWa3LC2QwAAAABJRU5ErkJggg==", + 60: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAlQTFRFAAAAAAAAjAC/MJKlOQAAAAN0Uk5TAP//RFDWIQAAAMpJREFUOI11kwEWgzAIQyH3P/RWB0mgrk+f2v6mEDDSBl7eIgeB73XudADGn/Varmc869DgVyleCgygIAdMXYeEQoYpPGvPBgGSab4BjL0WzRERgJ5JzaTHMAVuAH585+FpouLWWXRSVrbqroXzbdEFWCq3AiwtWDk3ADCPlxh+c9UrQ8OKxYRzAVZuGiRiAHy1Hpr9ABkBU5A7WIYkm1a7dEoBnKwTuieaCJmkxwKogHKrC79iUJL9H80s6q9qT9mBkfcmfjrwd3wAu4YFMBJ5c6EAAAAASUVORK5CYII=", + 61: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAUNJREFUWIW9VtEOAjEIY8b//+X5YEwQ2gK70yZGc4elG6xsmdm2hG1mKz++BMz5wIG/QuZ+5IC7V+6xkgiwA/8FEZCVXgPf2SDAJ75LhE+ehRQluCqi7ikgICY9FRGTYzGCHRGY1acExbV7QMHXcZJc46kTIuWqJOid7oMgINaeEakVMuGYG0je+PHYIdH/R8cwrna7j0rqY+odEz2AxPhEnWc95sNxrB2uyzk4hnH7F/ldlekbTSNCIarLY8wtRvQhRKI2eN9DcQqYs6EkLGZkRArVUFImxlEIiOaBhpNKejSOFTrdPRvdgxJEi47HMN6kemVoCGBzoXrWEzG47lQrVDvE0SwBst1q2h3tgCdnTndyJePcTgCz0kioVobsm1X5HffUpIqw2wOae5ntjUmZs3V7oMcBegARst5QV3D0ncW8ANrAhEO3Zl04AAAAAElFTkSuQmCC", + 62: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAAAXNSR0IArs4c6QAAAQ1JREFUSImtVlEWwjAIA5/3v3L90cogCczK82NSIIEBndmRrPCwoMXjDGBj+IlzaxPzuBd9lb9JU42nGDpWVUbNCEMn/k8MZipOf6xVYq39b2O0Gkhr2XgO7vXfR9xsCQDWSO30xtFzBgDnM0X0K962uXjBEa/RU5R6tME8YdQMIHexamAeVMQA69PpqqgRoT4qmQt2EB0iBm1rpvTbOmiXIwxorOT8RtMCSMyTGN13IgPvMHxe+gyLnuHrbZc2ziBSc4Ix/YzYAHXbsP2zwq+XtEnq+kyhq3ten8lYMKU+iEf1ehuzbcrEZ9X/BoEvmXU9C60aWvcyiwjvDEzuyaPblbXgoao6mcbfJ9bMXmrpm6m8R29bAAAAAElFTkSuQmCC", + 63: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAAAXNSR0IArs4c6QAAAQ1JREFUSImtVlEOxSAIE/Puf2Xez2YQaAWzZjGKQFUQJ+MMHUP24YJ43YAJLDmZmGEVCgz0/aJyj0NDB/V1b+8JlLbpIhLMfRhdiGmXpHH0E08dHTVoBo2BYoUqDYkVig23ygkqHGgfEGK0BVxadF0rs/5OSpZCHArU/BZjgiIJ71vhduwkdCTOhOMh+IUJF5WxD93CK2cIl4CEdooc2jNcN7mxFgPB+c0cVvI9jVNSDdNaJKAQkRODhYufzLKRTB5tE3nMIs5UVD5ElDwvnLJU/nhxJsS95yE1c9l18/QTgkoJSUCezAh0rVhIWwQHXxcg/0Wxn6O4g17hvCCw+Oy/6BsOsnHnIi1HRyfjDxqnkLbYqnInAAAAAElFTkSuQmCC", + 64: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAxQTFRFAAAAAAAAAP8AAAD/0o8flwAAAAR0Uk5TAP///7MtQIgAAACySURBVDiNhZMLDoQwCERp5v53XiMMDAWzaCK2j39r54+Y6EjZAaxqAs1M/ghAgjQnVvtp5QpuoIe4APQyNKoCkHcD3p3HHPUfgDuFP/HJZdOEwrpywAWc1ugNaJLABxGrBKQydr0Dnnd1CLeHtFJvBKJiD0XXXJRpVqb7NO8TtQJs1AToFaJPIGvAAnB+HMY4tPPITUCr2IFMDjuQU0MPEXkhrgao+Maxdr7UW4xMb/cqP62ZBbfx0owaAAAAAElFTkSuQmCC", + 65: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAxQTFRFAAAAAAAAAP8AAAD/0o8flwAAAAR0Uk5TAP///7MtQIgAAACwSURBVDiNjZILDsQgCEQhc/87d1UYPi1xNY1gHzgiopchvw/2rWUNWgacTQRGCxuAJ9vYmRa9FkEKQU6xoQOAGeHDoXzE3oXt+xkhMmnnPwIWXgCKEaUsMxDOF1DdDuACIOwIkJrAaoCgGhAq/OITQOcLwAR4gccMGo8VaK1DUtEBf+80C8DGY0/pC7hmyABeGqjS+3sAlM02A72svCZbOcqagBTf2+ZfoNS/eKzDNB6kygX1hPndnwAAAABJRU5ErkJggg==", + 66: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAVFJREFUWIXtVtEOAyEIw+X+/5fdyy6rtRRuW7KHrclFT5EiAjoiYsYXcfsm+d+AHzLAhPlhhUfj/w3yCPTAfHyn0gH/g/5x3hGgvDXgVMLKK6UDxhyMvmMTYGNm7LtXBlfErGMZnkIYoVxZKN6gNhLnESgleL5DjF0hN3jGgAqycw5bNhJbB9QP8nsM8CLVd2suYvUAgwmckZM+BeEF7QHMf1V4OCM6xiceew4nUZqSVJmTGUQchyTvWO/kFRKPrR5QytVOXrkTBHkE3gWcflUaVlWwif065mBULfez9Q2s13FW6xVBlQUKaSl2wkFtRXaxQOXiKjNU5FdZU3ixZ6+6qN6IfJyr34SOHMtup2wL7G9CVpAFZvc9UNQMfQTu9YPz7gHDLDz3WL96oEqxatedakpbXl/FikzNu/N19UFc1XkMoDLsu+h3Mkk6f+hd8zruqcKZOlY8Mk4AAAAASUVORK5CYII=", + 67: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAR9JREFUWIXFl8EOwyAMQ8O0//9ldkJClk2csK0+tZSSh2kCHREx40G90h6IN0k7a2P3JYD18vAGou+PHEQD7IEZxGrbA6ng+DwFwMBzu1aOsD6GC9pgJGcBcJbsGRvLAkBqFgCdUi4dloADnNa144AaUwIEac1mxdzC94n8JLt1QCgHYKmoBq/0tQFYkBOAOfOlvBSjsjpQVB1gD8iu/wZwKsU/BcB0w4pX1LscmG0yrOabrngOqABqwynklu8AAp3uC/JORGuGaCt+AwF9DbCaA+qLN7depn4WqLNhsbb6ADizi9zvAaC+dJjvAywZJ987ALWmWeExP8beqV8duRhIotoSsHIc0FZUDeC03s1dsfvjdR146b4QXWbB4w58AF2Ueh/5xGUaAAAAAElFTkSuQmCC", + 68: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAAAXNSR0IArs4c6QAAAPFJREFUSIm9VcsOwzAIC9H+/5ezUyZabGq31VDVAwGbEB4xFFlFE5KfZljRHQ6HILiGy5TCOGHJ+XEIxg6cZewFgkh/WT6qoRm4TzDQIztORayQOQw5uZcQBIZ0d9MN8YpiteesxbLX8WhSOyh+pSYCMTNmHziNJsoxUE4QwLpDJDebB6OTW+aABhmdhKKlaJFZze6X9LdmkdMo7RvoQItWcCHoqzD2J8dUCBaHuFxq6MYoRbBsKqLWcVoVNTl5geDyVZ4SPJO/EZgz0if40cQuZ7bilZ2RGkKeRdm/4es6uZ8NcJpW9GJGdrI1iCDBBv4CP4E1QtjzoX8AAAAASUVORK5CYII=", + 69: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAlQTFRFAAAAAAAAAP8AEEcUsgAAAAN0Uk5TAP//RFDWIQAAAMFJREFUOI2VkwsShCAMQ2vuf+gdJUmDC8PI+EF4pmmBug6tvgK42w7Ac90PbAD9iw3wSIDXJoQ6JyA0KsZivkWqh8AZmRki1doiQLMjTPV8IM1OgEz4hyuBqLDL5RBD9qXAypeDxwT+gHGDXaCrYYASUJLPmx4WDuAINIm2ppwizfAQW4FRJmBIAQsFOo5Kvwslz+K6Xt4wzIVu4LwSsDq6G1vO6UHbYwIALdk6hA5ML6RiVC5wrrTeUmAz6O/j6f4BJx0FD0j789sAAAAASUVORK5CYII=", + 70: "data:image/png;base64,R0lGODdhIAAgAIAAAAAAAAD/ACH/C05FVFNDQVBFMi4wAwEAAAAh+QQIFAAAACwAAAAAIAAgAAAClISPqbsBrmCYDyZ7nERUx3cZW+hx2aVRXIdlbSOmk1pZLyrLIMOrZcoLxTw2kfHm6uyMTFqwiLEhYccqM2jyHUfYU9Q6bbRGwG6MRA4nV7NTpetst7fYWREUf4vTeP37BqR1d+UEZnW2VdjHxvghFDUWp4TmEqG41KOoqTZkyclQNjQHh/i1o8YihXiKxNVKZRa7UAAAOw==", + 71: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAAAXNSR0IArs4c6QAAAOBJREFUSImtVVsOgDAIG8b7Xxk/TIzh0bULfk1XWhgd2qIfd38XZsZHyexhPc+uylyDkgMCL6+7820QBMomf5I8T8tbfnT3GfatTIehBBiPCuyBtDwNUBClhKGAIm/dGfGZJHhxbFRIxghI9pRKHHli4fXKe9JFXWuZmWyhbt2dXolEAtiOJXWXWT2LtKrJkH/u/O9lW8EGTbJTAlouPbJtMkDzSkIbMjp7VG1YpCAt/w/UvMfMmaDBCuDa+WsoaIDEz9mzTCbdCrSjAsQcDJL6ObjPJ+wdy4kvy2DQBkbjAdZatI8bL86ZAAAAAElFTkSuQmCC", + 72: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAAAXNSR0IArs4c6QAAAO5JREFUSInNlUsSxCAIRCH3v7OzcMoiCE37WYSFlTL46E5EpbUmIvzIhM+/xY1pd+nfcBCrmBBHDgCumThykC12AdSwDsICjJrUAfBeOpjdaH9S1TGrqnbG+32HS7P5/VXAyrRs0EXk6Xo36CAss9DuasxqSvdPiXZ0SyzdC3ZgF2escEdQBUp6h2a7bkTxiTK6ewty0n2G6XOXZA5QN9nuwwVAjdcn+veeGbG6ki58H2x0QI/6J6+eTqs5Pm+cuAtHCHOjhTUoTfEdRNDLGw1R+PnafZaBZ5jbmL2TmUrIzcn6nRr3K93Vyzq4OP4AF6fW0LqyuFQAAAAASUVORK5CYII=", + 73: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAWRJREFUWIWtV0ESAyEIw53+/8v20KFNs4miK5fOKEsiYKQtIno8tN5/IVprS/6vp+AI3Hu3ZHAd/Y8RYEAGdZm5ToHzCdESPH0wU0cIqNMhoQTMtKd/a+1cBhA0fxEIwf9KEwduARPg5lPNmGtHM8Dglf3tW6A6vKoB6LeVAe740Q2Y7S8TcMHcOmdluwTcPKoEqglVHNyfEmAgBOFrxXKsiPDasAROSrnp3IlnvREx0AFOlduv+I1IygyMgj5twturGJSB2Ykc2G4WtoSoIjhV+ysBPya7poYPF1f2wKxuJ+1GYCW9O8T4mws33GAxGjhcQ1Yb9XIgPGAq8FFtFQk1kFglVCqnZBZJ8Bim1JNt6TFyQdQEVFHJCBAiNTpVBGnFRwlS+6yvg6+ae9ikEKmPq1dO+WJZbk3oXjW8ZvlhxRSI+tv2JaBOUOneChGOaXVgRuKpOWGKiLh4tDrdfGj4Fy3tDQ0lUDS7MbOrAAAAAElFTkSuQmCC", + 74: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAAAXNSR0IArs4c6QAAATtJREFUSImtVkkSAyEIBGv+/2VzMCEEuhGteEpYmqWRUeXkzDlFRFXtR9YG+ejjmn9HbsKRFdkBomT5SlxVQQUeNxQe/IW0gsWOLYI+JvTaLLSO+bIeSeXPOWGYbAb/Ll/MQXZj1Wznx5j4iSafEWTNrccUJwSz9p4MNMihr6wWQeo8ilf5Ue5Q9RTVedPVt4zILo1ZDsuuGNAwGAwdIgxmkdPPwuALq6l2USDWx/Bzyapfp8uBwYmbn8Ly67LFrYHs3jAvcJPh1MK59Fo263jstnlB2jM6qEDKy8k2mgkz25gDv5HyqthmvQ8ghNsCna1IfA8YmUzFPs5S34MiRkFyOJhkZu336Bb6jdYxMvSQRIft1ruIBet80boBOg05mKILrJt1bafz1GA2ZxXAN0udwVmA4kXznwAX5wXBryxTNJai3QAAAABJRU5ErkJggg==", + 75: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAAxQTFRFAAAAAAAAAP8A/////zPWCAAAAAR0Uk5TAP///7MtQIgAAACiSURBVDiNjZNRFoAgCAT17f3vXKnACoj54SsZ1zGz9Utro4e84m0V8FbREQEd/OajAk5LwCJSyVUec5E6jDEsxEkoMO2kjwBmwnwAuTbbv+SsGhgQQZixEALIIMgBHpiCugAIoE8pYdgSxBm6WQ+Qme0hdWDFCGi+BXiAj6Qfge23yAFqfwH+ZQqgx7oDbkuUkqiBnwnxVmwJ66jcxWjJpK09hJkFbcnr6SEAAAAASUVORK5CYII=", +}; + +/** Beast ID (1-75) -> data:image/png;base64,... (shiny variant) */ +export const BEAST_PNG_SHINY: Record = { + 1: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAY1BMVEUAAABzc/9z/3N/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93M8HRRZAAAA5ElEQVQ4T32Ni3qCMAyFz8Yuuk1lChQG6N7/KZdbS2vqfpKTc5J+CvzDs1+9EH678a7EhOgSH0q+Ke4HkUOeStoWLUvK2LxwSfKA3yQWNx+5WVe5XstZsK5Ua/Rr3NpclgVSiyU1cYEZ8yzNI01z9hs/BRx5KR8xTRO3yqSOPphiJFjUjRYx8sn+AAEh8AhaQS1yBtVBSpz4Id77Hnf0tHJLdOgE8Z07A+czFYsEf/8moPWA00mLpMoRx0T1wVdG9QE+E/X7HnuDbI3dTkvb86ak6XllVGl6GjRN3u7BE8HDrATgD8U4FYbMv2GjAAAAAElFTkSuQmCC", + 2: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAhCAMAAACP+FljAAAAZlBMVEUAAABzc/9z/3N/c/qJ/3OLc/SXc++f/3Ojc+mvc+S1/3O7c97Gc9LK/3PQc8Lac7Hg/3Pjc6Htc5H2/3P3c4D/dXP/gXP/jXP/mHP/pHP/sHP/vHP/xnP/0HP/2nP/5XP/73P/+XNcoW5xAAABA0lEQVQ4T3WLiVqDQAyERy3W6gqUqwV7+f4vac7d8En/JDPJLACB15VtsNsV3WS/t37Kp/D8/XtlhbZtbaFSiXHfs+iKYL29/XJzMeRh1bcHqFkIdjl5txh3KhG2u3UOqG5SJgZKdsM1F3EVZCvxhfsilikRffsDExnCM8+XhZtcksUsPMzz7OL/zTEFzmfL3fNiLycHJz5oQiRMk/0xUams83Ec1eHBKiaGYeAZEFU2p+s6VnTI5pFxNDkS5YJcmaZBI64mScNrXctVM1tLSomvxJ4CluCLgRhsVDQHDjgYsAlmfAjiefhC5p0wz/OPqqImiUsV3t8UWfIlu/KiyOK36h8+nx1lGP9+DQAAAABJRU5ErkJggg==", + 3: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAYFBMVEUAAABz/3N/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93OYI300AAAAxElEQVQ4T32KhxqCMAyEqyKKCweiOPD939Lkkq580L8Zd5c6Z1jYILJK0CT/4Opc1HVMhCYTTRJ4DgqkPTJtK7MVoVyJoMPwJ14/gARTZUzdOLoRg2DnJTvwRVGzgBGLxXxQfllLvFHShJeymBcKHROfMgM9NwwDJJcYxOCpL8FED3pcGHFDgb7HDF6kpAl3aV0TdF1nhOFG5dvewAVDZn4RzrNGOc0a5ThrhH3REruiJbZFS2yKllgXLVNV0zphGbCXEn8jFw78eV1YZwAAAABJRU5ErkJggg==", + 4: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAhCAMAAACP+FljAAAAY1BMVEUAAABzc/9/c/qJ/3OLc/SXc++f/3Ojc+mvc+S1/3O7c97Gc9LK/3PQc8Lac7Hg/3Pjc6Htc5H2/3P3c4D/dXP/gXP/jXP/mHP/pHP/sHP/vHP/xnP/0HP/2nP/5XP/73P/+XOFEODKAAAAvUlEQVQ4T5WMgQ6CMAxE6wCHigooiIji/3+la9fNSDsS312vl3QZwH9kWbZ63/Ik2cVIUFWASnOOodPyahP3t1NoKvMMMzf9wYvkm8aT5bvChJ5ilzxYviuMMDqHrnBn+ZAMAxkbpeTGCkvQo3sIKejQXVgKV1JoChcnzLAETdO4iNKo0Rh1rVxP7FPskiOaIsHB6WvBnsTm+KFEl2EJrB9LYa0vC4qiABIiv4A8j5NTWWCMASfjGplmnQ3lBy0tClPpWieWAAAAAElFTkSuQmCC", + 5: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAY1BMVEUAAABzc/9z/3N/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93M8HRRZAAAA6UlEQVQ4T22Ki5bBQBBE2xIr2CQrxCOI//9K/Ziu6RH3SPWtGkTOj4A2Z2W5sjvnVz7EF7ZbTdiMP+bTQGdf14noNXF6z960F+IfXtGlvOyAyc80maYh83xqSFoPb8bj4ZFryd2SSbd4ZcZ0RpFRKJ7pdoNpE8IzXa8wbZb5/XKBlTVxPsPKmhiGwS1k4HRyKSs4loIKDsU9oCpi/zZ8HEDUtjpZptYGqGlk0lBp+GebCtt+zy6fIk2X1ER3O/580paxVtf8+VRLy1jZMJiCFqwha1XLSAWpKm1pWPoOoSUTloXvEFoIaXkDk/QPWXqmWv8AAAAASUVORK5CYII=", + 6: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAYFBMVEUAAABz/3N/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93OYI300AAAA10lEQVQ4T32KCwKCMAxDq6Io4hfBH+j9b2mTDhll+pqmaTcRMKP7GLFYTJNjpWD4e2ATXOcGmRZRsqQsIW1uEQf2ATA7zmc6pYuuPAy8g/dl5nlRllCerjN1jNL597aVNrgl/0Hk+YR9hW3MA60ICtF/uPfSvmMkuH1HSI7rJDiaRhtq/ItR10FS+ydyScaYqqr6NLrHnMw4khzRR440+722Vp8n7BTZWcTmnkW2NHMsTDFFAUnBDDHFrNcwrUFjcus8z4XCPmapNShFlkmmjvmLOfHXf3wAyUAMWk/7dc8AAAAASUVORK5CYII=", + 7: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAY1BMVEUAAABzc/9z/3N/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93M8HRRZAAAA+klEQVQ4T3WLi2KCUAxDyxTxxRwComxM//8rd5O298G2w22SpiqSeFv5mu0WQ1mfSNMIPkqzPoIj5+ihoG3bIPZFQ2l8hIfJn5rR6/Q9Fe6V8YoiL7PUkOczTFq5oMv45vtzW5ZFLTZx09MXX/JfzSeGotndO5n5r5k+zzq22vHxoApNsUUvgftdzaOtaso0TVBbYlFwu5VTMo4jFIFmhTEMg3osilquZvCrrsx+6hi7DqEj6KB2vGAocFB28h7Aj6m2eKNOzucwsBjiCZxO/4hyOFCFlkXtRfZRNWWRuqNAd/go3jDVNlLXeG7psAlgB0j5lrJSVZVJ4gdBZRIvhUexBAAAAABJRU5ErkJggg==", + 8: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAV1BMVEUAAAB/c/mK/3OMc/Sg/3Olc+i3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93NHMZYcAAAAxElEQVQ4T52KiwKCMAhFqay0LK2mzsf/f2eAuLGt7HGAey9sAN+wXX/OMmq3uOg5YC2RSH8UQSr8mlKW2GVyrhavKrUpJrGJG2WKPows40gjOl/kfcBCJRsG5zxC3/OQcgGHvncfrAUqag7WLip0XYeCJatc3AGg5VahZWvdh0bNbA34FTFuUI2RkwHPA4taJAjEnVttemVuWLODpNfUYnX8cFX6DZfkcg6i2mJOSUjIqfM3j8fAfmMf+Z/sAltl8+mD5gniRAu7syOJ8gAAAABJRU5ErkJggg==", + 9: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAXVBMVEUAAAB/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93Ow8UUdAAABDElEQVQ4T52N61LCUBCDY6lUQSpX29LS939MNskekf5wHL90NsnuGQD+SlVVy9UTr9IvvJEwxuVNbLcc/BgWtG3L4Qz7Tw4Wh+dh8WCeMXMwicX9ditDnimMIlOoMLGwTt5PzONYzmNkwsRPK+AaEgzXIFeMugxD+QWGIao0qOvWh2jyvudw8QboOnQx7Z1juNAvf1kk/NHzj4HLBSESnk2dN704n+MTUOLklkUPTs8gxXTSg6PBUYkm6aSJvcE+E4OL7/g0ERhlSDM7g51jTEqdfCQuUTmkZGOwYVZT+ObdgAIni0I+aJoSwBSz0co1WOc90pp5nU6T13WdD2pSggy0FfGLlfTw5EX6N3fMTRl8ZKuIKQAAAABJRU5ErkJggg==", + 10: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAY1BMVEUAAABzc/9z/3N/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93M8HRRZAAAA9UlEQVQ4T3WKiWKCQAxEx4py0yKHWBX8/69sLvYA+pKdzGQDEF9UO6JlopKsKXFLJuWX8ogktS+i4FfwKCwWnC0ydV2jVgdneBnxQ21I2NN13cZs+exMyLIs/wRlnkW9zNsLvN/HPuAVmxcTXzyD8TTii18vRvyPxyoPx+ZiksY0abIZcr8fh3EcWS1sF8wwDBhksErkrT9AL42+935V4cZ9MzTBRGipuNGKuEW7HnxrGfBlNFTcJE2QG90BFarKDXoaoIYpqXSiLLEG55Ajz3GIrrMMmVtl3nJiueJK4BBZX6yECxEciD9bkTv7pzhjnE5eV/cH85AQx3kO64IAAAAASUVORK5CYII=", + 11: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAY1BMVEUAAABzc/9z/3N/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93M8HRRZAAAA70lEQVQ4T2WN62KCUAyDi84N3U2nA6eAvv9TrklPey58hyZp+gORis2m9jUvla15w1DaixxcDopFuvOZLECVSnIsw5GSO+VcRjx1s8Qzx3J1F3lE4pbWR/RL3JAXX5dIs1+RsMzwOfrJz9MUWWPu76Xf+cpa5NbYjZJW8BdqacXV5erGJjOOOnDoqBuKgkGGYaDbrPhVoMwmtIrLxUOaip9VLhvlVK9yUpoq803U20PLV1skPkIttbwXGmGvUFX8whKbTi99z1EFljhYRF6BpIdkO1Ur2e2Ez7768ZOtYrqF5mS1/rTjr7uuk/zYUP4Bjc8N01PUGtkAAAAASUVORK5CYII=", + 12: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAABVUlEQVR42sWWIUtFURCEz3+e9orNoCaTQdBiEoPptRdMlmewWLSooEEEQRA1rAsLw2H2ukdu8A0fw9zZOf22DWjH4BQnIlfpKx0bAinF5drTai0N4YQNB7LPtFprg5NLuvSZVuvRUF8DbdjX+jLkxhludJZlH3BySWcjPpa9IMj9b3v6WHYPcWr48E97u5HReO9IrmRrOBHoGiiZsallF+g96E/spaGPZUvQIzBLnx9yXMlOIU5JKaegzZMdwek/6TLjcizbR4Y9M/fSVLJtCFH2V4b8thWyBXq8oTNk+uf0CX1jEe6wyRsiYyoa1Rt2xSc3HEgptKwnHNInr4SNDBiYVbc4o0cQ2OdXMhvrGivxCLJxJJBW6xJX2WUgSNlqrXAnLleHQXo2A53joXc5kbqfrxM8O8WJ15k6wGsw41ppD+9OBGYRB3Idawuf4aTYhP/Tv/oPRYNjeqJKgcQAAAAASUVORK5CYII=", + 13: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAXVBMVEUAAAB/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93Ow8UUdAAABC0lEQVQ4T41Ki1KDQBALLSBqS6WFai3w/5/ZTXJXEMcZs7t53QH/x863k9mgQlUFV1LKLzSxTTCp2T6+J46RNS8vbY5oWyZObsVdjMQqdLSdBZjnOMpskcsPxjRhIlNIU24TRozjSBUj+xSB+50nVnSKrAh88zLcyHH9A7cbYtZgVucPX9wY7dMr6/2Tq+ES9sr8cI0x4SryPUtgyBs3DINDEqFHH2tD7u1TBC6a0IvO7Fo9zjESWSUVWT5ipJZVlYqT92SrC5KscEwkpT1mJxwO4ry+KDnE24qtPg7xmkbWl9j2RUc2JahaijoGdZ2dkskoy9iShipTMnCJfSB9lS7RKIriR1azrf7EA64CFomTQfzlAAAAAElFTkSuQmCC", + 14: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAhCAMAAACP+FljAAAAY1BMVEUAAABzc/9/c/qJ/3OLc/SXc++f/3Ojc+mvc+S1/3O7c97Gc9LK/3PQc8Lac7Hg/3Pjc6Htc5H2/3P3c4D/dXP/gXP/jXP/mHP/pHP/sHP/vHP/xnP/0HP/2nP/5XP/73P/+XOFEODKAAAA6ElEQVQ4T42Ki5aCMAxEg4IgrLA+d1cU+f+v3MykYBvxHO90JpO2Ip+yftMnNozNVNJHsN3Cmlb8s/IV4x9J13UaYS5zMPz1k3Ec6bc8opRHmAlDsMYwsDjuwZp3mzE36MbkfKHvpcfQgoaecL2Kas4X/gAyNM8v4bDuP8iPwrDhn+WikkvAtpQzBJDcHCcIaGX3H44Q0Axrwl4le0Vj3mO+TYh5T2hbPS1ma7vYnNntcFCeFwlNIw2DtouEuqZroI17QhUsVVWxcYko4RIuBeKFp6CLomBbIIfzXKBlVtAKuUyWSTaViH+dIxLmPwcWPQAAAABJRU5ErkJggg==", + 15: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAYFBMVEUAAACxc+Olc+h/c/lzc///t3P/q3P/wnP/n3P/knOK/3P/93Og/3P6/3O3/3Pk/3PN/3PSc77xc4vcc637c3rnc5z/enP/7HP/4nP/hnPIc87/13P/zXOMc/SYc+6+c92hldCtAAAA30lEQVR42pWJC3LCQAxDBYU2aekfSAgB7n9L/MaxMzvLwPC8kmWtnuE90S02myJXfN054edR8a37xaeSuvpwJXXdderEm+Gmd3r1PQ5Z0UV1tMcc5ZAYRTFqHEdC6VZr4s0mEi/LYK21Gc5mph282pib8UhZOo2aJpIiNaSgbdV6UAQ6zRx4CIu7YC/MBvNcsg1hoYI/e0Wu2CEgoIp/JtYtflGsimEYNOQhzuQCupDwjAZpscDMWSRWVt4vlyZMCOPEBOezL5BlM8i/k2Tm7im7jC8TYtyigdWMVqIoqitukxALBr9uYQAAAABJRU5ErkJggg==", + 16: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAABNElEQVR42s2WoUsFYRDE/Z+nvWIzqMlkELSYxGB67QWT5RksFi0qaBBBEEQN68HCcMx+H7ufxTcMw+9m5y7f1sZp1zBZ27pODHTzJJy/GLU0EJwJcUnLu4nWBuFqWdeTgVBJhzF9G9zpRhpyVfaJfvZnddkrCG7p+Sg5IHtApZEck90icty4R767hnv+SGjuy5++xGRyvNLS176+RGyEu6dUdgYCmb02EVLZMZgEsvSdx77sAEw2EXo9uS3bAUF6NumA0JAtwJReHGfGU08/WNBySpv89I49JqHJhHmvZdQzjiR7J7fMdN/UHc49pUxT90O6wWoygcwm7sklXeHak8Ce1n1dK9zXUl/5uy7wmA9GdYqXyWnJnlzVId4mF0tmSfv4cNevfMy1ja95OvAk13/7G/8FSYXbmRbs7TAAAAAASUVORK5CYII=", + 17: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAYFBMVEUAAABz/3N/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93OYI300AAAA90lEQVQ4T32KiWKCQAxEU8CjniDFWgr1///STCa7AdS+ZOcIiLzgw/YNZSklZcE629qYXWd86lDecTgIJjhPMrvO8uhcLvpsmZfcAYNgnvjDKKkwGCN1ZPI3ok8ZBhmgSdBm/Opw6S5BryN93yNCXIMfHWhKyYIb9YZlp2e+Fx7Bubpdc4hvRte5dEw8iHwpdMGw24XathCG1lpLeJWmsX8bG4YGmkzqWh82e43/agVd5HTS1SdY7+be5XjUZ+vgYO63/V6frYODud92O322XlNKp+2Wlpun/GWzoSVliJOsZGXLPMFvRsVXVdg4TopTFIUUkaP8wwMaXRClleZU7QAAAABJRU5ErkJggg==", + 18: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAXVBMVEUAAAB/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93Ow8UUdAAAA9UlEQVQ4T5WK22KDMAxD1fUyOgoFRtfS2/9/5izbSQy8bMe2bCkB/szH6gwJ9qy9H2yYLVRJqspWiDM16poC2wwCLdpWl0nagR59HwzUcr/fFDbFpzjyYlG0bcmmOk8Ohfp0Kc/Kgx3qMX++s+9+2agrTBMmCi9RuhW3m4yfPFQC16sMd/JamR8tX3poagu4XKDlyw6PhXHE6D9HOope+gR8S7ENcQw0dB0wDNTCIAG9KdBpRzp0nUaL/HwuZ+pMg6aBjjn2nJO0zYnOVuZLK20tCzJHKarMMbnCp1Q+ZehDJhzCTWMd2c3tii220st0wcbn3/wCMroQq7mLavIAAAAASUVORK5CYII=", + 19: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAXVBMVEUAAAB/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93Ow8UUdAAAAwElEQVQ4T42JiQKCIBBE8Sg71eyyLP//M2OHXVjQrMfs7AOM+Zvc5Dmb1fiPWNlDQeEyywaZsleiXajrH2rMyUswEWIcRZD4DbzDVqp5+YpdGAa3SFjdCjylvSQ8KPagcI3pTd9TwZxH3F3FK+WGhD3LFVnggnzlbEOTvjNdZ8elS/+IFtO2LBMaTMOFiThKIlUc3PhgFDtOKIpiaw9Fbu5BUdmTpNL/a6m1X1xMaVOKYIsIRcEb0S8gy0R86ddlPju6CeXJzQQXAAAAAElFTkSuQmCC", + 20: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAABNklEQVR42sWWIUtFURCE/c/TXrEZ1GQyCFpMYjC99oLJ8gwWixYVNIggCKKG9cLAcBiXs9yD6McwzO6dPflu/APbARvLYGPNUYDiqGBLLw+wDNBTqTCPdYDS2Gn6ySweAvS6MMxngM4gtKGPE+9os2SFceIZ9OLTMHGHNktWGCeuoWCywjixxqRiP0ycY1LxdYxYYpJyKmvOIE7wM5iSpiiJQ1geq+XEHtpMT5WUS2ILln/5JBZQoJd9ed3/wqLN9FLpYc4rdtpMpc1OTdl5xEGbOdI7qGbn3rvBqWU6Q0d+QpTFFVZ0Bi3lRlpgTq4ucCk3bFkW8gdXuJUb3Hdk5fzBM9yba0/ZfafgT4ljPMkZmDWa0oKyPGcfL519USjZxZucQbKa5IcdNvExiUFeYieT/vRf/Rt6Dg6FjlW93gAAAABJRU5ErkJggg==", + 21: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAWlBMVEUAAACK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93O7wn4ZAAAA1UlEQVQ4y61KCQ6CQAysoiAocsh9/P+b0mu7iyHGxGk7M+0U4Fecvn5cttojSRJfINnlGY+TjKwhF85l2Vye+w+lL8hliW1YA0VeEfawBIZpsSvAHLrZVDEFbsKe+CjJaL8jzSh21Giwj8FrL+jto4e+x9ndu86sFHtD27bqaFq1HpqGmBrUh3gxbYVEzkNd18jkZK8traqKBRsqvWpcFCpoCjtI/nRC/XQ3CR5OHlR6cLgrU3P5SIlS8VwBbjKfiyKOY+eI4QDXK8tRHjFHRzmcHf0Xb0GnC8vPsABQAAAAAElFTkSuQmCC", + 22: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAASFBMVEUAAABzc/9/c/mMc/SYc+6lc+ixc+O+c93Ic87Sc77cc63nc5zxc4v7c3r/enP/hnP/knP/n3P/q3P/t3P/zXP/13P/4nP/7HPKDQuxAAAAgElEQVQ4T+3KCw6EIAwE0OJvZVFcdD/3v6m1Ii7JFC/gazNDQoluwI+V/r8pFJ8UircoHFxYEu1izgoIIcRQvLJCJqH/e+9jYCMvkwcybMPkgThyaeHBU+YoxFpLshb/E/X9mdAjK6CL1IOWt5VSNLyNlKLm2QOr/hYyhgzn1qcVNu8FZ4Lw4gIAAAAASUVORK5CYII=", + 23: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAXVBMVEUAAAB/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93Ow8UUdAAAA60lEQVQ4T42Ki1aEQAxDqyAuLiCs+9LV/f/PtEk7nYeeo3fSNA2I/JfHtqh4olLyWLJT7VKgGvaQ2b79BhZZFh87f7BtaW+RK+453W0avnywihx82mCpKx4Tt3rfokh8mNviHdF59ynOiqvq6tsL3pnLxRZVFCVnzBmLxik5QbATL2SmxFGOKgvVdt70wWNZkTkc6GILFy2zrjCB27lygld9ZtE4ds3zrEbxcvdWmSaYwLFTmNBbVl70BYxocjtSCcRxHHVS8wzyD7iFz8tBNcRXiwNajtL3fXyW3sSuqGu6rpNOoD94aIvf+AYiHw02zfsHZAAAAABJRU5ErkJggg==", + 24: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAVFBMVEUAAACMc/SYc+6lc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93NUC+OZAAAAsElEQVQ4T72J2xqCQAiE0bI0K13XNO393zMGTwservr6YQYGiP5JkiT2pEhTlj0G5OjcXjVP6QM+0rv01DM8duk6Qh3wZvRBJaK2pVblMAhNo1IYmNdrsjEvL1DX9agh0jBnvPfkMaWHJaSqYCggGZcFN5lzkMNQlGXJJiXJvJmigBF8nwewx5D7bNvc1FiTQdmgLa7ck+xPuHDpxXDm0ovltFo0cbzeAqKIonlH+iVf+MQHlJ6d6ocAAAAASUVORK5CYII=", + 25: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAWlBMVEUAAABzc/9/c/mMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/13P/4nP/7HP/93N7+zqyAAAAw0lEQVQ4T62LWQKDIAxEg9pFBW1t1a73v2bJRMAVf/oSJpMFoj9z2Ds47+zLsowfVFUV3V+Z2MGXiR18mMj+LWzuX47NizjPCes3Dxsi6/R9T5KrdJ1Nx2Lbtq0ocH3g7iqYzpibN2A+JWoaKBz7JgzBxcIqHuqGQm3Dau1/SE9hYPCMCb0ZpgPapta2aACDqaeQKIaukMmYnDPP+UmhJScbzno34TiyI+/JMgjDZnmQ8ktJAt2MRDJJvJ+hSCkUFgUPfu97DW00DMqzAAAAAElFTkSuQmCC", + 26: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAXVBMVEUAAAB/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93Ow8UUdAAABCklEQVQ4T52K22KCQAxEY8ULFosiUKjU//9MMzMJl4e+9CS7c9k1+wcf23jYRlaHdXle+eS8aT83qFIbH76Wv0iM6uTN7guMsXc86MdLAvd6IaFgmS+/M0xGWRky6Z4mOAY1zvMZAug4WPLj69DQGibWGXmN0BHMXcqgsPhhgOIamL99CXwqD8bpfUjfy4ao89N1mUCniKvjmLXt+gMyGpRtvD0270yPLClNvoVpmka+MTjnFh9S5W5YVbXa2upwc5v5Ot9XBw5jsKCqJCZVrrI2u8wSzo3CBeqUvmUpk5RsjfWJuyj9KSKbow/1iA3kFAvfopDhgYSKfV57jqsLyR+7nWHmGPe6+5s3NasSULosNaAAAAAASUVORK5CYII=", + 27: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAWlBMVEUAAAD/7HP/93P6/3Pk/3PN/3P/4nP/13P/zXP/wnP/t3P/q3P/n3P/knP/hnP/enO3/3Og/3P7c3rxc4vnc5zcc63Sc75/c/nIc86+c92xc+Olc+iYc+6Mc/SfA0YAAAAA6UlEQVR42q2TSZLCUAxD1TRD0wQSIGEIcP9rIltlu0ixYMH7soawBt9kLyd4T0d1ndp7FotsVK1iXm0um/IbKcWezTJUZXS1H8mDR1hKZEktzXmCuxwrrChiVYj48Od4QWHbhTXWBCRKooX/fJJg08JmAx2IJbEWmzRNgwZKEo3y2xJsMUW/qOwMJV7QbFu0jPCkrXGQK9XDnGO+QK123/fo3cGUKYIBw2COsoziZHei3ADN5HIxQ+0McXWjrl7lXsQ45tEBr6OKccu7MZjEAz7vd5pOlc4kyoe9RxQgJl377G9CfP/gL/0E4wsPcMZO/LkAAAAASUVORK5CYII=", + 28: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAV1BMVEUAAACMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93PYfm3JAAAA7klEQVQ4T62K2RaCMAxEg+KGGygqCv//nWYmSVt49HhJZkkR+QPr5SFjT9tt9BSi83A4YIxwK/FwwlIsG3ERuepH415ZrMbTJNNEg0zMLJqYxxDdcRwj5rt8XOAfEs3krZ8Bf1PSgWmQYTDzu8fBL68k0Bc2isuTneFJyovy0I+m63iNp14/mvQOS3q4u8DvJHeTWxI1xVNx7Tpz6SynGkGkbVsVgaIImpXM5SL6EYb5a+KsLG8FRx3s8g4abAN1Y0zs97o2s1Sy4+5cuDM2mE1ktkwtdQ3FWOfU0Y0VZmWJOVNJpdClMNyq4ref+QJkNQ9tfIdS3AAAAABJRU5ErkJggg==", + 29: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAC0klEQVR42sVXLU9cQRQ9s+kGDbqgMNiqKv4Cgux/QGGuW1P3RMsYVAUJNSiCQK1bUYUBgakBU5qAIE2aPCALm9yK9+5w3uzMbEtJOsnN/Tjn3LnvzQTeOgCK/7h6/yL+qPIqQ+jf2heVZPxCm08aJTax2kglib/aAKeF5oadqhR5JXO5S/iDzvet81nMcKvFXNbksM5Ejyr6SE+Ty7ke+5xl8CbQB1F96BIs5zrzSprYUtwwgN6K6m3bNONLPObEmnlc6HfaoI3Zx3jMyWn/tGfPrTQXQ78J3IrveNyhMVuUBw5hpg2Xi3PG76K/hHoqwH3j3ZoPHvdozBblprHl1nyjMaytMZd7Gwf6VdQMQCe2vPNK5+CpOveOfc9eq1t/flVu3UNH8vzakT4GHTXHFLi0uIf1thrvBT2kSduYa3GuhxIsx4m5pXrPDdpz2hegbsevo8eh3A18k9ethrSdnLlUs35u4KH7AgdAdbcVbHvorsBt003e7b5ew7jOfNZZvxKnF54w8fRatcPUCF4rAWvctodW0jHekHVBy4PrUFSH7dkP6awTccqzvmSpPQDom+lkIUxk8ZMM4aqqE3NtOlnAkwwxnTS6vm9wXn1fdZ+28p1eAf8lnxSAmueYazFmsVmJl+oZ8GvZUwAa+9ji+rXsBYvzXI9ULwdAL+QIq34z+9F4IUfFj8qUNu6Z26N3LuMkcC7j4Ff9Ju6xmLRVvxm46PzbWEwOydxzGSN8kp3IGd77d+D4RM4COZezhleMFz/Lx3IZzsTisVwGY4xrMc7GnBLe+Sg9lquZ6Tb8Mo7lCht+eYZjmMXcJ4fN3IEDuQEAHMgNavRRo48Nvxxia2A8q9foB43hZrYh83LLAdDP8jMUtvwSLE/FW34pcGNdapmG+8zcgR2pdUfqmXOyWgpjDluJl+nVBB9kEizXJMWxOPYv+mUkUv6l7r0Dczl/6foNp356kvBrxUQAAAAASUVORK5CYII=", + 30: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAY1BMVEUAAABzc/9z/3N/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93M8HRRZAAABE0lEQVQ4T2VMCWKCQAwcpRQFKrWo0BaE/7/STI5l1Uky16JAYL9PlikPH4q8sTJsharKnwKV1zXq2kyCN6KUL1k/S1ZJQUj65ijoua42gt6m7/UvmPVcBCt3XakGN+sazbKYJLvEJtzvcip0UWYfzJhnUzfWZV8EpgnTFrb+P1Gmmfvzy/Oz+ZVJliRQsW7MxD3dOEYchoEcL0M0VPJNJnCLTYfrVV/I5lLgKC4XP10Wz/lHV42pdcmc1RhvirOCueuYSV0SJ5PTCRy8nNcSWrRtC6qdotVeB00Dzgb1VjY0R0JflI8qrGIOhvj9wddGXvEpABe+QfogvkRZksB9R4mCgEwB2KajFNgpIIqdlSbK8vIARksSFP1F6cMAAAAASUVORK5CYII=", + 31: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAXVBMVEUAAAB/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93Ow8UUdAAABB0lEQVQ4T41Li3KCMBC8ilDQ1lYQRar+/2d6u3sJ0akzbu72lcTsbaz8SG2FjVig1kKsrqWPaFtfTIvwfEtsHbaFgl9g5yDtlm4P2L6MoSput0QJLJKx6xXjamAorBKbix+7YPVdBQ31zw8EUFaR3awEyM6zzExrdl4eAIjngs2m6eGB5ygmjuNEAnRxQoqaOB59NYQa5IRxHEGGAxqjXV7Y4UAOw+CslhhsGEB+4CBSGKDngjP1PSce2G8yOavJ/U8p4HCUbywIIqiM9gvgdQgcJxWbTYhUDYOKrvPpgtMTxOTtMxsih1Rb04QaTJNjqGO9zpaJMUSoqmoJGUX74SivAv+3z7gDA9MRNMgn7gYAAAAASUVORK5CYII=", + 32: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAYFBMVEUAAABzc/9/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93OndKRVAAAA50lEQVQ4T5WJ4UKDQAyDqzg2EN3GxmBT8P3f0kvaXvHYH79rmqQn8i+qqipPTg3VNVb5ZTRNI3gplF+k4+rgHXPJ8Whu2tBL3/caVE/54djasMiyYDM+YZ5nmpY/X+Q7TYLB1oav2BoLHg+1vEru9zBKezBNtqeJEWH9P45pRm40Fcy5+btps1MwDMI3WFVZA1e5klXny1zKeIHF9ZyTlzMszifMKUpxEfn0xZBP0T5WozWLvIdgvmikxbQRmVs9gIPqAFkNS+xXC7Zn1gvZUTtbGlTGG4Vn0c15NeXIYpfEC8cinhv4BU+pDK9vZSaGAAAAAElFTkSuQmCC", + 33: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAXVBMVEUAAAB/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93Ow8UUdAAABC0lEQVQ4T42M13bCQAxElQTjAiZ0glP+/zOZot3l5Ikr7Wg0MkS8wLv5H1c6VXRdDcjzF8MwSIa6toVsKt5iw4jG7Ng7qkSdYfuTOEioBxabxvyBnB4lznvhF6SR91L5IWm8eE2+SXWRtp6XZcFLi6ckg8L9XoYdZjt+gWqLlgTc1LY32xu1hBHXa44rLRZ1puDivlyCBeNFxpzP6iw25Qx8P7FLpZzqDo7HI0TF1vMuB/ZZbK14+6bgs6i6bXZgLsZ+jnlmNHuALd+WCsuqWf4qppRpkmaCZdIlxnG0jkEjkQkdopeXUnqqt15jrfsa2Dy3olXKSk7GLmfEBwkXRatz3cVbFhxo+Qs8AL6kFPIBzUyvAAAAAElFTkSuQmCC", + 34: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAY1BMVEUAAABzc/9z/3N/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93M8HRRZAAABAUlEQVQ4T2WKC3LCQAxDTSlNgDYtEEiaQJr7n7KW/NlleNbKkmdFat7A00XkXafKVOmgkaZp7NAYWbgPOnIwBCrN+aJKeck/eIDJLijR5BIhU7mAdV25TACJN+NPh1tD4CdjWZZMKAtDzeOR22Js567zlO7lQmaZ5yrN3PWHSabJA2SX+sMvlRme3RhlHDPCxuzGgBkGy4BefbjpYN2gOHg0rtfc1fiR9H0Ejb05QnLW8XSmfCcn1anK2rTHRflOU9chuvJDR6Mjd5o7WH6QT3tYTDpUcvQH9znCk72/aHtT+dCGtS2FoYKPNK86VLCrbEcDdiHbNK9bUF02aV43Bso/hzkUeEIRr9QAAAAASUVORK5CYII=", + 35: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAXVBMVEUAAAD/4nP/13Pxc4vnc5z6/3PIc86+c93Sc77cc62xc+Pk/3PN/3O3/3Og/3OK/3P/t3P/q3N/c/n/n3P/knP/wnP/zXP/hnP/enOlc+iYc+6Mc/T/93P/7HP7c3oPWIfAAAAA2UlEQVR42pWI21bDUAgFMYmnqZd6bWLU5v8/UzZzFry4lnaAzYD9nyf7i1N0nScueIyhgU/xUC3YBNxrVCiU3tIqJEDgm67gGwsu6osElUmDmwiSCnR1hmHITal5wmLLYkZrlFrJWXXWTtDkORPw4sWgHnoVbxHK+nDBewqpYcG62tqtgj98WAqtITv7vhOeau7QZBx9Qly9R9Q606QImdgKNDkyRy8MTeacOc4ZLZq1xoqrNTw5eMU+1EXCnRc7wPWEbbOtm2v+0j9Vvxp8eaWqSqB41Xhdxw/qiQ1CEYuM5wAAAABJRU5ErkJggg==", + 36: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAABU0lEQVR42sWWIUtEURCF/c+nbbEZ1GQyCFpMYjBt22CyrMFi0aKCBhEEQdQwXhj4eLzj7GV3wf0YDuecO2/y29oku6F11vqchHKI1hBXZRpKTQM0qWsxD7Up+3V4Co20fFqZ71AbPGOvyxCfauOx9h5r4lWYVEw3YkriQTlETCf6507cynX0CvZk6sRcQ4PPiPdm0QWIS6E0Oc1D0VDaKYipPKJpRtCj5cE4UyqGHp8GbKe4k8Sx2uCb4tHKoDR2M/OBmGzoUbCn+g7Ejtpg6PEY78sjEBO5jl4dnvpHfjQZKX1GDFhTnIJ37bkOY23qI4t51lFqDj0UTz3udD7UNDRAZKfPjWapbWhQGqIt1FzpOrWNl8TKo4uY6d6bLFHfR9OUXOixjZfmuws1p3oZ+lFc7ivnUG+YoUdLWPMLzr4+hjqINb6POtv6+kMLuh/+3y/6L6t+UUAhfw9uAAAAAElFTkSuQmCC", + 37: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAV1BMVEUAAACK/3OYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93O04eAhAAAA4ElEQVQ4T72JSRaCQAxEo4igMog4gHD/c5qqpKHh4caFP92pISI/s9vFKUmSOLKIqyOYIzK7kE+K7kXkeFUUhakHxMIH1DrcNT9k6mFHHW6VEdgZ2GmAHTAA3oR1MG95K1yBcCC99EBcuHu/iHT4HQWho4f6TeSlgycvLG5UlshToZj3UtzIQx76oAjc1s/+rrgTN1a7aflm2pbRBdxu85XJimU90TS+GroNrlcXU6eKXIVQcUeUkStJdASXS+Q5K87KuluS59t+IpMsC1b94makfDCpmzUHfQTuG3vOn/kAenMQ7xDT3O0AAAAASUVORK5CYII=", + 38: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAXVBMVEUAAABz/3OK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93PP5IUTAAAA0klEQVQ4T52K2wKCQAhEMSsrtexiN6v//8xggBbXeuk4wMysRD8pWEVeBmY2kQX0LSgrKIWQlLqukw+9s8XItpCxD7IVLnhh6fbKDdHzqUdkHol5YDHWapEYBt0DwUy537HdTLhBasxFbnTlLaPHXKzoYhPWyNAZi0kpGDm9d0IK4npeJ+hD9MYRijHnAIU0pmN1WZE8h13IChqv+bat2uzgWmgaHZILadSGaKOzSR+j73hYk40ZSD5PVFWV/69UJIXPlCXEy82Uebpuf1CWefMHbxpFCkA3babPAAAAAElFTkSuQmCC", + 39: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAABOUlEQVR42s2WIUuEYRCE/c/TrtgMajIZBC0mMZiuXTBZzmCxaFFBgwiCIGpYhYW5ZWfdO95w3MPLw+x8c/22NoJdAwMzwzgnhmgPMQePMjUwuBliP87cEN2U4zwZoj0sPMC3IZ1s+p5nh32CL5a0nPKrBntFzH5qr0EHNfYAtwYOmPtxjd1C7cGzBs/iCpuDTsGz7ssxnbFLqHVTloUVm0LtoYEbsWBnUHto4Fgs2DGSy7P5lJyxA6g9cJBC3IgF28F/9sdlKmsrNgEdg5b9gM78YMJAa1DXZ8k79qJZxkxrH13zjCN1PJuvyTV3OO/Nt2TccIMZ7YHN0pLuuMI1HU827HVJd8xwr8EzG55sJLRc4JFePdAjnOLl7xXNGId40zc4U/bxEe2hgZuFG7bxFe2hJy7ptf4z/wV+Y2YQi/bzUAAAAABJRU5ErkJggg==", + 40: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAY1BMVEUAAABzc/9z/3N/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93M8HRRZAAAA8klEQVQ4T22KgWKCQAxDO2RDZSg6dCoD/f+vXNP2ypXzpaRJDyKnqqqlvKPmqetUQHimhpoGy43EnD2L9vhkkIG/d9R1tlXSSJ3ps9D3XvsUfsSSQ8tBePG84BohDJP+eD5hkkR+F59nbbJmFWa2h4ln0g2fLNgT0R+LXZd1loA+QuOIIEjXoDxUj7La6X4n1YJ0xg83uvFkf8TG/LIw4RS4XmHxFJpyuYSWl8Qw0OA5f1g4n8sUOXk4eYwc02JZjhzEDghQybd9bFBJax+1re6CHSttTSu2MhK2GlZ8yUjQveJTRmMKOZsNJpX8xfhg8v4PH7gQS6CFYBgAAAAASUVORK5CYII=", + 41: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAXVBMVEUAAAB/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93Ow8UUdAAAA/0lEQVQ4T51KWVbDQAxzKFCWQNrsIaX3PyaWZCcTvnjIsixpxuwfeCA3PBV+r8r2RSgbzKEB3omwOvn0CWyeqt3aK5bIAF7RxY/7vTBi5DT2TcAk5QvcsDdcSjQl1nV1MQrIPeAL1IDcI5bFFhMXxN/vjtnmGZKJmKYJ62puICBfqOM42hgOBlSmNxsGGyIzJuUdfW998cGLqESzrrPu8IGRpfq2tVYPcdTtzeXiyygtwaZprFFsHLxKaT5Il1C/cFlbLdY1ExvYWod4I7mR2fhE9eojyazdztlHEkh/dvh59tkPIQfFPvrshzZddCef/bhxd5KXVpVV+0nh+Qt+AOo1D4jhBpY7AAAAAElFTkSuQmCC", + 42: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAUVBMVEUAAAB/c/mMc/SYc+6lc+ixc+O+c93Ic87Sc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93MzdOcoAAAA1ElEQVQ4T9WJ65aCQAyDw2UVFXUVRJb3f1CnSYuzoOf417STfskAX6F95i91PIa91TRNmOiv9UeRll/UONpidF7rnvYOG08rDRgGcw8r3dKYi3ET/VPfow9kjOTqVoCuezKutleCebQZJ10Wl3yJ9Lu4T47m7K7rHYOaU5rkZopesmVo9WOnRavkQT84cLgHElm9tMNOKzY3c6eapuEzgp3MqO1Wz9DJo7TRbpwNTfP/TxqeMG9ddZ1BPae5rypUAemJmXVKlKWgdFj0oaJAkUfOB3oAqpwJMoJwqbkAAAAASUVORK5CYII=", + 43: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAXVBMVEUAAADcc63Sc77Ic86+c92xc+Pxc4vnc5z7c3r/enP/hnP/knO3/3P/n3PN/3OK/3P/q3P/t3P/13P/zXP/wnP/7HOg/3P/4nN/c/mMc/SYc+7/93P6/3Pk/3Olc+iCukfpAAAA4klEQVR42o2T21bCUBBD0wJaRaUoKlrx/z/T7VzWsOYB2Mkk6XmvbmC300U+zPVp6Jwnc+xYXsmLGaxqFSck6sQRsQkFP0h19RhTC14WH5UUdt5xDOiP8IlieQILO6+gTr3pDefKqIaDalocqgR7dfaoSrM68+xvUc/KKviq3Kqq2BoyHsUh8KxFwIMfjqBwHEzC00SJKOwJ7uoiCcwhuLfzaNN7yOAsh4EEWzBqHEcfisJ5sFoJCQgrzNHBei3E4MAnKNlshGzhf9T4NdlIZXW+7VBW5wvkyuocj3J5Xf/3/wC22A26qn/gEgAAAABJRU5ErkJggg==", + 44: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAYFBMVEUAAABzc/9/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93OndKRVAAAA9klEQVQ4T42Li3KCQAxF0xdVi4ja8hAo//+XTe7NbrM4znh2N/ckAZFnedsOIlVVadHzmP3eruZ2Aepa9NSIe058J4Buy+XCS7ZbY131Kmaua9z/Ou4+jF8syyJ2cNU5DB/M88wMzo5MeqyyTBPMmmy3mz4kgFvLjcgo42gxmhj+HxJlGAYryMHwL5Aofd/b0+INSSnSdZ3YTQ3Fe+UHUNHkBeNbrwIzMcsb5YqisF7FjFDOrIk8ybuW3gJ0rY9816Suydo0boijTwPHNGN+/W9IHrgciojmsisiWMrPB5nlI2R6cS7yXsRdiryWUbbGS5HepaH8Ab/CFF+8s16uAAAAAElFTkSuQmCC", + 45: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAXVBMVEUAAABzc/9/c/mMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93P1NtDjAAAA30lEQVQ4T62L6WKDMAyDva3H2nEVaEeP7f0fs45k54Dyrx+xLClB5J1siWxXX3yDsF5c/kCUtAqapqH6asr7k5Ltk2fnH6xn+QvMYl48QPbDY9bcA5JzL6oboGFh1c0eXAN0cqUa9mAKuKVMU1bKb0AXgxcswUVRlcTFsHhWpOCMLrajQuMPRpaeB0UGuDQDWqPv+6A+SL5A13XRSaLDAW3bBoUTeA9GXddYtAi1SFSlwuFUFSvrjKN+WDFnwTjglK5gv9eRNAt2lJ3bJRvIJtoFXzjmVvjMZsmHfljc5AkhvxVOmEEEgQAAAABJRU5ErkJggg==", + 46: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAXVBMVEUAAAB/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93Ow8UUdAAAAxUlEQVQ4T5WJCRaCMAxEwypuICrKIt7/mKZJ0zblCfrTTGamAP+Qpl4VBWKOuMJ3hqqqwIxxIEoVZzjS8PMiNVLTsEBd20ZqQ0sDrVnwjkrFGx9CJmImmcnM7GwpvALVQZjcmXRjGZ0ZJbmKGQZc8TZH9D30bMgvebI8ncY85NmwpAtPt/y/BypHcfsamKuyQXJccPg6q2ka3MDHnFcjclqNAIetYr+RYSfXGf1f+lvqRshzUe9CsgwyI8vAJGaSIFMBP/EBw7gJ5s6TEcgAAAAASUVORK5CYII=", + 47: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAXVBMVEUAAAB/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93Ow8UUdAAAA30lEQVQ4T52N2RKCMAxFUymURVRwAxX+/zNtkzQN1RlnPDZ340GAf9jlQ1mWEkXTBnXtL5UaRW1dB5ouH+BwkCQCOg1DDDCQiTPr6g8DSyrMsiyqZJ7zyvyDp/KYmYeI8g/mGWYK379PE0wQHp5w/5J0FG43VHx4GVcdVWEul20VYc4oZ4mswqh9hDF24aTCiWTLUYej6kTfpwg9mWbPh7bfdKLFh6nNBqThC4reNHEgHItz4LA4F1ekCldBRSHEOBHWP2vJabDhAYmnKAq08ONMW1gCRv7LGDBcjZp/8Abjgwj10KYCHQAAAABJRU5ErkJggg==", + 48: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAYFBMVEUAAABzc/9/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93OndKRVAAABDklEQVQ4T42L4WKCQAyDCw6csAkKwsZA3v8tbZqWw/nHwCVfciDyng4HRrzcHFSllKVTAtupEw5M/eSwXai+6AyffDNvYm0aFFhMzGt8IFeih1+tUaB11b6miXRnYdy33Ae1LIssSCN0MDXPs1lSbLz/U5kbmQvcf5dJJZMR2HDCjI75V6UOAoOswKAflWU67OYi4zj6lwpAeroYhsE/QA72eCfcbt4VnyJu+t679MraooOhrut8cfjfLxfvCob7AWrblr0Vg6gbnM8+WGrzYdvlO9KBGU1V1/U+9+6q6FVlhhCzpE8zc6bjs476mB+RryqKIo76Xh901QakuMxzs1yQMBsoYAbIMryAhFT2AOtcE/bcCsziAAAAAElFTkSuQmCC", + 49: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAYFBMVEUAAABzc/9/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93OndKRVAAAA/ElEQVQ4T5WMYVuDMBCDbwgOp0xQNtiY7v//y12SK3T1ky9tcsn1weyfvIiyXnldKTfiLaPcgY8ND+XW+UxoLNf2lUhT+eAerMP9ef8baGB+fvAj5KZDbvHgRmTU2CzLkvwP6K9+rvEPxBxVFz8XOMgcCzDPMwROWOmKyaYJJhQipid2PvshHNWwwvbENycC2zq00HEccQM2KrmLp/ZNYo6o3mUYBsqgPUOqkfrevadJDRfGYMcjxD8eh4Iydh2mjurWcUqeerP3wIdoUFEjHuzgQEySjKPTttKWohRlsMfdQzVwSpk01jRZUsirgrquZeVipaoqWtlv7Ha0B3nlHfG29LsBAAAAAElFTkSuQmCC", + 50: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAXVBMVEUAAAD/q3P6/3P/enP7c3rxc4ulc+jk/3Pnc5zcc63Sc76+c93Ic87N/3O3/3OK/3P/wnOg/3N/c/n/93P/7HP/t3P/zXP/13P/4nOMc/SYc+6xc+P/hnP/knP/n3PRXC8eAAAA3ElEQVR42pWTSQ6DUAxDDbSFzgOdGe5/zEaOlehvKvH48XOyBws5n/GHa0SuJSfYO6nLBUd/rEeqpFW0rT2LkrquXR7aANH3vTsvxXa/ywqKz3m/Zcl2Ki4vyNKLLfx8wqFZDOTlAoSTvD3sI5KWR9yqCpDoyMowY8bMFFxmDbdp4gRT5kSNGEeAJYchmgZNNPBxghVWUTkUU6zXWblKee6yeXadNRPEFtE427DYIRtjx6TIAdmyI+veQ8OtZPAcBq38CjaQNy5+Bd+vbHiBO/k4sA9/uOFmb9n//gMHLQxGymFv5wAAAABJRU5ErkJggg==", + 51: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAYFBMVEUAAABzc/9/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93OndKRVAAAA00lEQVQ4T5WK6QKCMAyD530j4oGKyvu/pUnbsa3yx69ZmhRC+JMZ8Lec5WDjbNR1jbBXwt5/iBzdzmiaxlye5Px73+OJtPLAW8kH2OL2vN/Rgpp44gUBbBoTT4nO1HUdnaXkiaHRNfk/wgMjFsdzx4hhdHnatoVRmNZ/Bbc8DCVxFfmYcRH95oEzJuWsGCfRWDHqUNd5owqqKlQxSo0t4yBjYYQdtRvSD1vTVsRcsobWsnWogpUpDlWwoMwsFMyhOVyMW06JKcRHl6AtMQGBQowFRr7g9A37Am5hkAAAAABJRU5ErkJggg==", + 52: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAY1BMVEUAAABzc/9z/3N/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93M8HRRZAAABBUlEQVQ4T3WKDVvCMBCDD0FgA0UdDJju4///Si9Jr0+7R99ec0las+Alu7/Z7aq0ymaHGjtEk3+0bfHdWk7NG8VR0lrzQeiigXQp0HUdo1RrWZb4sOSkimG2eZ7jBzyCl9LZJjfTBAWT7BTD64zjmH7kMFpRgZ8QmqQ13yT5+okMmGEYYCFrnlIA/1TOPB4cGEdV+X7nuNx9nChF3/d+6VLk1oNz4xDtGxZt9Ne04eCvNE7uM19+arPiM4Tmfy6cxHtCwaMLyvxBnM/UFMoHrZMfKJedpHS01sRYA6E2Lg3k6Hh3NCkXN2q92Z6nZg/wBF5xapTxZNuYgi0iK/UbPyXK7Db2Cz1MEo8D7vOCAAAAAElFTkSuQmCC", + 53: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAYFBMVEUAAABzc/9/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93OndKRVAAABC0lEQVQ4T42Mi1KDUBBDV0AUn9gib8r//2U3yd6L7TiO6d7kJDia/U9lWf411HXNR4qIgWqaBs7k+cuz6y2dP4IQALJP/+ECWFQFJ+cTJKTAmhz33Sxf0rHtdjGcGxyWgR8utm22obgJN2TagCvP3yrCrTExbOH5WxYkQwPDNc82u8PAgbPYJto0BaSBk4Zx1P8ZeXekHIbBjRDHyjmp742//galbwjJ55iL9i7+riN1GlQA6TN1Pt/mL/rKdqhtI1rQ4Wl2+4BY5RHH7HqnPFmOnvSaghCRZ9eLHwRAU1GjnlMQIvLsevKDAGgqatRjxH0qzKoKr0KkgUVDURQw4o/Txo/Sg8udmBp1BbnXFiTsZUE8AAAAAElFTkSuQmCC", + 54: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAY1BMVEUAAABzc/9z/3N/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93M8HRRZAAAA+ElEQVQ4T4WKjXaCUAyDO4e6saFMEYfiz/s/pU3T3gJn5+wrTZNcRJLVKvUvqqqa6PJVZBvQL5+l9lPXLhGcRpomLHATz20rLSSSWSo4Hql2vCFMz9IHaJ6KxweB4z7MoOcPd/vkrpSIEWblpoNjimgNj3cy6jemjRmjVK5XvxQfbS+aL8Ce/WiLwYPIoAMFw1Acx8Kv71I5ImffdJHOZntLfV+cLxRTOJ3C2AfRKa1I14XxVemyVQ6TS3+wKfxMjPt0M/b2ZUh2RemS70XwnC750oFynU8XuzS0Uc34mOjckQ12w0sx1uswFozyKPJOYDJZYdXbP7wA1aMTPk/+oA0AAAAASUVORK5CYII=", + 55: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAXVBMVEUAAAB/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93Ow8UUdAAABBUlEQVQ4T5WNiVLCUAxFr7JZWVygSkX4/8/kniRtoY4zevLezUleB6S/8ThdTFksppsbnuKSv7BeEyLpP9m5nLvMGCa8uYj+MN5zcekCJbQ7zoXO4iht4Dug5XVZbj7QqejFG85p/OKL4gytFuMn0HVdRheBk+Y4FifukTUzfBbiMOVKDPnjH0DiMfar+vekbdVGt7WM/aI46OCTZh3HZL/X3kkweebWaN4Dd5HZbeHwCk4sWu2UqhfIXldRsTRbSE3fKmpYbyDfQzd9r/Uz5DuCR/b7phEFDeANGimtVlr5LW84x2LCly7RwvC41mXsNHeRafPSOYKZmWuQ0hhnN0PyEPVPrqlgGew8GT8VAAAAAElFTkSuQmCC", + 56: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAhCAMAAACP+FljAAAAZlBMVEUAAABzc/9z/3N/c/qJ/3OLc/SXc++f/3Ojc+mvc+S1/3O7c97Gc9LK/3PQc8Lac7Hg/3Pjc6Htc5H2/3P3c4D/dXP/gXP/jXP/mHP/pHP/sHP/vHP/xnP/0HP/2nP/5XP/73P/+XNcoW5xAAAA50lEQVQ4T22KCXbCQAxDTQul0CVACA1tk8D9L4nlZcbjx4+lseQQBV6E2LSs19Wfsd3yiOWLsae9kPvAl5LrwoGB577S99SrM/kI7vgq+Uy3m5q8FiPLsqjJLOnKzPOsps+c7zRNE8xWSYn/FFMm+oNgITf85piK69UsTmDkGcUQRmSR82PyIHspiC4XFolVqYFhGNh81FzgDInproUJnHhO/tpSBI4ysCPQ5KXQdeoOdZLKXfmGGN0ltT98hpVpG/AhViB8DbsGxHB8L3gRjm+FUFING4E2lkrti/Nqrm8pKitzfWvzACUgEugkOBuPAAAAAElFTkSuQmCC", + 57: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAYFBMVEUAAABzc/9/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93OndKRVAAAA30lEQVQ4T42KgRaCMAhFSSvLsmamU7P6/78MxlxAek4XeO+xAfAveZ6zicWyp94HXeQIxwjGRc5YX1vkeuVZ5XbjWeX95lnh9dJueRLJfpmmiSbawsGD+oFw+mGEcWQHSqP9H2AYQM5gDnroQ6fQ638P3ntWnxZJB13XsQE5m6CFtg06S1DBPTSFu95nGmgaVCH4JKmhrnEw1GIROHCOzEEKTh1csC9R0Vgl1axVJRbBCUt1lETJWpZR8KFUBwcs0wd1AEVBU3AseNfsdthhgtnvwHar3ZJlmQmaDWIT8gGsdBCG5FFiIQAAAABJRU5ErkJggg==", + 58: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAhCAMAAACP+FljAAAAVFBMVEUAAACLc/SXc++jc+mvc+S7c97Gc9LK/3PQc8Lac7Hg/3Pjc6Htc5H2/3P3c4D/dXP/gXP/jXP/mHP/pHP/sHP/vHP/xnP/0HP/2nP/5XP/73P/+XMExvBJAAAA1ElEQVQ4T82K2RaCQAxD6wruwyao//+ftmkGCvrkk3faNMkZkf+iKIplFTkeIaZfuYxmdHNe3OkseOo8J//J4xFD8GSQYRhC+qCXvu9jXHKXuxLznE66Tjc2MYi00ra69OyyUZrGRhoPUw2tsXVdw+UmmKry0WVfYdwYKSWsJH5IdLw3ewossMYvuF51VMx6QeNJ5AzcZoXxpJwUuqwwLCOHLL6IkbLkwS3FY2A/KteLkR1155YnsKXa5XqV2dhuxJ6P34l1Pmt4DDuyArKih84+/MYbwf4JdQi4BMEAAAAASUVORK5CYII=", + 59: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAYFBMVEUAAABzc/9/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93OndKRVAAABGklEQVQ4T5WM2XKDUAxDFRKalGylgVCytP//l5VkXyAzfalsS8e+DMA/tF5z/nx5c9MKpE96Z0VIy1Pq4MLhICunQtRZmkB4Ns9/+HRnBln5/EPRTPOJlsu3ShJH6oQ8Uc8QnkQu5YSlHppHjoJgfPj5ftfc4ZoY4QvdbpygzBeN44hRPorVs77cNEMUUIIahiGdqR7UuVBXCjNdlbHC2bPU6Ps+R+3dia7roDJmi5Fw0VzCTZdYPShqW7QOQZsnb9RHKAhuLgzMOuFEFcqb4FS+OB7ZnoBii5/s926ZtomkpuE4XFrDm3jfUXZkl2UX71vNNpyLaJsRH9S2uobbQzOmNhsOyyg5sFTFruiyqkT18slqBZZUvLz8ArEgGg3LbPdYAAAAAElFTkSuQmCC", + 60: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAYFBMVEUAAABz/3N/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93OYI300AAABBElEQVQ4T3WKiVLDQAxDDQ2khCbQHC30IP//l1iS98hM+xTLsjZmFS8P0pbdzj/Mpn13lQOkpOoDKuSLb/SDK4Oo8+Co+3IpOBHSrYexWjCfcZTpaa3c1jUFROY/F5cmwZrF3SW/Y1WNLrNbMoZc3XJxTXOFq2KK8+KyiwPXmQvyCwFEfIZY8+Ofw0hHU3PmFLczPXOisO3kCWzebaFs4Sxs6IUZE4Y9z7wKUwkeJ/cpV+DoUjjiUxMV+XbloJgrMeQ12KBjSCXo+147Plxy8UlFSI4ddJyOwXenFA9g77I9pqx4EC2npbU8uBjFG1U2okh/NE0jbwwhOli6wKvYnvUPT/kH6sQSj94TDLQAAAAASUVORK5CYII=", + 61: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAY1BMVEUAAABzc/9z/3N/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93M8HRRZAAAA5klEQVQ4T3WKjULCQAyDO2EiboL4B8IQ3v8pbdLe9Vbn1zZNcycCHqiJJlyvwweRbrQWiPhZa4GIX9iZNn1lz5ll7z4NKbr7/B/cMBC7eMar8kOhlu1H4cq5Ej+CaZpkEnRN0Iidi1yUeBe7Izmjz4qfcMwK32wzjTVDTo1pfeVIoYarJ/jSBvRm6Cuf2nlmH+SDnVbLG0YpymDGoWg1if2fTuxQOzra/C4yjqI1+sqvYBhk4IZbYIveKuZanrSwqOE8FnkEquo8QOax0jNU7XvzPVzEKy3VFRU7BfjWdZ1YwUOs6H8BLvwPLS8WjpMAAAAASUVORK5CYII=", + 62: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAY1BMVEUAAABzc/9z/3N/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93M8HRRZAAAA90lEQVQ4T22LgVrCQAyDT0RRNhCcOmEM9v5PaZO0d7f7/GmTNDdS+oeNzaYta7Zb27ZMuzrv1jfY7ylUnbDC4QDRwqBy53SyVSpB7gzD0KYhRSWWJS2mkGiqDB6VKj6qw7jfqauiXPNsM7vnqnC7YYkO00QT0ySdItgmRnG9hnsywy+4XCCrZIGF+HWhw6JwxlFrikEavRA/HC0kisI3h+tnwxeH62f9BD453GJ1PmvPcD+diB9amAlNfY5H7hGmw2vEnrH36UH+ALHrOmZaR5Iavb2D/I/I3uB8I/FBBDlfXoV6N096eAniKSevnzPWNYHHU6HOmT8CuxEygH4gTQAAAABJRU5ErkJggg==", + 63: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAY1BMVEUAAABzc/9z/3N/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93M8HRRZAAAA70lEQVQ4T22JgUKDQAxDq6LTbU4UHLIN5v9/pU167VXgXdKkPZHKI4eSbqRJqW4aPxR2+pg7JoYdnD3l3uOhV96L/Nkp0UrbqktnscXppOs6BDtW68EvpcZjteHc715CfjHmefaGhfGPaZKpZL1EQ73dVDoSvtj5qq/OasQV5aK6YEWhrGPyY0QdR3g0+5GbyA+7BwoqHTcwpDIMXOMkcj6rvdvAy3zrwzTrtEOi7/uSvqdP8BXEnn4/+bxb+A4+9EFemStO8MnMZclRdfSy/AQH6MC5zVvSFq/mEhu8UOE1z1TNFU8Ui+WCBxCt3v8AiZYQTX4fMY0AAAAASUVORK5CYII=", + 64: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAXVBMVEUAAAB/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93Ow8UUdAAAAzUlEQVQ4T5WKWQKCQAxD64Ybioo76P2P6TTplIrw4aNNkwwifzB1+i9kMWid1Wo8KVsqCIWz11VBgMmJHDHj+W3H+CrBK6uPl6Q1aaVteXMJmqZR5WfH68QTQwfvydwDQwtyyP0d80vX3zB9QntNc83OBA2dyEXnQmOZhWU5Y9TgULs2Udc1DpxqKI2Ty28CB9vhmKi4FfAY2VHsZAmUtlKWIUQ2uobFHuvRYCyXw94pigKnsz3mHDvhYQbSgddIwweRCX+buMuJMZQjfABO6A2D7N+eYwAAAABJRU5ErkJggg==", + 65: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAXVBMVEUAAAB/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93Ow8UUdAAAA3UlEQVQ4T42Li1YCQQxDg4LuKvJQVB7K/3+mTZvOdFfO0VuapJkF+Ad3WhppSe8rYsoYRaY4B32HYRigYVSDZ9SlKhueNvmjbJJo6MDe/2S+5/IyiaC3a1Cypyb45lLcicpU8tUD51eNS0uTs9fnoiW0AqcmYRFVGMfUo0H1Jlrns6gao5wfRSdV8l5UnkdwkB0UeiXe0guTD/AaGlaaxm7nOpkZW4I22/k7XnzrzFj7atZxV55CDZNedMa0cYyoovHYLaKK5IGYec6qvC+r6SgBuK+mowRgIW5df/EDA+MOWqP7gHgAAAAASUVORK5CYII=", + 66: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAUVBMVEUAAAB/c/mMc/SYc+6lc+ixc+O+c93Ic87Sc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93MzdOcoAAAA5klEQVQ4T9WKAXqCUAyDIwKbCuIQBbn/QW2avuLmtwOYviZ/2wd8tI4v3Pd99rZLXFew4L4SgkOPx7tZ+JMWLIs7CEvZJs6YZyVtVsZBcGfdCU7lnnyzMr/xWdNDugDTlCsO2zTB+WpFL32l9EMnjCNGOo2Ddtz6Afix8hB7OsfhwjKFWaUCh2HAIHJOJZ5lEZuSu47dKXwR+/IBOJ0ySJq2BA5ZfGEZ1HcpPjetFdJX9Mv4a9Oq2zaIHmuqabIbn4kkn4DaXu3pYa6x5gXY762VDMsAKCtW5ckQeFY8ATuvd/23/6Mnpp0NmhaYiQQAAAAASUVORK5CYII=", + 67: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAYFBMVEUAAABzc/9/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93OndKRVAAAAwklEQVQ4T42JhxaCMAxFozgRFdko6v//pXnpoA3jeN9I2hD9SyJJbElCDtZjwSFnGOWX6JyxMxL5gc+RuwRyQxJQFAWJ3Cii89cU5Ib9dHwYlN3NW/MWuTFhGGC9Kl7RmOPpa4G+N1mko46tf0faduwZmoZj3OgbqKmuyaXWV6aiysOPCSVSlrbkGfMQT3dPzs4Jksr1nW4iTL/GXL3cUFyseHOLIk0pxYBTbHOcpKTnOAZZYM+C19jpj5AtC73KRr1//coNRg1y/a4AAAAASUVORK5CYII=", + 68: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAY1BMVEUAAABzc/9z/3N/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93M8HRRZAAAA4UlEQVQ4T3WMjXqCMAxF4xTYVCaw+bupvP9T2pvbtKnAsSS5J/kUcXwossgmsnjQNE2qs2y3vs3QtqK/dumg63yb4cdYOhjHMdUpz5LJ/jGh3N9n8Pt/YFMyef+nxDmrtL8R8RTiSoqDwlxAqG6v2cSZCB6FjlDkRNCRaGh5cCTWfeLBrxJbQmB4MAyD6APMOjAF+kBsfRK9pCgHEGs2kvM30CpGKfYAVTIU0ewAqjugiOYLoLoDCjOfARR3QGGm1q+uawuhIluQSr8qYH+AsYobsMZbA0ZOfGS1Cu8NmLB6ARQaHQuYuoSOAAAAAElFTkSuQmCC", + 69: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAWlBMVEUAAAB/c/mMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93Oa6C5yAAAA7ElEQVQ4T61M2XaCUBCbSmsrKpZFLIr//5tOMgtg1Sdj1rkcRd6NT+D+GPgmYYz/KMsyyvIhsVfunY/wO5WsC1yzXMElxlHGWZfZBC4XisGNieU4m59BBp0ihvBhAFVZ7IM/d8tpR5MT7cTIPb/0PdRLHzvD2lF5pNsDu99ZulDntUPQWaSFWoSaF0u8KBpl0yBihuJU1zU8lp2YdjuE0nhV8CxSpapKE4LFWWSnhECWHZxpfybbrdiPA2S1ndgoNzB0gnXCD03h3esMa9payZbp+FLQY2hjdxRmBdNmUcRSrO5K7LzLh+PZfoEbY10P39byP/0AAAAASUVORK5CYII=", + 70: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAXVBMVEUAAACMc/Tnc5yg/3O3/3P/enP/7HP/4nP/hnP/knOYc+7/n3P/q3P/t3P/wnOlc+j/zXP/13Oxc+O+c91/c/nIc87Sc77cc63/93P6/3Pk/3PN/3OK/3Pxc4v7c3r40sIaAAAA8UlEQVR42o2T23aCUAxEQy9UqoUWShVR/v8zu5OBlcXxxZ1J9hzesWe4MWsjN575Fq8M8UZlnCxvawDFqGlhnsmsikmgklzJlQDVdNlkmiaWE2uPXC4sQ6h7at+6xtEUJvkAY6Jr+bDjx5fZKmfPty9DVEtaa1tulpIvxkV0Sk4nSfFnwfEoRSFoR9M0kgobTg6HuIilYZS8g8vjLR0sy2JGUAxVfeVu9wiFE6vCCV4YIiOudzBxZsJnLInNfyTMDWGJEow2jogDmCLcyTAMKnsnfd8XpaCzrgsHtueT+KqvSaqKVFG0Jm/8klC+5ad+/X9yOhC2UA2+KgAAAABJRU5ErkJggg==", + 71: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAY1BMVEUAAABzc/9z/3N/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93M8HRRZAAAA4ElEQVQ4T3WKi1bDMAxDvTJgjDIKYw/oePz/V2JJjtO025VjST4xa+i6rj3MWMe7xWNjV9hqy67xgoFuMdgwyAy+YJ+2j9jyx8kUecKvC7u0hh8XR5anyrerpHlwLi6FSwQeJ4zjtBnbKAu+XLRSJ8Xs04WJVUIWs3O+M6y28uHkwtTOVi9HzLF+QORNHCh44aCSh48ytecD7xy+POgYpzc9TdAUe3VhfGmzMIrdDiuynp/ikPRaYdb3TMmzC5sPtuDJheGit2wwm0gKCx5c8ggz7jm1zLnL5VvesAplLPwDWcQLobQoBAoAAAAASUVORK5CYII=", + 72: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAY1BMVEUAAABzc/9z/3N/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93M8HRRZAAAA30lEQVQ4T4WKCVbDMAxEh30LtLSQQFNo7n/KajSWkU0e/P882oxLtGY0XydbtLtL9mj3mGzR7tlFSW8q2m1d4rk1yl2XvVvZO2rLW9xgWfLE66koTqLe2X37Y1otxJ3NVwzsC3X2PNb7MfjZ1E7M88xnucrBwIHFcoVPw8NrfwU+DA8rsK6/Y5omPsIJzMw4jnxEc3N9J1HZsG9+vJmepGzW2GFH+nXllZJml9n427AkXtzoIuMGDOUx1Q9DzOLJ7KvU9OAiJSu72N27RFVzCNyaynWBGzfqb6/+Ebj42zNMpRTMINA18QAAAABJRU5ErkJggg==", + 73: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAY1BMVEUAAABzc/9z/3N/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93M8HRRZAAAA8klEQVQ4T22LCQKCMAwEA6IIKgqCB6D4/1eas7S0E7LZTQrAljzPk95RQIGQoVHED0rRsvRSQF2b1qh1/AAu1ARc2EfcbvyhoZnificxk+AXSsCyLOa0Q76EWezt/SNo2F5hnqlnMaj8rUzTBPSxYKMLGMcRRSyFUYPxdtM5M8zLhpTtXnZ/OkM47/6HByR4rNthGDbHQdYW+57Ve9Cva6JLa9dJgNbXdk2t7q4sVx0ghrYUyDZg2jROG9nxOIOqGC+cdXXSdsHMSUKlHVFVsj5y4Ty6E1vrAxYcWD0o6XKvFbHX3lHt4jtdgPcZV4Iso/UfJwcO5ld/2ocAAAAASUVORK5CYII=", + 74: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAY1BMVEUAAABzc/9z/3N/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93M8HRRZAAABDElEQVQ4T22KiWKCMBBEpxZKLzwQBBWo//+VndldjqAvmzk2AVJ2O40n9zUZsiwuZAxOURSTM7my2ZBv4h/pKlI1W5CyLP2dMZoWpcFwJDj6B2XDooTLs+EfFM6u0wp4EDyWpkn4MzxpwmMnxnHEGC6ZTUsxDAMGM4Z5ta7oeUz63ruQTh+AO+7TsAjT5cNN56YgV5CZO1dciUcz1VgYnZhDh27ZGC3atjVXMI1NcLmAR6ioR55o0MQ0VsXqmdQ8qGsfkT4DVeVa6cpgi4VT2Ek3NPlwSPNBrFYr9nte6l7hBb/EVf6CHzHbM1+G+/bN+BTukG/5MCxonsnzHHmE3MKGdzIHTylvZA6e8A8RyRv+eqdfnQAAAABJRU5ErkJggg==", + 75: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAXVBMVEUAAAB/c/mK/3OMc/SYc+6g/3Olc+ixc+O3/3O+c93Ic87N/3PSc77cc63k/3Pnc5zxc4v6/3P7c3r/enP/hnP/knP/n3P/q3P/t3P/wnP/zXP/13P/4nP/7HP/93Ow8UUdAAAA1UlEQVQ4T5WKixKCMAwE4/uNKIgK6P9/pkkuiZTqjG7K3TaF6CemIczwwVl4L0gmY80DWbOaD9nxmDHJEygKKszSB+PEIyV5ssuIJ76ntGXKQ85jkGN6Hep7SC8kP3QddYTTMdglf7StBmdLohLazt3iztgtSrkhb/iwMFOuPIlp+Y5pmmjRRkeOc+HRctOEgRpZi8BJPaisKlGN2IFzlBy92cooo9RKxp/AMcpszCHKLGOvIamWs81kxMYTkrPyhGQsebTQH5h7QjJmPJLfmfCZvPMPXlr6DM4rtlcJAAAAAElFTkSuQmCC", +}; + +/** Beast ID (1-75) -> data:image/gif;base64,... */ +export const BEAST_GIF_REGULAR: Record = { + 1: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAP+IAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACgISPqRvrFmJ7lEnJwKzwxro94aeEnNakJpKe4+myogZDx1p3JQ6qK1baqVCjSwJow3gmS5bxuIwSb7SN8iptJW/YTlZLC5JQZOCHJ3OWueexuqbM+ZDkXDlOlV/rdnXbbTfX1EcUBahnSJiUpdg2RQfz5dE3KRX4+MfngmQ1iVAAACH5BAUUAAIALAEAAAAeACAAAAJ9hI+py+0XHgy0RWmorulisGmW5IHl1yEcqpRnSqrOO2a19a5wG+mZb3JVhkLRxNgjIkOeHqjDZJqetssmGJQOISplNoSlVa1JbNa8m26PVB4LOPuexAylk3Uswz/EM/4ZZYQXKIiSFPUHaDdl6LXIBxbI93NoRpe30gR2UAAAIfkEBRQAAgAsAwABAB0AEwAAAkKEj6kWuwGbS1LFO1m+cYsPhl8gClsGkEIDeeULl0BMxyhVm4+a0x3Ui7FaQRsDWHx1kjZmzRCaOUVS6VTEu1Kt2gIAIfkEBRQAAgAsAgABAB0AHwAAAnuEj6GB7Q+WhGZRaSGrd/PneY4SRWKTXQnFrsfZshvckiRKl6+d7nDGsARFmMTEVzQlS0Mh5mnSMSu8JtT2QkWVV6yKGgU6TzewlxqMqcsxK1vatsLV6OGWbgz36O4l/+n3B5gjwzVBqGE3hgdo+CZzCMWnROm0lhLiVwAAOw==", + 2: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAP+IAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACoISPFgnLD5WTsaawcJvW4s91UdiIEpkp5aUd7eoy4aQ56bzBapqX9qfLAH0UGzFXM/KExyVouPTdjqfhjhh1PqFNVcy7eZG8ya8LV/ypwZeTmyKDjF/h7aol3M7md91ZRudn9saSp3YYNiIWBGPF9wXCRhPIwjgHtWdVJxap2akHaogHRFpqt6OXeFr3cGqaKBJ5lgdrgoTJWtvqOgoKUAAAIfkEBRQAAgAsAAAFACAAGwAAAmyEL6nLfG+CBK06Gd6MtoscZd5IluaJpmoirhYQWHE5v0p91tSyu0n/8VVwAoPLyMAQcxih8wn9RXmQ6jIJejggVxmCepAIJ8pymIwJlWfrDQytPLvbLV4ja3Vr0ml19b+30ecH+Nc3qIZnUAAAIfkEBRQAAgAsAAAAACAAIAAAApuEj6nLHPqaRCGaOjPA3OpWhd63jBsJnqfpiNgFHe6rJuH65DRV9zIfk+Vgw43OSFQdI0PmjLkiNqOX529KwzpfnF/1ChPuoJasCGJyXVk+L1pI6SJxnp3xBqZW8bYR2882h3d29yUx2FPEd2hIWIZyU1dIYiVGeKj2pGm3Z1apGWcXOdM5iFg4ujhpeqezJbpVGtsZ1DopZrtQAAAh+QQFFAACACwAAAAAIAAgAAACoISPFgnLD5WTsaawcJvW4s91UdiIXlmSo3Yx5IewW6uFcq2gIJrvKeXI6DLEnm4m/G1ArKQQ94wxY7+iMcj0RY2HiReWewQp4a7NHL41IdivRKXiSd1L3Cyl5fio4xfYfCZ2ITNX99ZGFLfUJZe0WKF3WCbnYddD+MY2Bbi3x1mTFTol+pWIuEMKWKfGuvkIilnoAvP3Z5KnFwvZhOlpUAAAOw==", + 3: "data:image/gif;base64,R0lGODlhIAAgAPECAAAAAP+IAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQFFAACACwAAAAAIAAgAAACf4SPCaHtGKKcUbEH3T11Y59xBvhR1UhinEeVpxU20jolrN1CzM6f9U+6bHao0UJ0tBmXt2QyuHTWokKY9IOECl9VVFV7TCmJKaLzGTJbmhqdComOvnHB1zy9ld/ldrHKD7cHqDc3eFZ4Zxjzt3f4oBiIJZjYuABo12gyVcmpUAAAIfkEBRQAAgAsAQAAAB4AIAAAAnSEj6nL3eEcVHDGgLPGx0bgIV4oMRP3iRtKpqjBpssItnBmig+38njtW3UqHdANZkS+kpaTLsl8NoevKTSKfBSvROC2GaMRbbpxokvjKinp3PBjtcpupN+ceXLeuW0ZeesHd/eX5RJoiCiYeHG46DbXs9FQAAAh+QQFFAACACwBAAEAHgAaAAACZISPqcvN4SJMcEYQst7Z1Os9FIiJiHVx2khi6LS1x9vJbGivsdutFDcruUKWnvGDe+FKvmFx1nzWksHGU0iNLnVLplfiVV6p1W9wvJAqplhYeShhe+QgmL1Lop1yKRnKlNe3UAAAOw==", + 4: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAP+IAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACcYSPqcsNAZ1c4dSJH7rZxcp1TBiKSfmgIkiZG3u6llaqGAvP7pXrJq7ZyEA9g00C5AV/xGWxkzTSdlLO81YNXidA4dHjlIpXkWmXOk19R+KcEg1bc7Vtany8xJqzK138k8cFSAQhp1CGiGNoMfhmpVAAACH5BAUUAAIALAYAAQAWAB8AAAJfhI+py70BjZi02nkCuLx7DkSa5iCBBWkfJq2e6lIhdlbwesfVrMvh1qOMfD+GLNcbXoCdERNXVPZ+NU7VmnB6mD/ZB4J1Lr7gIItxFfAsDhcpPdHGnquDWWgo3/dqQwEAOw==", + 5: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAP+IAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACgoR/oYrtj0JbsM4kDbN2a8xVSxZRIUBmJuaJFwqz7UNCnjQ79bd+J5rK+X63HegXk5WMrkmxJ2ImR8KSjXWkSWtV3dZ6gg7HHOGuq7tGkMk12DlKpF9LKmNmbNn3XBsOSgUkp6WxtXEYFVJEhlVWl8jm5sUlReOnQvZ12SdJN3lzUAAAIfkEBRQAAgAsAAAAACAAIAAAAn2Ej6nLGg9Dm0k6Sxl+iOflGRv0VeR1llYqRti3Aq/cltpmT/OsgTIf0r1YHWLv4Em5YKagi3cxFTvMKRLaYO2wKKcURtyqgkgr2HflOtDXJpm2TqefFHHrGcl+8Xi2nN9XAcKR57YzSCjkhagm8hNzE1KIAhdZ+aMDdghQAAAh+QQFFAACACwAAAEAIAAfAAACe4R/oYvtn5yCtIV0ca0zmpVtFtBZoIhkTAqGqEqyX4ma3uY+eU7xFz2ruVYSYs9GGp5wRWWLWZSloFMMj/phXTlD7RZCc351XW0tWJ0BcWXrOTkyn4G7tbUTJpNby2zTW4e3VfK0Z2RWCIanmHSIJWPUF6VHmDYZBdNQAAA7", + 6: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAIwAvwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAEACfIQdp5frj+JKFFrUMmi3bxVwTHhVGXVWnrSF5rg6ohqX341+4uNy+0pisHq3GEkjRNaEE1btB1pCgjSpzFdUQT09oqu0DVp3Wt82GukWjc2X5szLfVtO4A8pBkqw+WXYCnOkNNZXB2i2BthypHhFt3bix+SFIcWYVdkYUwAAIfkEBRQAAgAsAQAAABsAHwAAAl+Ej4Gmu9FOlMk1eITWmHUnbaLggeAofqaDtq3UuIBqXVB7rZO7Aenq4/VoicDPuJmAiMjeTGkSBjVAg5DkuWqn2q73Cw6Lx+Sy+Ty6nW1mJANNbYYV8BnnHMyMaWRQAQA7", + 7: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAIwAvwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACmoSPqcsb3uIJD9BKZcsP269ZGfh5BjYqXleeralOLLhWZGKXcze7zJgT4U5BSDF2FOVYRSbi4ltOntMqDCgjWm2waIQz1GaJF+n4aVZy0V8sLZrSgIdxCVSnRSWVYaFPFtS0RlJHiLNTVhPGNZh41XgnpnY26WBSBifHeJZSKNlixEY1evMXWCXJ5PR5xQbEQ6qX9PoT2aanUQAAIfkEBRQAAgAsAQAEAB4AGwAAAkqEL6nLen9CaJRJGKtWAZu5aV0FhFQpmk3nqeEjudsFgLL43TOK6kwvsPk4GOHwiEwql6YaM/iJISUsBPLxzGq3GyeTRU1SIclHAQAh+QQFFAACACwCAAAAHAAeAAACeYR/gbntoQCM0FmpstHxoq5JjMdwm9h51Cm26UOFWay2yRta+bU3K8/ivWAk1vBXdH2CugqIdpr4ojXk6Fph2m7ZbXAy/ECz3SZog5ROl4/F8TZ6Xrky8ApMiuG9qme3DPOzp6cDh2bIh+ZUuFf0luSGYgJ5SDZjUQAAOw==", + 8: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAIwAvwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEGQD/ACwAAAAAIAAgAAACc4SPqcvBD01ws9WYqJ0Oo76AlxdVHCmFI0iyEqWdHntypvwqWg4Dpt8ZZYK72AfoOvyCSh/SiftcdpmXqJE6OpvXUDOrpWHBRfEWy/zqSmBvG0Ilo9hDlCs5z59n8LfeD5jHhGe39nfYZ4i4WFjFmPiYVwAAIfkEBRkAAgAsBQAHABgAGQAAAlWEHwG5y+dgUpNVRJGhXMXZNGCWiZa4hWh5qajpbV6ZQm8Uxmwtx5ovSek0tqGLaEsGjzzlz+kEKo1LJrS5nBWv1SSNiwVfpeJyGDl9mstUdHR9JhcAACH5BAUZAAIALAIAAQAbAB8AAAJxhI+pC8EW4oNOqohn28tR7XWVpV1k+KCfNKohmmFsRnlwM252C3Fvr+vRcEEfouLb2VJFovN4WEanwF8JKMRCOVQjN4FkqLrY8feiNZO45ms5O7EG2245mkqvkvPWfEfspvUhGHgHSHYW2OYnVXgYWAAAOw==", + 9: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAIwAvwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACm4SPqcsY32ILgFKJz9vm1rxA3eiBXFV+qWSpLaqarYhuNOvd3anNzseAvICzi05TOxkTy1VR9LLlVqOdD1qN9YhYIWxK/MJi0tvVBiSPFV4pl8wrCcsuX22dLLvtcwfdwnGVlqJXF6hFVVhHEub0Z9WE10P306bF9EgSN/GYk4TkGDL4yfgTRAMoF3eU54cahcZ0aSc6BHKL21AAACH5BAUUAAIALAEAAQAdABYAAAI5hB15y+0hYnSUpmuk3lwrlHWidHzjKUFREKIdm7buaM72jef6zm+sugMogL2i8YhMKpcTpRCQ/BUAACH5BAUUAAIALAEAAAAeAB8AAAKBhB15y+0QIBS02otvCrl7e3DfSEGRQXpbmkZuxH4vEH8SXTcVLCeg4kJMcqfghse6nUKumKR4FMaMp1Kt8oSark/TUZTszhhgknhzoHzX6+7wijXimmqnfFlm3dNwtfvGtNZxFoQgqCLWcIjDdWjVuISABRnppWAXFdJl9/fgeVAAACH5BAUUAAIALAEAAAAeAB8AAAJylA0Wx+0Plny0prOqZilH5GXb0TnRN15C2Zyi1Yhf545g67ybTmL2dkmgfrgcsbjyHR+LC++nEgScUaiOFaMBl9yu1/QNi8fPZdk7PXOFCsiXN2RWnmmYNN5s0RHKpMcWINNW07PjUqVwCLDI2Oj4uFgAADs=", + 10: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAIwAvwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACkoQReMud2QyUir018QlXwf5MWYWAmidGXLdR2ho50kq78Q1b3M3bVh/LBXfA2clHLJZ4SWVLpRMyZRuaFHcsWUfYp3bLDdqaWueSGS77xsl0+ZMLZdwVUYq0Psmt9eyL/WQSdrFXQ+gB9YEx18dC0Xa2c+f4+BOpsxZiRmXkRgb1eLWZchhFR3JoZ3TG2dP0uVoAACH5BAUUAAIALAEAAAAfAB8AAAKNhI+pmwHOonEQ1SrfwTbQx4GaFzbeJl4nQ37W1IArHMstFJZdPme2tqCQfDhJ0QekKYG3SE+xuj1r0IlU96pdhxkMjsPtZoPYapKF3JSX6otZhiK7WrDwWauOe+80oZRZFwRopZfC9+HXhEgYc8QYCIkyI0To5miYFUX1RUdGFOiShrdoMkXl9PXYYVAAADs=", + 11: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAAA/yIgNAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACjoSPGJGwDaNhico7z8tY2rU5k+Up4LkxJLRyzidibaZqddnNs+u1d7MThUy6COVz/FWAShtPAYQ2gytfTBWMaZ6d5fa6zUJdqcfwYv6KSyCytHt6wroV61gmTp7prLaWHxUIeOc2KJfj5/dHFFLThlL3mPby8ihUWWkWJ+RImdYJipU5IolVWib3eVmlUAAAIfkEBRQAAwAsAgAAAB0AGwAAAmqEjxFoyg/bW7HKRkG2+mTlXOHEgCYobQn0fR1bLbI3k9xb2tbo4T7Jo21UqxbGRzwSQ6rk8AddAjvBS896u1opriRt+0JVeyhwFsN8krNjF8erxerO47PGJLdH4O9V/qYGIXCXxhWDZ1AAADs=", + 12: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAAA/wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACkYSPqcsWsZ5Ms4HqrkbyWdiB2RF6jUluZPmdaNhyUCrPkZ3ZIs5gI6U6aXguy6U0wZlQveGQJ/oZOatN9OPBzKDMGzTo6E6PKS5RgTxerz3YFvRtJ8npXIQM7uBpVHZVxwJ0pocWdvdGqKR2JmglQ+dTuFOTFNnItWcpGUQYJjZmiPY5pqlZZAkH+iQ2qepqUAAAIfkEBRQAAgAsAQAAABMAHAAAAkOEHaca4g8jBNLRirNIuvsPak1IltFlikAStN7aHp+clmitrfck6Q6LqOw2C9fjAFw8Eotm65l7PoOgVWmkAoKA2EgBACH5BAUUAAIALAIAAAAdAB8AAAKHhI8Zyb3+VIiMmmXB3E1TrCHbWHnc840TpIQS53SmuMa06MpeG4E6fMiEfLycbgdR1VIX4fBZC+acth3KWAReaU7gBTs7BntYL1c1IxObaNQJx7uuSNE1aB32flyW+RiNk0Ii5fYzWKgkczel5BezmDZnduam5ygW9hIlNvl3JLlJSDU0mFUAADs=", + 13: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAAA/wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACoISPqcsa98CLzckY8r20Ijxtmgcl4Wig5teMZ8mmUtyZ1NS5qQZy9sLbnXA/S+amQh2PxaUMtgzGONFaVOQYVq8v1WxGVIJ7OdmQGnSFzOwd7Iv5PuNm6Utel699c/x9gwUI9jT4Fkb4VghRw1JG40ZYxsjgOMlUkdQXmTaFaFiyNxh6s5JI6tgCRwl3CqX6czmmRGcV22lL6YWJS9LbUAAAIfkEBRQAAgAsAQABAB4AHQAAAmCEjxDCbZFibLSyAKHcWGX/WNYhNkuJCsClrMKZVkoKx5SXaZBduiwfa2GAtpmJiEwql8ym8+ncQY1QirSKDWYvRNBGVhNpbgdNGXUVtayxsEnYfJyLaLkb5Sul2/dKoAAAIfkEBRQAAgAsAQAEAB4AGgAAAnYEhKnLahaanOzQ+0AI0FyqcVv3VRv3jGWSog9yelN7uhoUl6M7hvUP3LEUkUQRU7ylOhyKCLWzCDQrwZNk7VCrShsKsV1Bl8dq01GuGru3tHpa5r0Zaekqg0+fL3HtcuZGFDaFIaFk9walFgg2xpeCpKMygVIAACH5BAUUAAIALAEAAQAeAB0AAAJmhH9hwq0IoQqh2cuifhTMr4XIhFlAiVqV4HlZqaBxesL1k3QceYHpmgHSUgzKg4js1TIeyi8JNUWn1GrPmhROXdhuyaAlhmnAmcO69KqzYMwYZnpjW13z+g6V26V4RxvJBZVGY1AAADs=", + 14: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAAA/wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAEACgYSPqcsbD15oNEp4rawGWjQ5Iedl5ciBkbZOG7lq2OjCx1nT6V2he1cC+n6qjupFymFYv5qM5ezFXNFjj0Z9hTzN23JIDNuARl74gs6Ivei1wjfkdsts4tK4qVLaeXWzbyIHk3XSsuMUaHUlxJig97b10QcCVkTHpGPHk+eGB5VSAAAh+QQFFAACACwEAAgAFgAVAAACSJSPmRHqGEB7hs0jGdj82hNZgBMlWShxmxapoaaun3LR1CvGFi7mbnraoWoLivH4SBGRTIqSiZI1o5mmAFadtrJIrMR6dYG3BQAh+QQFFAACACwFAAIAFQAeAAACaoSPqReLraAJUAI7K200rw2G2NNd2RiJTsqVK5OM7gPD21czs9ly/H7xTYI+S6f3k4GIxJ1qGYrdnk5Tkykc9kpHq7bZsn2vM2Ex6BWjb0yaBp0jecJTCfcd/eWM3KEfPmWFYof1wrOGUgAAOw==", + 15: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAAA/wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAEACkYSPqbsR8CBD8Tl246nJ6ulYGHRNlKl8jZQaqsua3BqnapjB+P1S/fajoTogHQkjmhE1pVlJEoRtWKLp8FRNyphPqpLEBe60UNf4Ch5Hi9f1CV0jSuGx2zFOyy27/E8IX3aUBcXx49GCpzdS90bVZnXHCMeFA0nHNOe2w1g4teljhgn5F+nnB2RJSqimuMoKUAAAIfkEBRQAAgAsDAAXAAgACAAAAg+Ej2EKHN7SeW8hey1VoQAAIfkEBRQAAgAsCwAVAAoABwAAAg8MjmcQ7ckUWjC2dOertQAAIfkEBRQAAgAsCAAHABAABgAAAhFUhKl46xtAe0YiQG/eYb4OFAAh+QQFFAACACwIAAcAEAAGAAACEYSPaaHK8NphNKZAEdbWLVUAACH5BAUUAAIALAgABwAQABUAAAIsRICpGOIPoztnKeqAhHr7FzRf+JXmiabqyqpMCCMbxRilclbi98rjZYLtHgUAOw==", + 16: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAD/AAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACiYSPqct9EVyDMFVwDY1Tx/xQmoQ948mVpPqV7ZeuIgPG5OsiuOxx8c7TWXKrk8oCcswqyaPSh6zdhsajTeFLtVDVxVYLDSutXCjmanJKQ12TbcPUNXtvKvZuJp+RXuIItmUn9JMD1DYB6FJXBMMyc9iHY4gWRFPkwSd481ZHGeW1JvEC5ndpqlAAACH5BAUUAAIALAMAAgAbAB0AAAJRhIWpy+YWmFQBzIuz3lzZPn2CCJbmmVQqmgbV42hkGGUVBrx4Pjf19Lr5cprgjEcsQl6OFccFabp+m2kTSZVhedkik3tKssbksvkM4pWd5FcBACH5BAUUAAIALAMAAgAbAB0AAAJSBCKpyx0GX5vr0Iuz3nyhTn2CCJbmqRyBhCYHBFsZGQKaXOPTo+/29eolHixMkMYrGlcG3kuZUTlXTFDk2fxxmFjo7fg6eVvksvmM1hDNYbahAAAh+QQFFAACACwDAAUAGwAaAAACSJSPErfpDyGINE1zq968xwCAjZcEJoCmKCmN7BGur+V+GRLXDxjTqL778VKizikmNHlMQ9HP84sWl8PcKzTLarfcLre3nYZRBQA7", + 17: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAD/AAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACkISPmWGsDxubMyqHXNj8WlgB4Udu4hlh5WmSoNZkqsu1EutmbKfbnhwLongfk6ZFnKWGMdhB+QglVb4l5opq0haURdYChX7Bl6pIXH4esb4aUNqZXbG37rnmPHtHuyDyxuRkJ2Gkdsf01sPll6LE9zcGtCeZJyMmJ5d2SZWpE/m0NyjUuOQnGppzGBaX2mpQAAAh+QQFFAACACwJAAAAFgAfAAACaoSPqathzlJwlCIo39yxAWh1l4WJ3/OVy3SiB9tw4wm/tPxWs9u2NYuRCS89kM92ywWDyQyqZFzpckhnBlbTqIhAakpFempDVOhtgxXb0qnOdCzqruNZdaROu+N5EnnMw7eTtLcG5dcHVAAAIfkEBRQAAgAsCQABABYAHgAAAmiEjxC26bxiTA21gPPbU/ntYF4FWiP5iB+pUhl7Kej0WmIrM0fF26uq2QljI92OdmnhkJRh8+PK+Yw21AkyXepuxteseIR0oOOrt3TtWqO8YAmXBsHBHGs5dIemqNPQmxU2F1elJ8NVAAA7", + 18: "data:image/gif;base64,R0lGODdhIAAgAIAAAAAAAAD/ACH/C05FVFNDQVBFMi4wAwEAAAAh+QQIFAAAACwAAAAAIAAgAAACi4SPqcvtn0JY80hojawaTK6BEPhlJCJ2VemxDfetp5h6aOuQdGfL4X2xmXCrXw/3yggvMR6GVYouc8WTs/qKFlXYWgwWcu0sUnEkohWqjlBwCwpkI2dwhe/nluaIayXGLqf2EEThNLhU0zcyNyPIoMekpre3VeaYlIh1WVgYmfgIunno8vdUeoqKUAAAIfkECBQAAAAsAAAAACAAIAAAAoyEj6nLGQ2eg6/KiLMJt/XLad0GkWG1oSQVgYj0lVjIgHB63PCeZ3Rv8eFEP4XthTppSrqZs+gxvXpDZtLWlCFX0yzlxu0uJ6qkcOswK6/E9mjFyfKcY6AaaAJ7lFLqu9YSIwM1dQZIQ6g3OMTXUkcm8jSjEuXC+Ai5cGQWxQSn9afF0igKSlWKmgpQAAAh+QQIFAAAACwAAAAAIAAgAAACjoSPqcut4RaUaUY0gz4ZQGs1m9F9nIdSVWp67Qm78kym9bqOKheCdQbk3XqoTWfW0oVsRyPycioVpzaJNOajYkimkc+r3WqyYyaOO30tl9RX+k1jPaNvMMvJHoLcHzejL9dUlPcHVwWlQohYqGjl4CdyRwHJeERHeYnWFfYoV2e4sxV4OFnJGUnqubjaUAAAOw==", + 19: "data:image/gif;base64,R0lGODlhIAAgAPECAAAAAAD/AAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQFFAACACwAAAAAIAAgAAACeoSPqcsZEJ57silqKszbeql5SHiADFmimQqx3aW67WLCH81d4svnvhVxzELBHfHXu20omJpx2GliRJopp7or/ZxZXLLrlXVBXPAqRzb7mC+x8ApHAtEj+tPudNemfLmurLVEFYUX14Blx+OSFlgFOKGTVHSCggipZlYAACH5BAUUAAIALAIABQAcABoAAAJXhCWBy40qgJu0Lmkrzrz7D4biSJbmiaYk5ATGC8dG4FIALcs4d7v5/WJNfEBdzBIjBmcen7LohDFm1GI1WoVhiU+fzUpV4jaTmbg31pIv5vTvpXn/eK8CACH5BAUUAAIALAEABAAeABsAAAJWhB+iyy1xYlTJ2Qqs3tzVvnzgSJbmiabqyrbuC8OB6EGSNOcGZ+Qz8sNxbBFfg8jrHWkMJmUDIQIzFkCwiGgKG8rQ7XoL96RiarJ8I6HXzsVa3FbFNQUAIfkEBRQAAgAsAQAFAB4AGgAAAlaEESKg7c9EerTa6yLOu/sPhuJIluaJpuo6GtgBx3IwWbSMI4F7GbcM8WF2vEaRooH0YMSmzQcFGhHIAzETa0aZ1iixy+x8t2Pa50em1SqImbrFmuYOBQA7", + 20: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAD/AAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACiYSPqcsW+ECcsMFAZcbRpseFoPdhDjOZ5Nl90qqArdnCp8MdtT26O9wJ6WwujfBFvMR+QKaKqBLlNLyb1AocLoIrrpSmbXA9YxTL0mMiX1/R2ql7bp+/YM9ML7Jx7fON5YUX97YWthWDdHfRh0hxN7UUGEjF54bjh5hZR5YIaeQoNqI2JJNkClAAACH5BAUUAAIALAEAAAAeAB4AAAKBhB0HuejHlAyR0bei3Jd6n23ihU2QJoYoFKZjiySry8ZkQ7+rnL921eP8SLPe7RTkFI9GywcEo1mGU5xLs1QUMbJnp+azXsFa1rYBNDm8XiuqAk19wE60FF3lPdhQIO8tVgb4pSYn9PXGN2iXKLdomNEWeAUYyCRUOLmlF3cypVEAACH5BAUUAAIALAEAAAAeABoAAAJOhB+iyy1xogSurjmT3RCfvVHgSJbmiaaBloZiW0XwTNeXZN85s7ZQC+hIfrDgEIESKpEqhAGyMqCeUKMQ+AxWa9Yu61TtLL7Jm6zo4R4KACH5BAUUAAIALAEAAAAeABoAAAJVhB0gy+0C0pknvMskpbjDPVneJY7m2W2oF7TuioEKjLU0+976zj9u3lvYgg3DLXLTbEo0ZeUAe1Ikx8jUqENII0xTS5oYJsNWTbVcmh0z5O6qXe6RCwA7", + 21: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAP///wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAEACgYSPqavBfqAJTrJFEZS2awtU4Xhp0XSOYpk+KOk1YMZNM0tGIM6r/X6zhXYJ4gvmaxWNvpXykTlGbdNjSrT5VXWmnvf7A1M/Hmb3FKtsG5iijsKMd2PtSy2de7rhQ7d9neOUx1LWl2XExxVFBMSGRDcYdJhUUlM3KLZlxgMp5rlQAAAh+QQFFAACACwCAAEAHQAeAAACdISPqcsaDYNc70FkgZ2m3p5wmXdlx6hpXGOeoAqz1KtKbTinHcnc+oaJzIA8GS5l8oVaJCCth7LFkJ8o1fXRaYvKJQiFFb4qvO50lLx6dzGm9PjF+phB4okepjbF2rbeuOXiYbaE15e1dojIxrgYlOfY41gAACH5BAUUAAIALAQAAgAbAB0AAAJohI+By73qIggwTflMvWrLSh1diF2aOY0liKaUx2xdMmMsK9p0XusnJFtZgCdL4xYi8RykWS/3KXIykaTUA3MNU6gsVhRsSbnNx7OL5oJjvyJuvHZOqczpGV7HlzTvvVHvF+Y3SFi4UAAAIfkEBRQAAgAsBAABABoAHAAAAmuEjxDJGd/WamgqA/Gl+2QrcZZHShkzkht0VpGGPa3qwEqIvqub59OYoqlwttQM9yuhQDdTjcIMGTm3YufaS9qwPI2T6TiBgJdfi6X1fMId85O8g3tr0q2LnKyLZPcylQr2FxYoKDRTKCdYAAA7", + 22: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAP///wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACVYSPqcvtD6OctNqLs66hh418hwiSgKl5Hsgu6otacSx3xrrNLLzbp58RqW7B08/2oUWSzJ/xknxGlUskkyoBOnMKbBbmXd6EpTGRSw4/yNJU1KhdFAAAIfkEBRQAAgAsCgAIAAwAFgAAAjGEjwnBoYtckoae1p5euF9lOZIYgZMXMZVarSwpZjFHqzYEwXZMsWs5SXVCP1yLhisAADs=", + 23: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAP///wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACiYSPqcsYDdsD05lQ45nY0qt5D0dlIYiNXWZqXZKWp7e871m1d8vkoBPjwWqKEQ4mNIZ8khmHaVK5oj/g7HNRKrEuVNa67cl8W6PwA918zxsWt/Rky7zF1a2IDddTMSDpPbf290WnBshXZcHmZoYHOJQltXdXs4JGFVinaNi2+IP4eAWXJ+pUKloAACH5BAUUAAIALAIAAAAeACAAAAKIhG8RyO23FkzqPVkBtnxHzVlRpXxgyGTIhqZNCaqodFJ1S9OQF+rTbuqkfLFWjfib2ZCJZoepC/ZW1NEsmjwxnRoT9iNrwo6s4q3rEmOsFyo6yU47ieOSb6y92PG2vIgkVbUSRlHmVnZXFNhlqALINbQzqCh05pLzd+fotyUH9tPpCUlo5MZQAAA7", + 24: "data:image/gif;base64,R0lGODlhIAAgAPECAAAAAP///wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQFFAACACwAAAAAIAAgAAACY4SPqcvtD6MEoc5o6XXB9L49IBgyY7l81YcmFtu6Kya9EInhZk1maa5SuTQ3m+eI0Jl6mlXGyEkenk7eCeZRipjalrNbwoEvyjEti0aN1sgQdkp0x+Hm6E/d9U2gQ33sD2hQAAAh+QQFFAACACwFAAMAGAAbAAACVoQRecttipw84cWJb81y7/aBSFKF1kSSYpY6plu63ChjEG29i6LeNxg7lYKrWErVoVA8OmXuMoN4ZstHi7rLYqHOaPXEmWq8UDGLG2kyflaqjt154yYFACH5BAUUAAIALAMAAgAUABwAAAJThB15y6sQWmywTkfPvCj3ilFRolwcU4JfRp4nOqIe8r60Zj7OWJqiuoHUYrxWbdX7dWIeXXDmbM1kmumqOn2qWMvrz7eVbJlcDplltsF2WZ3lVQAAIfkEBRQAAgAsAwACABQAHAAAAlGEj6kXEL+ia07GRm2iWRt+bRPUfQpZicsDnRe2Sq26ZTNcjxNTombl+8FYRJqNU0oBlS+hp0VMyhBSFy30QVpAOyb1x/CGk7iTdGZeVVkxdAEAOw==", + 25: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAP///wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACdISPqcvtDwOcStIb8qXZbtdpXxN6YxWeSymqBtu5MgizrmThc6y1Y18zRVq1l48hNKYSSUQTYKuQTJ4l9Wm9OpVNnRF08EpfUCw0TFKebbgcWHcsk5/bNbAsxpxX9Ec/PhRWgrZRBbfXt0KGR5jIJLfIxVAAACH5BAUUAAIALAIAAgAZAB4AAAJmhI+pyxAN04sxWArtxEpfLnlgqI2HV46oaLbnCnPPNKvXvVUz/DE9b8ghhA7UUEgssoYnyeuDDOam05eSlmxea9YFt7a5OZjcsbmEwwXXa3BPWTRrwfEdJivVHd94ufiXwZYCdVAAACH5BAUUAAIALAIAAgAZAB4AAAJihI8Wwu0Po5wtWIqztlz7D2LcmJTliJrqyiboy7VHcMpIbAHLR8N5m5voaKbfLHV0AUCK2YpUrEiGS8gOumsYIilaSAcm6phe6WN0fowFVe2Bq+Rm3SZIKYSnvPLqOb/tUAAAOw==", + 26: "data:image/gif;base64,R0lGODlhIAAgAPECAAAAAP+AAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQFFAACACwAAAAAIAAgAEAClYSPqcsQDyMKTlHqcMu6mut137g8JDRFqjR9aHuYmArXcdlosxeaJB8T2TYpoWXFOo0uPldi1QIBe0naD9QxWqLboe6Fdd6Au5K0HKxop2Fizj2FqzfrlFe4RqGz9KfsFzcDVjQXMtTltMN0g/eXyCAox6KTMYYYtFdpyVjHkyUiZbdkJEj5pkgJumjmVdNWCSUnm1AAACH5BAUUAAIALAEAAQAeABAAAAI9hI+pe8EcnJiUglCz1jGmDWqIZ2Dh6ZiCY5znhVSluzUiQLsNa+cbS2r5MhLZECXEHUO80fIJzVyiIWWuAAAh+QQFFAACACwBAAIAHgAaAAACRpSPeQAZwSKMtLKX7mSqeyd9HZQ1i6gAQWep6NdG72ysNOlkGO2pKvQI8Uq20zAVKx6XTIOrCY1Kp9Sq9YrNprKmKo5qKwAAIfkEBRQAAgAsAQACAB4ADgAAAjgMhKkrEQtOMqyiuBxGz3orUR/UTWUzZlKmPGvKno0Me6HwMgCdu3NtQ4VyQCGryKA1iMhmU5QqAAA7", + 27: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAP+IAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAEACkoSPqathDgKEUbr5cpWR+WN5nMZQ4PeYyDSum2qpS9tdtZjI1Zm1Idz5wEKoYjCnsZ04MZIwyXKyfKYoRXmcZV2jqgtZiu68G55NVzwb12wouQ2eXWW0nV16/TJ5jaq/mbKG0XMziGb3d0SU08X3MncY53hT8tV35mM5WRnYVFfnaLXUEJdHAzhGmIl1kRgJp1AAACH5BAUUAAIALAoAAgAUAAgAAAIdDI6hhn28GnsTKJeezpjKj0HU5XHlNhpiZXWnUgAAIfkEBRQAAgAsAQABAB4AGwAAAnyEj4EQrQsjMy6lJ698PC8MNZZ3gCVFceKljinaMdhcdXE7Z6sMK05Msv1opBPv9zHpbBNfahdStSZGpBElcz4jItOQWoS9njvoEneabsDYdJjdjCt1Uef82rasQPxQMFnBdUfjRZfU1jX2sYioVRLItvcYyZiDyPMI5VMAACH5BAUUAAIALAQAAQAaAA0AAAItlC+AcYq/gmLpSFuhYe7d30GXxlmhdwqgRmZqR7Fis8r25t76zvd9GPNBUrwCADs=", + 28: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAP+IAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAEACh4SPqauB4R6MB77rop7caJAxled9oIiSqZhR5nWWccVZrdzWi35SfTlZCYeMF3FmQeo2o2YDtCw6d1AbyqeCJbGz3bZL2nCP5LL5XB6valimtxNLKkPO7+8py2L07Xy/SZfFJudD1+fCc1dHZXMzplYUZEYoV0VztfjhMsVppPKXEqIJhnZUAAAh+QQFFAACACwBAAIAHgAcAAAChESAqct79lhs7gQ7U24XGh09G6h9U4h0jmKZKKimZFvKEP3Z8qlfPs3DsUi6YSsmNM5yxZwqE6RgfsyVMPTz1Xam4S1bPHqxVFt0C9vwUiORiKN+epY3yjJ7HNlZ2r3f/PbnVQeDJhHoZsbmh/L2wshl1VQiV6XooedUBST1xeXopHVQAAA7", + 29: "data:image/gif;base64,R0lGODlhIAAgAPECAAAAAP+AAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQFFAACACwAAAAAIAAgAAACpYSPqctt4SKDgEpna803cR18V5iRUKiID4Vu6Ll8LbhuBzfXMLtbvv0Innga4Q1UQhKLM6LvBXzhbjtXlBpEsGgk49OqDV9/4GINqzuuhjAat+3iTXNIZl2a62K33LLHDLUlxzZn5Jall9VXJWZlEqPmYZKoOBVGCBWJuNnVuQaXItTSWdgY10Z6RCc6xIq3FiNl8yQDhGaoRYkLKyloFjGZqNJQAAAh+QQFFAACACwAAAEAIAAfAAACjISPqcsZKKKctNJXgY2vha9tYod8JHWIXEkarftJbfe6ACbdgXxFdnm75WIqASio8xmGj6aSltPtUKIQ9AKiykIc2mEqTWGFmcQKZ5lWK1k2F2VGqd9F5Q9SrwKn7fym5Fc0N0EXqGVkaFgYOPOVKOfg+CiAhOQ0mXaJmbYYSMa2qbY5SsrYV0rp8lgAACH5BAUUAAIALAkAAQAXAB8AAAJnhB+iy93polwwgonp2SZ4fEWeFwocQJ7kUipox61T8NYdTRtKzuT07ELgWq6KaYPDOX6ZlDHDQDFFJwQqU7U+H9kNNqvE5KpbS5dIRb6gwSx7yuZ6d/HGvP6AwqNQNL5e9ifIcpZVAAAh+QQFFAACACwAAAAAIAAfAAACgpSPGMntt550IMU5K94G+BCBF9V4FaiB3aEpreAZKhDCLMmg8MK/lA7Z0V5Dm2ChGQIDsaPTEWkxd9Om4noLfmjMkyXhu9CEF97vW9sFOVgX9zvGjMY+NpQosz+mekkxxVaX1ScHaOdTIXhIWMiQojgxgmDCWEmYaJmpubcJ1vmlVwAAOw==", + 30: "data:image/gif;base64,R0lGODdhIAAgAJEAAAAAAAAAAP+AAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQFFAAAACwAAAAAIAAgAAACnYx/IsjZrOJ6L9agqE7ZdS5J2GQs5NR9JYKOIgaHLezE9mq610r3tJnbsVQlEm/E4hkbqSKSsoQ8ldHbhhkUMpNbqLDK7UrBxtf0WENDmqC0VDf0aGanNLH+tTqfsxobv5T1thWoNSQCFNZX1pWRhdeTmDP5Afk2GYO5wagpM2hlgSlD5Idz4+moFOaSIvlzNReSqXoUNYoiqFamUAAAIfkECRQAAAAsAAAAACAAIAAAApqMj6nLKdIOjK/OKN+CGrOKcJdhlWIYXFPXSWialiRszrBL5zMXj/itep18vwyxZUMCbZ8VidcgopDOzc0Tglo/L0d0e+WCp+LnSHnsOkBhdlitaGnjTPdVqQ7u2vKk16Xlg9fkF+ORZqVxYviWZZHjpsfU6DTYuMOTmQlHt9kDIqXz5CVDhVMZpwgV2OX5qfom+frKxvJXVFEAADs=", + 31: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAIwAvwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACk4SPqcsZ8FAMEzYVrTZ0X1lZWfZh1DOhZXmibdOqy3uczkjOtVS7e17pjH6ckMNTJPZsO6TGqAN5UpzVRiaSrpi8KYjb7DiTzyJNPDYnZT4tA/0c8uBzFdsopl+9YXZ0i5RTddQVKAcBFJPnFnPzNojopjbTNuViQ2OSJmgG1vMmiOUZSckCN7pkdcOZqYrI6fpRAAAh+QQFFAACACwAAAAAHwAfAAAChISPqRC8v1poRkIUhNb1THthHgU6YTJ5Zkqd6CfFKdO64zca247vvtaqNXyVmsjB6lQ2wR+Qg3ICSSiAlFoqzjxOqglCJSqRRrDPK5KqOWuBtQ0/x9vb4lxqvxPPOn2b4TeXETjUVRj4FrgWtpHox2KkyGMheXVYeXaJKdCzmam5iQNQAAAh+QQFFAACACwAAAcAHwAYAAACSpRhFhDpv15CTVCpHMP02lVN2IF827WNDxMx6ZGE6tm8nKwKrZ730IHzCXnDYamokh2RzKZTaHv+ltIq1CqhYrfcrjS4rWi/omoBACH5BAUUAAIALAEABwAdABgAAAJJlGEWEOkPj2gCUYfis/asq0EMU00VCGpjGmXhGS6Kerlveef6zvf+D9RRWMGi8UY6PohFUrI56Sg5zJ9UWQLZeplU1zqThLmKAgA7", + 32: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAIwAvwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACiISPqcsd3yIK51EAZbS446sp4Odl4TQaYHpSXAWfzDWyLempMlon9qZ69XaxYm5n0hllSdwxKElCLCnXxkV19n46K3YS45K8LJrV8ckuMk0fEKVca7ZPcMc2bBtX6HpYWQXDxQdoFyd351ayZGgWVzZjmAgl2bhISIiYSPN3qFjHNyTi2XVZVwAAIfkEBRQAAgAsBgABABkAHwAAAl6EH3nLG6hAbDS9ayZFogv1SOGWiQ5CVmeZMuEotc67phhdk0GXwyoO81UsnqLxiEwaJ8rmp/NwNqPSpqRq5e2wxavAyz2Cw90tuXw2js+ZdNHshrvn9DoUYP/E0qkCADs=", + 33: "data:image/gif;base64,R0lGODdhIAAgAJEAAAAAAAD/AIwAvwAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQIFAAAACwAAAAAIAAgAAACoISPqbviL5hsIMZ6FczsGahtXCKCh1Nh1pimqPrFsjVxr4vBrPndOcnqeBCozeTE04lqSRWNKFwBZ83GqGhrWX1I4iU4s2p/Yy9Q+o1xw7rWa7jOFXHpk5Okpufbz176mZElhUdTZ+eHdIXnVvYVBHa4Ejh0CGPXpxWXJSeTaYnohxk41Vk6avh5RclWd7PZ19o1ZlSolrRKiBN6xNvLUAAAIfkECBQAAAAsAAAAACAAIAAAAp2Ej6nL4i+YXLEaN/N5lycYTSD4jVJYoRiApakWduy10TEC4av1zRrrASpWGdKmlRMZj67kEDm09ZRR4rJE1Gl5UV/JK+R+dS+U7VbzcXi7NqU8Y+OAWXX8jl/jO2Y5rfbSY2E2x8c0ldY3Vfd3chbj1Bh0dwOJ1qjm5+VCxiQGOQYGBkpoiEmHRqgKmrj5Z4lJMviYNSm4F/mj+1MAACH5BAgUAAAALAAAAAAgACAAAAKehI+py+1vhJwCwopjtW5qqVBbI4pJOYYRALItiMEpk8LrnZGIx/Zyfmp9RsJDkWYaunikmJCyhD6YrhXvaJRmq8OZ8bab2by4sDPsQ2Yzm7aV3B5zX/TFK52rRU9WfH/phxZItOMDR9jzB/jBV5jo9sXVKNkX90iViJM3ecQEpQd2lgk2CsTmIYb5qDnnCPRXY/qZtkalWjm6x7ELUQAAIfkECBQAAAAsAAAAACAAIAAAAp2Ej6nL7W+EnALCimNddLepSUonMmR3iJjqpRFQgvBLZx8iZ6yNy2kJa2ksIQ8IdUEGV8rRznhMCF3LFrA4xQpZuBlnKN1usr8ws0eV1lTe8euKZuuCIXB3Nndbq+Z3mxrF41ej5rLiVKj3AyXm4JaWNTaVB0QxAmmzZ4dW5EX4BqfpyaPj49n5KUl3t5r5VzaZg1d1ZYo4x0ekC1EAADs=", + 34: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAIwAvwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACk4SPF7vpDwNoLb6KmHYsT6l1lBFi3gShqaqoIetREpfOib3iLrmh+s0BlUY1k0JYMdJ+stgvo/RBYZGncPeM0aiglS+riwLFuF6NVxV1zsimViy9dedfC/gzf13I1342fkGC12WBNzbotoV20vZRKEgl6BfYoiUl8vhXR6TI4pbn2Kl5eQVUKemEaQrJtsF00qpXAAAh+QQFFAACACwAAAEAHgAfAAACfAwcostiDRWKFIIIcpXbpvp1R6Z1pmiQZKquAZulIYO069i+x8vz18nY7Xq2HEYHQVJ+nkaseNPZdLLDCRY7mphb1I4C236GwBOpvJyhl5x1ZaR2e+LyRamOF1/hCGzWVOPzINcnNEjIJ1Q3U8hV9kGk4AgE6SNJKNGTUgAAOw==", + 35: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAIwAvwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACjYSPqcsZDaN5gLaAoaV8bT2FlYdYyvd0FzmOaWuWjPq64pHNIXpXNV4yvVKYYg+XQw5hk5gsp2ohI8Moi+rAaiW7rQ/rlF1v1qAUiCY7w0zpL2z0fVzQsvlMlAPhc/2GByLy43Z2kjYIVZiVhJjIZnPXJWkY89ikmLGWZLbZVQm5h6no+TQaCMqVqgpQAAAh+QQFFAACACwCAAEAHAAZAAACaoSPqbvBD52RkFGJX6Dnzt+AiJdxAOedn1Na3cuqbYLOqqxs94Ti5xX7mTaxIFGEyYCCsmGTpzG9RhWpqLIKdaxUKZd7q+2mZOCVivbtjsIpS7emKVfv5DrV7mVz7jGc6aYEZEM3AqcWUwAAOw==", + 36: "data:image/gif;base64,R0lGODdhIAAgAIAAAAAAAAAA/yH/C05FVFNDQVBFMi4wAwEAAAAh+QQIFAAAACwAAAAAIAAgAAACmoSPqcsZfR5coZpqAZ7s5etxzRdJoqOlUWqeIJiR3BdLdEtdWmh5oUqJ6Wwqm2zIWimTPwTxtaspcc1NyUkDanm4XXLpKz51XtZPiCymxSVSc9XCxMPkONmb5S1RyPMXP6eg14dXd8cE4dNlJcJ1aDRTVmXyJlj2JfWXg6Xp2EG1d9fldHVICsUnNAqHShq2OjToqtmB6HJ7UAAAIfkECBQAAAAsAAAAACAAIAAAApSEj6nL7a8CNHKegCmu2yaZXaAXVUhIUsB4rW66cl1MouFtogxHg2PG291UvODs42K9VMRkhNk70ZimpiZ3zC63P5nG2SKyhuEh8LscU9PomE7Zqm7kvrI0XW++d6ff9a3T9ldVkncGc7RA6OAH5/dgSNfHOBWFk7Q4GbYFlSmYwwf11BH0hJnZxYl0ttjo+fUI41EAADs=", + 37: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAAA/wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACgoSPqcvtFsKL8kFaF86MAqx5X+dJJvdFCbdBo4nAbtmu73ycl9iNPl5LqRTDmPC0CeZstVbS9lOhkLciy5cppoCoHM+qxTFlrK7XDGI6wlgLTxhy67wWEh1ej8fYUM12V2c2o7QmCJR3hJjHd6c4tyLj6LL3o4jlZNkTmcnZ6fmpUAAAIfkEBRQAAgAsAQABAB4AHgAAAoWEHRnHre2ASvBMCtdC2GnZWZuYfdqIVCBDjWckxR8Ypqglt1dV5891Y0V0QM7NRfopdzHhplMs8ibOlcyKa7FcGFOQiiMNUU+huBRslkRHcvq6gvZU2/OcbkPj6bXHnmf186dyIsi3Z6LGd3f1huZ3+Of3NTNYWeeYEWakOLhFlel5WVEAACH5BAUUAAIALAEAAAAdAB8AAAKFhI+pFrEN14vIWSoBxLa23F2Mo3zJF2oqSI5qK55aN2NHer/XJpn3BrTJPLpgrcT4zWooYC5HMhmNE44uGYPSlqPo9UTxcSvjFcos9qRXZBhn3eo1lXQQO7rO1Lv6HjcSZ9fGEyjY9tJHJFOY6ITEWKUH6cd4lpjE5jJJiYd5WUL4aTdZAAA7", + 38: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAAA/wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAEACeYSPqRkWvcBjTkJ6bpT7zgo2Iic+GnIqZhdBp7e1bqrGlh3TLr63YB76cWofx4SG+2mWvkWPlTTWMChmpmgbKaPcbhTGE1KR4yHKK8TqnhbsmWd1c8FvZIptejWr4mmX7Rf29zY2kxEkhUFX1DMCRga1BIjmBEmJUAAAIfkEBRQAAgAsAAAAACAAHgAAAnSEj6kYFr2iBJBO9Wg9cF8LYs7HPR5DlmiGJqephm3MsGLl5fXNXXa/gPlwmVMKlDN+GjjaRDdyMIESpdLpykarT2n0uk11uscvmdQBy4LjI7T1C5bS1FjT+g5NmXehtunFs/ESx9WmUcaDGJbIVtgIGQlQAAA7", + 39: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAAA/wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAEACkoSPqctx4UCUJsK3nJbTvr1lFHV9Y8gkYEWmyDpVcYu+LcdqXq1Afvn6AV05HI7nig1lthTMc4KJQLMezQo9YVg31VV3kVZt0HLRSRqrVsRmSd3m6rTx6XFU/2F2nyV5brEDaBfVY1b1lCTlFdLId8VIM+TzZXXD10gXOSgJSRgWaITkxiQoV2eSikql2IX6elAAACH5BAUUAAIALAIABQAcABYAAAJahBGiy71xYpiuvhnRsfZA81Gcg2naNzrguQBp5SoYlLwNjeCQ3ep6zDvlhLsUcajj/WZAXm/YaHaitYeUg7DggjTGjys8gruqoFbjFIRXaUaWdO1UVYZgBlAAACH5BAUUAAIALAEAAQAeAB4AAAKKhI+pyxkWHpCNvSvj3NUdzIUVdXElaUUoWEKq97mKJlKbukIhvu+ZDqTddKwWrTg8EX8m4015ssmgE6pUSExaO8nnUDaKsYDfY8/7PaOyXdvrg1V2EUzRXB6cZ3P0H4heU+P0xyZmyNOSBpjxp2EmZVHVZ8c1tVS5wFTHhUMo2dkQBemC5+E5U1oAACH5BAUUAAIALAwADwAKAAQAAAIJhH+RusAKHYoFACH5BAUUAAIALAEAAQAeAB4AAAKKhI8QFqsJ41uN0SeloxfneG3ThzjMFJZZY1aJq8DqeYrtYdKsqFtu3olhfsIazsPpCW+2UbHU7KQ8lpcxSvtgR1MNd/gFAsNGlDMkBTvX6/R1djsGv71ul15Ey6nTSnS7d8XSRlW2tJFkeAQm46dk1ZIGM6ellEMC0XhJsjP40rm5J5N5Jxr6uVYAACH5BAUUAAIALAIABQAcABYAAAJihC2py3pvAmjUSQiCbq/pe4BVFT7SNnrnoQRp5SZRNr3cSp/2sl59AsJkgLnZL1XE9WqCGM9SzHGmDGUV6MHymDLnS0LS7VaL5K4ZNQ7HRYo39YbG4TTInE1Z28Aw/bduUAAAOw==", + 40: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAAA/wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAEACh4SPocjtt0xIYM53YZWP5Q5qnGZh1Vem36ZeK7uJIfZK9UzFZGhl0ZlzoIawxMrl85RMwBSPpbjRZlKcbvez7ihL7SIb7CBrUbAwFnEZy+f2V/hCXtW9U9TYQMG+bI6vi2V35wd1piLj0fRUhTfypIV3w/iYZ+bV6ASpQzTJdASkqVapKThTAAAh+QQFFAACACwAAAAAIAAgAAAChoSPqcsa32IM5tFl5aGwXpB5EieCFfM5YEqSq9UlKXJBMy3TbKvG52ranGocn04odGFuuaQpE/rAbDKlQ1q98V7UIAz1bEqNvSdWxZ2YfzqWmsjEaOKjuUZevzeDe/2GXOKHs0SXl1MkiFSyJXg2xNfIZlP4hmMVyTeZ+LMD6ad5tJk2iFAAADs=", + 41: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAD/AAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACkoSPqcutYWCT7kUXsqYM+lwdG4iQ4jKiHCWZZ5ResgdoDye2sqVur14KsXTAXcVWSypZoV+Spow2QUCotPmk4a62GLT4gllhSzKvNkbNEqt0B12OUrFM8Jw92Q6NV2Gu7xO25vSXcxc3iKRy4kLYd0EEFxSpxif19QjJhjTmJiinydix9SRqWvKB0ybXOYn16lAAACH5BAUUAAIALAAAAQAgAB4AAAKJhI+py80Bo5sGVhQDbbbq72RWB2jXqUiJyaarWmZni2FmfM8luqekvKPdcjVgLNgbbnA6JG/SGvVqS2nStTwmic+XBHSlHr7cIpjGLGOdOWuVOwRTiOij2uOu29tMz1hrM+W3cvXB16amhPcVBLNgKCYFcmdDojO5wVKGSTlGyZkFhdT5lhaaUAAAOw==", + 42: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAD/AAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACfYSPqcvtD6OctLKQsFVBg75dINZ5W1kiJjVqJli55JdZpMvFtLHK8ZzjwR6rQ9E4DAJpRyTk2EQWocSa1bhrJF/ZJFb18XCvN3IWC5Qtz2te+C3uvpqplJANXsC8vrvW/fYlhHKBJxiUAaUmkngWaKdXwwdZ6KXXloMZ0lAAACH5BAUUAAIALAEABQAcABYAAAJVhI+pG9gLVXhgxutsmxRn3nWe9oRiVG5VckJbKXkrJaayxhwc6qKWY1AFV75e7LIjsjC1IbCVWdJazZ8TOLReQzPnjqt74qZTpO0ZPZ69JnT4rQMBCgAh+QQFFAACACwBAAUAHgATAAACQIwuhsvdeqCbDICAQaQcQaV1lBFakuiE0YVOLHKp7RLEWj2nG547tSbreYLCovEoICITyeVDKSydjDie8+ek1QoAIfkEBRQAAgAsAQAFAB4AEwAAAk2UDXHL7Q9jDEraBdLdiPKbVd9ILkEolkeSJV55trKbWmc8t1QOPDov2wUdOGCRgiuylDnh76ZDWFwM1qwGCVWhMU7I+q1gI9+ZCpEpAAA7", + 43: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAD/AAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACiYSPqasRDKN5gEKH7Z3MNVlxiTaCj+ZV6bGSnAWz3/mpMUKmbsjLEbWj1VgZ0QgDOgaNPmaztCGiVk5TL4RK4qgq3PAHre4WGW4sF2XeslAd+9QaS71GtO/cZD/Rt3rJjdRiQ0fXN4VFeNe3hSgmNeYhJFKmhZhFI4RZ6ZfZqFWkabnZFRo6qlUAACH5BAUUAAIALAEAAQAeABoAAAJxBBKmy+15nEEUyhkb0hdb9TGhiIHdJkHWipKtebSsqJLlneKe9lX1Mzq9QMPe45hZ9F4UW8dkXD1pIdkUCUtmhZUtLvjN/rQllDWSUIGJUg9TeUvHt1VXmJxWN80xo1I+NyHX5kJIhOaV0cWDGLcoUQAAIfkEBRQAAgAsAgABABwAHAAAAnSEY6nLjNhihNCFeyV4La/qbOFEiglokdXqfRtItexHnfYt1Tb6KpgHw2gssIOGZ7qhlq2XrrTziZC5Zo86XCZxxx/HxQUbV8YeGPjlkLtfU7OYfKy3ZO2b2/Y69+HMXD4VNjZ3FXfy48SjphRY01YV5bhRAAAh+QQFFAACACwCAAEAHAAcAAACdkSAqct711CYNJrbJoNb9sg5WBJupTdyVaeRUpuWbQjRFmqfsEHVzn57yYC2j2t0FCpWyOBjeTndmK9mMOnRXXk9azEDVaG8VR7mWZMuNWJqsS0eN2XmI33Wrbh/KRe7zxJX9SSHQ2VGGHPIgoQWlWUFBunzUAAAIfkEBRQAAgAsAQABAB0AHQAAAnuEj6lrEQzhA5O5W9fMxymePCDYSQ1CdinFno33UdwGt3K4he5u8eyYweRQl8in5lrZULGls6iqKGdLkc8IVV2NviGTK/SWxpqvNDl6qVvWcwTqRgZ3bfL8RLXamVLMTSSHYxNXt6VnUTjoh/UzVldz+HYG6BEpUaRXVwAAIfkEBRQAAgAsCQAGABQADQAAAh6UH3lrwQaiewLMJym+WoMOhhQnHlaJoepDrm7VigUAOw==", + 44: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAD/AAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAEACjISPqZvh79BTgcmI22zUrvp91TiBHhMBJlR2KmgaLHTEXB26N5qOp4chzX4i2yq1o/SEr03S11xFbZJqiNrUqbRJHHer+VqwxDHJWwaDh+RTcFNi/VowGRLdkXqdF+Or9saHFxOXYYeFKFdFkyPTB0NzZ+WoEQmIglcmScmZOdmFiEYW2tXpaWpKRVYAACH5BAUUAAIALAAAAQAgAB8AAAKIhI+pyxgNWZjmvYirvYBnZ3VT+B3cNY5daW5iSrHaG6uwt9yxhq+Q7UPtTC+FytHq+YqrE5KZwAkrydTyidzZYJJcbaPrGik3mvKapFWHxGiYd8w9y2/xVWclGdtrK3+PZqYnInY2CNKDIjMDePZjlxhh+Ef1CFgZ1TBJiXknlwn6GcppGJlQAAA7", + 45: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAD/AAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAAChYSPqcvt34KcAVT4qLQbo2tQh+hNoxmSGZp2HMto4CI7ml3HN74rPQ87qYIV2azlCllGrx/yyDk1g1PlR5j7oKAJI1SVmX6JsafPNAOpzee19aXlws/hZdelLqal7SvbzuTzlnfUIbe0RxMIcfH15hEF6Ab5WLRIWZmIaee42bV4GJYYWgAAIfkEBRQAAgAsGQAUAAYABgAAAgpEApmoe+wUPKkAACH5BAUUAAIALBIAFAANAAgAAAIUhH9hwair2AMTtvTi3Mj1X3nUdxQAIfkEBRQAAgAsEgAUAA0ACAAAAhSEbxGnuPBgS0xN5hDctMf5aWIkFgAh+QQFFAACACwFAAIAEwAeAAACXIQRgal731hbCRp5JEN5X61E3qc9JglOJ1WuXeu+m0pB5RSuM07b1WWKfGIZoINYPJ5ooiSnqBrhnMvek1P5XbWs6cvifVqDLqbRct2i02evNZp+d8jLNjXpNhQAACH5BAUUAAIALBkAFAAGAAYAAAIIBGKYaqvMWisAOw==", + 46: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAP///wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAEACfYSPqcsQGJ4zMsKm5N346E41zxhO1YSSX2KhrLd25DaD1Ne2txxpVV9yADOmXcqowsRORJurGIqBpC9nUGaV6jgiE3VXc263Sktt7PPioOf0KdwV5qzXZ/3rYejWYviPXsLEJVY1OKVUZzOXgbfQmEcYedi0pKiydAmoeVAAACH5BAUUAAIALAIAAQAcABoAAAJjhI+pyxaBXpsQPGmnvbE6v2Ec5JFOdpIjan5Ha0qweIZpFr8ffYNKBXRRIihiwlc7Jo0L5EYH/TGZGEbVB3Q2S8WWhrUMD5XTBlb6LZrT2lpbecaln+rXO6q518fWubgsBFgAACH5BAUUAAIALAsAAQAKAAkAAAIURAJpiHvJGmwMmjvVw7Tvb12SBhQAIfkEBRQAAgAsAgACABwAGQAAAmMEgmFnqdxSVHShdR6jskJtNSK3jZbmVSr0ieyKYVc2z7EcP7ob5jjI6/luO+JNKEPhjiAgz8ZULqHHU0jprBadWa1xWUWyxOEuODz+mn3A3ToZtKLj5Xm6jn4PvXb6Hv61UAAAOw==", + 47: "data:image/gif;base64,R0lGODlhIAAgAPAAAAAAAP///yH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACfISPqcu94VKYDCIL6LNY6vkpWgSNjnmlldgdpdq1LqcatHui0hORfH/6ZYAxIdBYO3qGGNluNRQpL7LmNNOyOhs649ZGTUZ71VQXKmWCiegb6fvC+dZm+nddzdKF+pjba/PSZMUniBMSmAaCtzSCsniI9RhSVGFYd5V5UAAAIfkEBRQAAgAsAAADABwAHAAAAiWUj6kK6w+jnLRCEKzeBvMPhuJIluaJpurKLkHTbi85j3W8wWMBACH5BAUUAAIALBgABwADAAMAAAIERGAJBQAh+QQFFAACACwAAAMAHAAcAAACI5SPqRrrD6OctNqLs75g+w+G4kiW5ommCdCoGBvCoOxiLVgAACH5BAUUAAIALAAABQAcABoAAAImlI+pCutvQIAUyYpzvrq76YXiSJbmiabqyrZp0LgkjNKnLZPxWQAAIfkEBRQAAgAsAAABAB0AHgAAAl6Ej6nC7Q8ZCgrE2w4F+2DMGUHwlc6Iml8nIuoTTtR7jXKFa61C0pflk7ASo2CE0jNmTMDaSZfjDT3G5qOTVDayWsiUaDVxu+Sy2Tg7q4PjFU+Uftk0mbDKtuwi6ecCADs=", + 48: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAP///wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACloSPqcsWkSCQEr0aJ3ZPdecdH3dZmWlt3oapHEi5bTO+C9WI0O6CYmhiAWmdCs+Ii3wuzGYsqVsWmZqd5laaZX9XKwl6nPiuypqR22LVdGJYOSX7eZUp2rDOvlXn8P6K/pdHl4blF4QHKIjysrY2hqjoSPIW2fNY9YWU8+i4tMkwF/aJFdb0qdZIBWqDOUNWSGjWZTlRAAAh+QQFFAACACwBAAkAHAAUAAACRpSPqQiQ7ZYUkcG5QHgxVExtzxGIoKZU5rkajVC2k/zCMkgiNy7tPMX49YTEYgZmTCE3vhMSWSM6Vh7jNFEqam7NRbPLKwAAIfkEBRQAAgAsAgABAB4AHwAAAmKEL6nLeg9BmynagANdIAfbHRiILB+kbRy2GWlzvduJfow8SbN6PzhPsQGHxKLJCAwhl0zF59eMSqc5hw66ZAl0Sy61pf2OvuRtA8vrjAxlQVgKoYZcHi8yQxVO0EerC8ZTAAAh+QQFFAACACwBAAkAHAAUAAACRpSPqRiR7ZYUkcG5AngRVExtzwGIoKZU5rkajVC2k/zCMkgiNy7tPMX49YTEYgZmTCE3vhMSWSM6Vh7jNFEqam7NRbPLKwAAOw==", + 49: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAP///wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACjYSPqcttAWNw9Mg7K8NYKy49HgJm4VgCHLqmFaiekdaGUJxk+RXPNnkDllyqh24xnJGMllMvKBIyYUzcx/r0HbObSa1YdW47yuiu6SWCy1ghO8prGk3vta6ctljzZrRcZDKX9hZ0BCV459SGqNWVeGVTeIj3YShJuJXjtzOZuXRYaTnSwAY6utl3CpRQAAAh+QQFFAACACwFAAsADQASAAACK4SPoalrDZoML07qLsZW9qc5oIccZBlZ1cJW3VZOrydubE2Zmfupa44KIgoAIfkEBRQAAgAsAAAKACAAFgAAAliEhanLjRCAm1TAUDOLuoWPLVK3RMa3kY7BnuoGHi8FcrPYXu6ttB8ke9V8D14idrrcfL9LiMfc3ZCnyFMVZVmNR5OSq/V6c+QyVVxOm8VjtTsMf8t1VUMBACH5BAUUAAIALAUAAQAYABsAAAJFlI+gC+gv2lNwViNvhiHs+3TUd5CGt5mVB30me3SgA59KMNsIDOCzm8jlfEJO8YhMKpfMpvMJjRotyNSpWJMQhazGNlcAADs=", + 50: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAP///wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAEAChISPqcsQoeCRSFJnb0wX9uY1jrhYRvcw2kmq0zq945mC61PHMPm5LV6hpHKzSikSkmU4N84LiCnKZsIfSFdMOoNNbes4/IqJYpHptrvGorj0c3tkITdMlDxKR5KrTZ7mvJZXM0iFF1gVuLGD+KcW97aUJ6llMnno5sPk5OXXFoJZFopQAAAh+QQFFAACACwDAAIAHAAPAAACJIR/osvtD56ctE4QbD1ZSxOE3ieO5ql0Hoa27luFKoxF8P0ZBQAh+QQFFAACACwBAAUAHgAUAAACMoSPAcLtD6GKtDJjswuc68wtnxaOwmSmUaC2rnC8qyfXo8La+s73Ve47hQzAF+JQ6h0LADs=", + 51: "data:image/gif;base64,R0lGODlhIAAgAPECAAAAAP+IAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQFFAACACwAAAAAIAAgAAACeoSPqcvtD4MMsBp6sW1TAr0t4Bcek0l5mhdhbpK+YffRZYZeCFu5p3oiRXSkVLFkPAqTs6VJ2ZTVoJuganoTMkYWKZHbI+7EVe3YHEZ/kViFt4Ve8aJOcFcnsz/yMXKaZ/S2txboN6hUqMaBk+c0hBXjI+j2k0Rjk1AAACH5BAUUAAIALAQAAgAWAB4AAAJjhI+pi+HBIjROplfnqkfTvnVQBjbUeAGcKY5Y2YofXL7ZY6k6OnmqHVuxZjSFr4eSCHe+VC6kYy1/xWgTCY0GQzhGk/gERz7JpJcshfasa6ln3Z65qDsiFouu08vI/k1o81AAACH5BAUUAAIALAMAAwAYAB0AAAJhhI+py+0PozShBlnPpXevrlkg4CVbhoKnknGmV4ZcZ2kOvJJtI9Y7NLJFYrJH0MSrJRmlWJOJYrWIRaSOKrQOPxMnCaOifI3i5w+RKrt0Whr7CxNG4fHVyY6+61PnK61SAAAh+QQFFAACACwDAAMAGAAdAAACaYSPEBvpr86CqEnWLDVac7lNYgY+FlkpXjKpGVaa4xeHr7s6Z0TuOtyZQTyrnI7FQdmKqg1t6PSVWr8azRhpHp8VkckVhTq52TEIpaTsiORUFi11U990JO/GI5/g5+f+8wf2xoDTNTJRAAA7", + 52: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAP+IAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACkYR/gcvtoVwCUCKIs1Z8v2hFoGWM2VKR3zkx4IiWqYyKc0zdMEbl8MUr9YRBX4M1FLUSN9eMoxoKp8uoDFm1KovN6O5k83aS2FyIatY4nxUdsEtVumrV32/yIha1Urx1vnT3d4T2pnaRdqVlAiixIyVHE+iWxASkuPEEiWbT6Sd4xMLYkelxCFWpolnX57g5UQAAIfkEBRQAAgAsAQAAAB8AGQAAAm2Ej6nLEA1hePHN6Kbe3OWuXJVBYeWxoSdCrSzokpYYyq2basvd1rS+A9I8pBdOWCRKGj8Mo3SKVUAoZ6IHVFq1n+GQWeR9pVXlhZrcpaPZstF7hbLm3HB5Jrs+65ZMfe9GxjHm1/cXEuXzRVIAADs=", + 53: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAP+IAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACo4SPqcsW39ILcQLr8IUaaWpx3NFdznlSpmquLIiuWUrS76SyUvZBbV5B5Xw632aGFI5qRyDR04yBgD+YkPnaFJc/idV6pLmYvNa11pkqqFAzacsWhas6r4wIUy9wZHWWN7RmFueWxGD0FqFIVnhYhzOEVyKJ2PjItwYZQ1fSBlVkeQgI5oJRxyiWiorFB6rZuGkoC0t5OppkCtrlJrln2oaZUAAAIfkEBRQAAgAsAAAMACAAFAAAAl+MjqnLF2CanA/AOLMI1VqtAaAjItBYMp2HLd5FXafEzVnV0uNuvv7H+P1qL45ReDkWccYVZOhrOi3SRyN5zLwmW1CTYkR5uGNv88nC5hSp5XDVizI5YCIxSV2tSax5AQAh+QQFFAACACwAAAwAIAAUAAACVoSOqcsHYZqc78GJkQX85Rx84hSOJBdcprStX+SCUGel5WKn9Fbr9Pzb5YC/ISrY8+2OwgYRhcmRbCIapSOSSrSZ4lIJY9yMyyQCaEMRr2r1061a9MoFACH5BAUUAAIALAAAEAAgABAAAAJLhB8Byrq83pkmuVjl3Wl2j2FbWEGUdyHpuZ4Z4say+s1ljVp6++A7TvkBY7+exeZqKZHBW5HEXDaZMOPuRYVqebKP0MsVlkAqp64AADs=", + 54: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAP+IAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAAClYSPEIGbD9NiZh4X49xY9dw8lkddX3hWW5N6iiuOZMyWMWe/oGimeAms6FQ5ClCmYyhVPJtPuHw9YSGpdQWZQq8yjiR3JVqFLPKFezarh9tosDosJtkw+XoJNmXV+BYV7iSVt2YmF7WHCGa0k5gxmAb5KMG4OEkHcviGSGZ3CMd45wgaV0nIxEOEpYFzSvJT8xMr+1MAACH5BAUUAAIALAAAAAAgACAAAAKYhI8WCcsPm1MzWjmDPvsmDYZc5ykMSFXYs5FIWKFv17Ly+p6uDn9lnlJhdsJFjGiCxZINyqk5ejaNSaSENc2KiEKodkqiFVVUh8y8g5K1xuUMyPn6oqZ63Cz1xvXMrmiuV5a2N7fWRmiRcZcF0aWWg/cT6VjTCEglyVfn97Em5ahzAQp4ZUM4NkOmOJJxoxSkpvQqS1srWwAAIfkEBRQAAgAsAAAAACAAIAAAApiEj6nLHJFgm+chS+mTYFeeGduIdWUIfuJppqu5kBfrwe7K1ZWix2R6m+R6OFasMwOKWssdEiIxQme85fTZyx2n3BrtaH0yoxig8uoxR5q7LvISAZ3F7XXTha6+4O/wNT7X50ekweYX0hd1+If4Jofl0KDIZySo9xgkqJTIRQfD89VyUyIzKTfykabySfPzk3oK6zr7KvtTAAA7", + 55: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAP+IAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAEACmoSPqcsQD58z4cja2EU1OjhRXgJK0zWaJ5m1CviJW4xxnomS5UpZfA1TvWouV6eXwxVlkU4TAw0Nn7QPSkm0hY4cK9IG091ON670GKUFjbwly90CSuGvs2oG5za3+Aa1tAGVtYDmVIhl5oNG5tUoKHbl47iT4TQnaDnIhNg1BgkUGdhoMQIW9ISzaKrnlXn5JSfi+MWSOEWHWwAAIfkEBRQAAgAsAQAAAB8AHwAAApGEHafLvZGcbBGkOjM8N/uObArmWaYpnqSmQhd4Tu5suTWCy/PeguuIEkUqm5/kZfMRSzua6slBBUO14Y3UTL6qyhi3IyzaWhrr2Al7XHPaJAXcPbtHvJjc/MjSpTSYnuzWx1FHdxZU9IU1hzPUNBXiCJnlR+XDCIeYw6eJNLUFlFZpKPM4WFVS1oiKOrbqClAAADs=", + 56: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAIwAvwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAAChYSPFsvp/xaSsCbJAqDW6sx1IhiKUKZoZoelW7NO20vCK4epR1nBTa67UX4pnmcYJMVmJuNpF3REPTcmSzdUaK29osuFpW6lY+5F9RmHd5EsM8kuq9dwNfkVt63NbxnIzvdVVPPmdEcDtyd2otc0UdMy1QaJYjNJeHipxMJYmSlT5feUUAAAIfkEBRQAAgAsAAAAAB4AHwAAAnuEj6nLGg+bRI+GKSu8FS++XV4WiqMTAd2JqoaWnpxabuMKJ2uTRrCJ6WlesYnQYvMASUpZs7lEumgv4vRKXHZw1OohOt2ZxhTvUFf2mrlYEVm3C6ffxuxXDXbQStk8urZ3V8eQhEX4VTPkh5i4FccI+PHR+AS5pSeJUAAAOw==", + 57: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAIwAvwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAAChoSPqcsY70KUrVEJAa1Wvw9t3II52jhmGcqpIsu4sPV6cwJe4G183u67XX6l0wwj2oRgyJ7OaUzZVNNi63cCYmsK5HC5lVK/UC6uh3sNry7d02zyPbPgShNqK0un+Dv8oNZ3xoZmtFZol+YGGNWx9oj2B7g4OYcSgqnFkxex6VQTJBRaCVcAACH5BAUoAAIALAUAAQAWABwAAAJYBCKpy8APo5w0GEOhdfnt7mHgSHbcc3oJoq0lyKphXB3olN5SbiW21BMcgoIAbWFUDC9G0cLQhG6kOWGU+qFcllPc9gqtHpjcKvB3xFk2RC1tmAFvM1tAAQAh+QQFFAACACwHAAEAEQAHAAACEYSOqaHtDxuYgMUz7RV549oUACH5BAUUAAIALAgAAQARAAcAAAIRhI6poe0PE5iAxTPtFXnj+hQAIfkEBRQAAgAsBQAKABYAEwAAAkyEEYnJGweReYzOeNV500LKaaKXgeUilVYlNaFzhsorpt58pRu35SYMxLWENdepg0S+ULLjsofS+WxT6bMj492oXNoO+xlFZmQWD1AAADs=", + 58: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAIwAvwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAEACeoSPqcsYFp6SDdAX8aKJ19iBh1Y5Yoli2deAGedJMDqOJATd9E57Nt+xnCZAlc6y8a1WSGKsmRviHNNqKiirQUsvqVAFDIvHk4s3fCGOz9Til7UzbpNc8NynzQnf+GwbZ5SGFWTyQqg145ZnpvhzFxfS5selNuVCxlMAACH5BAUUAAIALAEABAAeABsAAAJxhI+pyxjfooLmBRnvojhp8B1hB1ZjRYqnl15Wtk4g17z1TGeMC8Xb//LJPDzUkFhCBXdGY4/n+iWbuOrUQf1ELVrWNfSkjTRgBxdczhLF3mYUtmYLrzORndp2usk3bFJLEQP4R6h3dPdWJnhWZzIWUAAAOw==", + 59: "data:image/gif;base64,R0lGODlhIAAgAPECAAAAAIwAvwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQFFAACACwAAAAAIAAgAAACo4SPqcsbYWCbUsaaLAUavp9xm3dhoeh8nfpEZWO64qoqdXul8UGyfD0raTgs0ow2dPxyqJtr9epVWlMUZRec2KhEHDWJ2HmDHevPAjJ9ZcgtlxhCN89dOK57T5vX96b8xXTjhbWEljZUdAZU94UBxoMXBpcxtsV4OFUF4yElyZnC1lMHiAhyaRfVZ2WKOjiJGMbXKAU2hjSr5Xd0urh5hPmmUAAAIfkEBRQAAgAsAQABAB4AHgAAAliEjynL7e8UnDQYC6hueXtnBaLYfdB4lWY1BuuEWW+1GPMmevJNAS4PDAoQvEPEV0yoeKFDa7lKNYU7H6nYIl2AFwyR2h0Fc43dzKv8jYUPNfsNv0HZbnYBACH5BAUUAAIALAEAAgAeAB0AAAJyhI+py+IPo2AoAImFpcdmCQQOJzrlN4ZMwKLPxm5K6n1hzCr4fWWxIeuoYiAh7Nd7nTDHE8mlaWmAQZ4BqrJWO0uoN+n1SsNfcnhsRt1AaSXY1H68J0TbPBrp+vQjyG15d5aBEKcHE7eHqIhYs5jnGFEAACH5BAUUAAIALAQAAQAZAB4AAAI4lC8RtujvFIPUASkrbbqLG3nWl4AiBKQpeX5YOyYc/Mz0Adx0riN2DwwKh8Si8YhMKpfL340XLAAAOw==", + 60: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAIwAvwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACmYSPFonLD8OS00EF7KMyUZ9l3DiJXGOVV+p9Tdh2aAzW2O2ehwajfKgDvm4rGOtofLF6xN5vB2U6dzJGVarSyUqOILSSI16LJs34af2qqRf1sjNquxXd6zjCpovo9/TGCCanMmO3V/TDBYIWNVShuHKGM4WWuCY0ZJOFEYa5tqWX1CmW5FIGmjZY6eNFlfJBuQQZtzErZytXAAAh+QQFFAACACwAAAAAHwAfAAAClISPqcsb/ZoE4VUbIZW3potYVEeKZRiJmpGx4KGiHvrNrNJm6dzdH26DjTwx3+SW2uQ2TJyw2YIalc+lMVgLaXe8KPIl5BLDzdVQZ8MydMxieU39nr2OODGorrv23by2vjPE8TZSGEaH5OTm9tOY5LSG98OGaOLDpvdH9cjTuMWX2Kb5tCkI0+dl2ZMKxopBEtljUAAAOw==", + 61: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAAA/wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACkIQRp8uWjR6csSVJLWI3z748mOeUnElu6olm0qi8nky9sEPXMRxgN7vpCUErS0/1M12Op+FMWIyVnCGoCHKVHkZZjfeXLDI5PhcOuqWGlaI2rvVBdbvmc3u81m7heW32nzJVkRYU+LZ0tGRIyJTIFRXn9Df0+Gg0tmenCOkjQ8QmVuHomeZpJagX0UGEV0hVAAAh+QQFFAACACwAAAAAIAAgAAACkYQfp8uWDcKDNE6VbmWZx011y6OB3zk6JqI2Uwm9IbvJ1Qtb9I2VEmaSSYYilOtH4n2GLsuvxswliZxoy2M0apKxbnbXREgvORqRTP1in2wSt3Z9v+EOptMWTGXLYa5/pZKBtgRYt2T1NLMlaJgYc9YiiATiY4fFIiQGpIeUJsY4iTl3skV6h2IpQtWBg3k4UQAAIfkEBRQAAgAsAAAAAB4AIAAAAomEHafL2JGaVHClOOelAOfXceHHRN54fmZ5pBLmwqT8tm5H13bp3e0PCW4cj8pK4whacBWVMrUS8oxE0am3HGVZ2q23yROBmGDyUddMm87on5atIyOU1cy13rUTj3DkpbfhE/ZHVUaC0/V3aCXXxwH4ggUjlcZlRJlFBQQ3xLSp6Vn1FDIJRFpRAAA7", + 62: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAAA/wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACj4SPmWHBCuN6Ty4LXMNHN591TCWBFXWRkKeiyIg56jfDsW2vYXyVoP+yaGafDGtUI4poMgopp/g1nyilMSqbhJSm12lpfW5SwZWznEOWxrtrh71uE606eT3+tvfw7PP+nrcjFjb39tOGBSe4MQWU5SXShBjZGPEYSFkZBWg0Jfm35ynKNTcqmnliqoq0KloAACH5BAUUAAIALAMAAAAdABsAAAJyhI+py+0PTwixAuqw1WpKb2Ach4CXFIbjApIimrJmOWskfZ53vsN+l0t4apfbxChqvYSUke14VJWCUlr0E3P6oMGra6p7fYWoZTNG3WZtqh47DSd3f3Ewj95To8cy+1LXMDPXxMVwBUPItQPlksT3EVAAADs=", + 63: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAAA/wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACjISPEBi9Cc9L87kI1zRXevxVoaJsmMWRGvmBasOOqfui40rbKruZmc+bwXJDCkdHjJVOwJJF03EBO7jdLOajHhmw6PWILEZEXOSXgZU0W8Yleax779aeKaUqFS/vNLXjn6VnhMe2BYJjQkg3pmao1CfUcwYZNLSYIzRJmca5KdPpGfQZakZICXgniFAAACH5BAUUAAIALAAAAAAgABoAAAJ2hBGny70BVXpwOhmPNbPeh22c9o2kOSaZsyKueqKM6Eq2DM53WmsZDdtYgL/G0NTyHWedzsWDILKS0eaQZsRoPTCUMObL1ojYKpQbgVbF4F2FCi5/SyqnDld6xex5igjex/E2GAjSlVOo18OTeBcl2JjTUqZQAAA7", + 64: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAAA/wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAAChISPqcsbD2ObJkxL1cs71xR1B0aRInKSDaYybKmF57eC9IteOWBtOB0z8YY+4mj2Gw2NtuXNEXIAly3Pc1flTG8tVTf5FDaZVXCqu62k1B3vbOyEZ8dzYF3JlTjv+I93pzXV1hfIIyNmFeeSeHTBB/XHxng1qAgSJeKTySJRloaFNmlVAAAh+QQFCgACACwLAAcACgAGAAACDYSPEMur7wKU0akmky4AIfkEBQoAAgAsCgAEAAwACAAAAg+EjxYB656inPS8yzCupgAAIfkEBQoAAgAsCgAEAAwACAAAAhSEg2mA6+2inC/ZExjLPO+vLBYEFAAh+QQFFAACACwLAAcACgASAAACHkSOZ7AdIKKMa9L43tImBQuG4kiW5olin+QhFAPDBQAh+QQFFAACACwMABYACAADAAACBwwMiYrh7woAOw==", + 65: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAAA/wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQECgD/ACwAAAAAIAAgAEACioSPqatx4RKcEVRzn1w3MytNVsdpmJZV1NkgnroxkAs6dv2Z9N6G4szSkXSuiAhjAwZjuSXx6fFFn0iKdVo63bagprML/jauL7KMapUyfbikcnTrkshAVecqfQ97rXiWLxZGJWh0NANzxvOBhfa2thiSw5jXVjPJxJUUCKjleAlXp4gkyTn16dVUAAAh+QQFFAACACwEAAEAFAAUAAACP5SPoIrdEGIEroalQt3ian54GESBoRSZ0jKlJneNGerEMukhNlvC4/XakYK/ng8jvJGQLl+F8QpFhZ9opwkqAAAh+QQFFAACACwAAAEAHwAaAAACc4SPqcvtHk5MoVZqcb6Ayw92zCZG1mSc4XShKZt1bPq+Z4xyrozEvC+yAYWeIO1o7N1CyN6o1Ng1IQup9am4Oim1LXerknmkU7Im+qWqla72g3yLm71dLMRtguYfRH1pnvWRN5i0Rmgyw7ejUgTIRDMkVQAAIfkEBRQAAgAsAAABAB8AGgAAAnSEjxi76XpCkjCyyWQDehr6RQ/XgN9lbZy4Zu65xSEJWyQoK+aNzr6746lWLKLR0/Epi6Pmchl8HplBSrTq4dUqWeYDN9pFMeNp2euoDk3nKQzYa4rPbZqog3eHM63+0GmUJwhYNJgDOFfCRuim8VfX6BVUAAA7", + 66: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAD/AAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAEACjoSPqasR8J6JUCK6HJx69+NoYlZFYWlaFcO2DPWNaoJdtjo3mWSNoA/auIbEoo7UwQAvtZ/r9BJ6UNTmsTFLBq9YjhfH6U2mxqC1jE6r19hUifVhOr30bc5kc+bG4B6eGiUmNsYXcifV1Le3grPkEcc1Z8gDRgM3pZSnGUUIdJZV9xfmJwTD82bWeMaWUAAAIfkEBRQAAgAsAQAGAB8AEwAAAl+EEYG553+UYxI1iFlLlF8cLV4YjaCkpB9lgYaaovFrZq121hDc9pV68gFHM07l5espZyUWymIU8TLAy/F23T00RpkLuQ1PvkoS1Awe27o3tDutPmazSF6ns6Wn9fBXAQA7", + 67: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAD/AAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACeYSPqcsY9x6IsCWJp6G6284FWfZhnBKRjeSpLGuJ73TKn6eFuVPatGMS3Xi603CjqvyOFxQzxnuuTNLVD1aFwIRZ5Oa7lKa812pKhjYOX1wf7paMYkve4pte+6rxu9EdSsG28yQ0kzNHCNSl1LJIBObYFFlhOMl4UwAAIfkEBRQAAgAsBAABABgAHwAAAmCEA6LLDGhenLSeihYMS85thR50SUhwjliUgmnpmk8re5+iKuQno7vfs3B0B03I1TCCRLti8umIQKfGBxWaEKBw1673Cw6Lx+SyuZslU8ZD3bgShlnFojqr1rTr96ZqpQAAIfkEBRQAAgAsAgAAABwAIAAAAnyEYwmI6/qOVI3CVivc/Ok4faJ3kSNYYhiarAvjBDDjwtEs2eQmx6/f4wRzJtDwQtPIaB2eD9g8rI5Sz6dzvUZLre02SPWmdOJWrVpm/n5a4WsJJzcz4GHbwgp5VU65G9fl13dDdBdICPWVWCgWlmOI9VjGtTMZCRkl2FEAADs=", + 68: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAD/AAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACgoSPqcsNAaGbKVpKI5K48d15gTGWIfMd46lYLttq5Aq7ttzdOu7sPo26bFIPXuVViRFVNoxQ+exFZzdSsjjFaozD0rKKo22n4J/XONb61EdOlSpDX5DtM5CdZdrr54mEPLd0pAWF5bd3RSilCGIlOMTY2Kcy6LbgxkX1QCkCOGcFUAAAIfkEBRQAAgAsAgAAABwAIAAAAnyEf6GL7b5ieBTFpGpldurHTKL3NRxWQtKVdtzarvJJzTap3jPIYjjQM8BMud/wI3HRNr1kRkjMsGBPHvAiu5K20pEWq3uGnOGuedwkm69fI/gsDPpGZ/rP9W1rkXb9UpWnxsfWRje4lbfHBAXUCBXE5fGSoKd0x1iWhFAAADs=", + 69: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAAD/AAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACkoSPqcvtD0GYM7pg8MHaJqpUXphx5oh0n4RuTCVC8KtxjwjXaRmv6SmxBUuk3RAHQvpcKpeR9Qw2nb8pUrh0qmpCK1T77Mwyw42OOjZ1k1+ytI0Gf2LT9tiOFtcp2K/4XXZEBYVDdrXVQ2TTpLMVwXUmxXZT9cdTV6SYCHLByXl5t+CY6PeZFeV2asZHCmraAlEAACH5BAUUAAIALAIAAgAcAB0AAAKChI+pyxn/mgyGHmqli1svG4WZB4wIRl6M2EDlCr5KxspV5aonBqJlfzvhfrhayGETKl+j3GzGiR6fSCIxhjQBg1cVZ2jtMqcQlM9l4tKCzrTWF6bx4Bf0WsYr5rZH7a0pxQRmU6ZDxWZY+JHlVPTxFbeTpDa3IwKZxmW49FPWqOdZAAAh+QQFFAACACwBAAMAHwAcAAACiISPF7vp7wKQylCI5607Rw2G3vdIzAh2SGOqCtWUFxOvCW3ZdT3dr2Xq7Wa+GcxXEb5cvdupKWSVSEpOrogErmDBHO9r7LbEpzFwN71Cocd1UttiJ4cy4jVmFrFw23Zc8zXSNbfGZAOoRiOVscHH9sS4hdjH+AQJWIbRKPLmeEj19tmnCKH4VAAAIfkEBRQAAgAsCwACAAwACwAAAhyEg2gb0HzcW642peSkdtPMHVO2XZJYoWTiRUYBADs=", + 70: "data:image/gif;base64,R0lGODdhIAAgAHcAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAAAACwAAAAAIAAgAIAAAAAA/wAClISPqbsBrmCYDyZ7nERUx3cZW+hx2aVRXIdlbSOmk1pZLyrLIMOrZcoLxTw2kfHm6uyMTFqwiLEhYccqM2jyHUfYU9Q6bbRGwG6MRA4nV7NTpetst7fYWREUf4vTeP37BqR1d+UEZnW2VdjHxvghFDUWp4TmEqG41KOoqTZkyclQNjQHh/i1o8YihXiKxNVKZRa7UAAAIfkEBRQAAAAsAQABAB4AHACBAAAAAAAAAP8AAAAAApgEcqaGF/iWapIp8QTAQs9kXYi3VUtAngyqotQFLt2GrV5DPU1tYiN1O3SGpopHcxQaRR8GR/Z5iSKpWwp0NcyQLuYmMyuKY7DxiVWRmqHfb3atNKvhKic9ZJmvszu85T3x0oFGt8OD85RTBgMhw8IRNOhIwuKSkuMzotVV4td0haSkBhjItjIWtBhK2iPRt3hXxhoLS9taAAAh+QQFFAAAACwBAAEAHgAcAIEAAAAAAAAA/wAAAAACmAR0pofihpaKEqoQwwl6JnshnYGVkjAukZNS1PUtHMCtKOg+9Cs/GJxAcWaVSkdz3BhDHogJGCxifDLniSRF7n6kDItYDIOq4tOtwitLjqKzGp0Kp99XK30cvZNV2JglbibzdJfBtWLiAoXV0IMk9MfVNXKD4hZTSbWV0VQXp0W5VKbTBzEH9DKiBVgWt6mo17cKGzorplEAACH5BAUUAAAALAEAAQAeABwAgQAAAAAAAAD/AAAAAAKZBHKmh+GGlooSGiGCAFnLNi0ZV13fVkUOOo2U+V4bpnrU/XCx0um8pcFgShXUDMb6XW4tjzKx0z2SKGeIVDxmRstlMEks7cBhBjlRDhsR2zTRGo66F7dznI6ei1KmvMUO8UIDKCajAtHG1PcDwuOxVcXBtcRi03Z10MFGGVFZiPWzYVOUlrPIUBb5pKV3ikbVSgoam0qbtlEAADs=", + 71: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAP///wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACfYSPGJvtb8KRsDaqrAY49u1Q0ghWI0Z+oCqqm3hFXDmj4TvnTJ65/Q18kBILH09ozEyOsY7LKdQpY7JotcZaPqUQ2JUoS9qYNZ7RS+ael9/qOAj7jNHUNX0XZofe+lY6WMZWpDFk1rbC5UYjBXWIKOdIGPnXNZVHk3KU+VAAACH5BAUUAAIALAIAAAAdAB4AAAJ0hI+pyxnfogqHSmndZdnAvVjUCIbAd6bdtaZn1k6erHIIOdO26PFaXNNpZK0H0LVCRTo4l7Nigt6Q0+gz5xwVoUxqw+flHbNYEuxbroJ1Z9zZlnNL18OrvNJ93/TSGWT8BCai5IDyBviD5cXiV3WFoUi2UAAAOw==", + 72: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAP///wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAEACiQyMpwnt35JU8ISLqzPaIpxFFMSNYvmV4jOdlfqanedd883WcMcs/gT8CXu4zfAGsuVcyKQyhgPpbDtNcnMlFa3G56zlc8FQx6D5WJYh0+DiecwKac88anREnHqXaqyzutJklwEomBKSJ6in5Yanw7iVc1goJtOTaMTUNSckGbZZGVQZylb6xlYAACH5BAUUAAIALAAAAAAgAB0AAAJ8RIx3wJ2tXpzIQYlptFxnzFne8jgkc6KfeZnBe3lh+NZbVc7uzaopbYP1QLNgbajrGE+kX3GZciYNsOB0elRUr8+qVYr1HnFcSNaWK6PETfX6PFa5N1a5Wym8dxJx0dwM5ud0k9eCJBhTBjay4kOGQzHE9OjoyJj2wXhTAAAh+QQFFAACACwAAAAAIAAeAAACfQwMl2rN7xaC1Nkl872JY+xFX/d0kziNoEKWGtuS6TGvYIDHp5rdeK5C1GASDy/4+SmHxx5tCWxKoVHpUfmsWoO55fbaxX55Ye949Msyz+n2Gf2kvFfd2LxCvJeGazKjn9QkAncXoifzYqMoCLOzk7fxYsQSWYkX4Xip2VAAACH5BAUUAAIALAAAAAAgAB4AAAKBRIx3wKwJn4TNxTtztVX7tmwghlhhKG5fl46s1qbBvJwjGhv0LNp4SyuxTELZLujK9Y5I4S/G5A2VKt6RmgsqrFig9fqkanecbuerLZp1W9/agUaFswny9A2X4lV16Rx7oqf00OMkCATlpJaI+DFxo+aGYwNZKElCAel4odm5KVEAADs=", + 73: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAP///wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAAACiYSPacF6HJxcAMYF65T3NdRtYPhFmah0lqmhqclqn5vMakg/4J6ftd6zvCi01QxYvJyOSlGmAauUXMufEOfAyrJa3o6FbaY4wiEnV+v6UCQt0znK/rxEDO6exlNIo7Z0DoVU51OlowI4IbaFpHb2x4jW99XyyAW5GMjm0QJG2QME1qVJ2Rlpd1AAACH5BAUUAAIALAQABwAZABEAAAJBhI+Zoe3HTHShSmSfrHlpwIXKNEbchjWnxbCZCb2eCINfmaq2Ws82idqVTjziTQgCIpck4yUGnLRyqM6zg832bAUAOw==", + 74: "data:image/gif;base64,R0lGODlhIAAgAPEAAAAAAP///wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQEFAD/ACwAAAAAIAAgAEACkYSPGQGrjpZkx8HGJk0VbzoZ1sWVonSGJbqmYqW1Iwaj6rp5Hpub+D3zsWqjIYhIcmWKJlsq+bxxlkmSpteZDXfYlq8R/QpjO3FzyzVPdc40cUoNgmll7JUHybfhdPMeD4iW9bL0YAM1eMH0drZ1BUbGF/cR1RUxpxXpx1emo4ZDKPUZ5jZKymaqFCGqJqppUAAAIfkEBRQAAgAsAQAAABUAFwAAAj6Ug6bLh9HiSgDICA3Id6rUheIoWE0lckepmKvGmKj3VXZmfw3Ex/oOIpFUw41Q5zoqW0sNJHmEkqQjalVYAAAh+QQFFAACACwKAAcAFAAUAAACPZSPGcktAJw8ccpqszZrho6AEwR8nxWQ5kdiRwqtLKmopRmLAuyeDX8zOW5BoUcBk/h2rIzrsUk8o1OnowAAIfkEBRQAAgAsAQAAABUAFwAAAj6EL6nLctDiMqHKCGqFl+XNdeJIBpElhgmlmUroKgHrTe3Mxur6MDpmIAlfw9esuEIhl4kYcqZ8Mp1DanVYAAA7", + 75: "data:image/gif;base64,R0lGODlhIAAgAPECAAAAAP///wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQFFAACACwAAAAAIAAgAEACgISPqcsQ9sJzbs6WIrJ0n8uAHhZ2mSSSIwShbIal3Oeq5pvaN03ljcZr7WySDgcl8n2GPc+sdGI9la8RVZWs6mAVI3DrQ26XsmJxbFZcSRcL6AxuVjQRMbZ9/hrZ0a5VCceTJ0eVBCTDtMTltvKjpjWmBbfmaBXpZHkppajZiVEAACH5BAUUAAIALAMAAAAGAB8AAAIfBGKJeryHYkuT0fXCa3n7ql3VSG4lRZ7iakhWO5pGAQAh+QQFFAACACwDAAAABgAfAAACH4RvgaCnzWJ6EabVsmR0IrtVjtVdH4ae6mo66UWecQEAIfkEBRQAAgAsAwAAABAAHwAAAjmUYqnLiQZMAM9FeRuKG1eZcFcWHlDjCCTKtgvllvFMa/A80bdLrfUPDAoVu6ExOPmwerjiMjfzLQoAIfkEBRQAAgAsAwAAABkAHwAAAlCEhanL7Z9AALDaiyTFS6LALWBIllyAToYxWer6etaqyZcasySsZ+1dU9geI8cPwhMNO7nlDJcMxY4YVmpToplc2K33C35ovpOiaewtg82hAgAh+QQFFAACACwDAAAAGQAfAAACUQQiqcvtD1U4sdqbJsJsJsAxYEiWnIGmVHUE7qReMOphRwrX3IxKq3X7CXSQ0UP40CBvEF6Q5LxtTkGkxYUzDV9a1rQLDos71hCzqwGfu0ZSAQA7", +}; + +/** Beast ID (1-75) -> data:image/gif;base64,... (shiny variant) */ +export const BEAST_GIF_SHINY: Record = { + 1: "data:image/gif;base64,R0lGODlhIAAgAPUgAIr/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/3P/cwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAgACwAAAAAIAAgAAAG/0CQcEgsGo+fo1IIaAKWUGVgSg0crdboUMDtCqLf6IA4GBvN2iGBAGKvl+50gThPaw1EvBKvtx+Gf3ZKCAhGhIJDCQkgiotFjUeORAqUIJWUCpOYmZqcQgsgC6KhoqWfpaNDqKBFDK6vsLAgr0MMs7dCDboguru9v768Qw3CQg7HDiDIxsjNycfKQ8lGDyAP1ULX1tXX2NrYUBBFEOLkIOJC5ObqRxERiO7v74ISIBL3+ET3iEITEyD+/AEk8g8RhYMUQBxUmJBfkQoVQECUCDGiQyEWQFjYyLHjRRAXQoocGfIjCAwoU6o0mQFEhpcwX7r8qEEDiJo3cda0yW+DzyWfG0AA/emQg1GjII4qddgBRIenTqE+bQpVkIerHoZkFYIVa5EgACH5BAkUAB8ALAIAAQAeAB8AAAX/4CeOZGmawHkGbKB+7lsKdC2Y95i/Q+8PPJmIQCIQhcICqaBEygwk6EsqPJCsL6wTMeKqvK9EwiRWjU8KxSdtSqtLbtJi/qHTR/O8PL8QMT4MgYCBgoOEhYCJfyQNjY6Pjh+NkiMNlB8OmQ6YmZyan5yYI5sjD6Yfpg+oqayqqagvEB8QsrOytLa1tLi7JxEkEb/BH78jwcIqEhJOI8rMIhMfE9PUJdHPFBQf2dnbzyUV4RUf4eTj3yQWFh/q7Orr6B8X8hf19vbxHxj7/P0Y8Rk+ZBhIkGA+DR80KEyoEOHCZxsifoi4YWJFihWZcdjI8QPHjxyYdRDRoeSHkiNRDpJE4qGlyxEeYLpsWSIEACH5BAkUAB8ALAIAAQAdAB8AAAX/4CeOZGmOwHkGbKCa7inMtPCK9jvs/HD7vheBQCIKb59CIZlcvpw3A0mKRB5I16oWIeJqR4nEJ2win8QjhfqjXpfaJvhnMV/Q7/SRfU/a20kMgYKBIoOCIwwfiYkNjR+NkJGQjw2PI5WVDh8OmpydnqCfmyOaJA8fD6eoqaysq6eqKhAjELO1H7WzuLm7uiMRESTAH8PBv8VfSBISyRMfE9DRJc5fFBQf1tbYySQV3hUf3uHg3CMWFh/n6efo5RcfF/Hy8+UfGPf4+RjlGR8Z/wAB1tPwQYPBggYJHvyyoeGHhhseRoQYUQuHixg/YNzIQUsHER1Cfgj5kSRIJB5SCqoc4YGlypQkQgAAIfkEBRQAHwAsAgABAB0AHwAABf/gJ44kYAJkqq5f4L4BK76yYN9CPebsMJC/VfAzVBEIH+RRdkTKPgVS9En9GEjXqvYg4mpHCMQnrCKvxKOE+qNep9oq+EcxV9Dv9JF9T9rbSQuBgoEig4IjCx+JCwyNDB+OkZKQj48ilSINmh+aDZydoJ6bnpkpDh8Op6iprKyrp6osDyMPs7UftbO4ubu6IxAQJMAfw8G/xV9UERHJEh8S0NEpzl8TEx/W1tjJJBTeFB/e4eDcIxUVH+fp5+jlFh8W8fLz5Rf29/j25R8Y/f7/+zJ8yECwIMGB5TRo+KCQYUOFC79smEhxw4eKFJNx2LjxA8ePyTp86EByZEmSIksNVvHA0sMIlyJatiQRAgA7", + 2: "data:image/gif;base64,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", + 3: "data:image/gif;base64,R0lGODlhIAAgAPUdAKD/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/4r/c3P/cwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAdACwAAAAAIAAgAAAF7mAnjmTZfWaqkl7rvq3prSWg2iRg43QXqL9RMNgTCY7I40hZNA0GpKeURqgSVNdRNmUdFb7gUoE0JoO/JYOhs1az1eu3G96Okw4ifL6jP/T5I38lCCKEhYcjhoYdiiYJIo+QIwmUkR2WkZYjCiKcnTSeHZ6hIwsdpqcLqKciq6qopqsjDB20tkW3tyYNHby9JL6+IsG/KQ4OJMgryiLHTR0PI9HQ0s8mENjX2dYkESIR3h3g39wkEubnI+nlE0Xt5RRF8eUVRfXcFs/51hfP/dYYngW0luFZQWsaniXktmEDjYblRnCYSLFixIsmQgAAIfkECRQAHwAsAQABAB4AHwAABeDgJ45kaY7eqZbA2bbrGMx0PctxKaj72OeigUr4GRCBI4JyqRQRkKZCgSQVTaElA0lr0KoO4MOXJP6CP4i0Oo1Wi9btNVuUSHzs9Dsdb8fr6yQKIoKDhSOEhB+IJAsijY4jC5KPH5SPlB8MIpqbMZyZnSMNH6OkDaWkIqinpaOoHw6wsrE5sbayJA8furu5Iry/wcAjEBAkxivIIsVAESPOH9DRWCMS1ibWEtQiE9zdHxPf39QUJBTlI+hYFUDsWBZA8FgXQPRQGPdQGfpQGv1QGwBi4QCEILUOCBMqRLgiBAAh+QQFFAAeACwBAAIAHgAeAAAF36AnjmRpisCpmgHrtSspzHQ9i4KXx+Og+iQgz0NQFUnHoafAbDJLBeXIYCBVPVSqlHTgHrpbE4I0DnsS6DM6IVqz1yaFfD5SeOx3vB2fz9sXgB4LI4OCJIWFhoCJDAwejiKQj42SlZMkDSKZmjGbHpueHg4iow6mI6OiqKepqSIPHrCyQ7OzIxAeuCK6u723v7wiER7DwjHFxMklEhIkzSLPzx7S09QqE9gm2BNmHhQiFN/e4uJhFSQV5yPqWxZD7lsXQ/JbGEP2Uhn5Uhr8Uhv/tnAYMjBMh4MIEx5cEQIAOw==", + 4: "data:image/gif;base64,R0lGODlhIAAgAPQfALf/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/4r/c6D/cwAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAfACwAAAAAIAAgAAAF6+AnjmRpnmj6dazqnt4Yv/QHkHftBsHX9zqVgDQMogamAdJIInycJijzUyhQTdbpx7DtkrjTw0dMLomZCFE6XWIbEx+4vARnKj6K+720Ny4+f4EigkwMDB+GiCOHh1MNH4+RIpKPRg4il5eYH5pGDyKfoaAfn0wQH6enJKlTER+uIrCwr0wStiISH7m7uloTIr+/HxPETBQixx/HycrIUxUi0NAf01ofFtci2NncQRcf39/gIuLkQRgi6OrpH+hBGSPwH/DyGfbz+Doa+x8a/f37+BnZsEEEQYMFExbUwaHhBw4PIT4UIXFiiRAAIfkEBRQAHQAsBgADABYAHQAABc1gJ44iYJJoOgar6ooCGb/pMHT3TZMEwfe7TuE1pBk6hiNK+TocRE7S84UQIaoprCrR4Xa9I3BKMSKPX4vOIr1GpV2MTjw+mtManQZeL9rTHB2AgCOCLg8dh4iIiYeJKhAikJAjkpEpER2YmCSaLxIdnyKhoaAuE6ciEx2qrKs0FCKwsB0UtbQvFSK5uTsWI74dvsDAOxcdxsciyMsoGB3Ozs8i0DsZItbWHRnbNBreHRrg4N7f4eAbIhvoHerp6O/rJBzzHRz19vUi+CQhADs=", + 5: "data:image/gif;base64,R0lGODlhIAAgAPUgAIr/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/3P/cwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAgACwAAAAAIAAgAAAG/0CQcDj8GI3EpHJJBCQBUKY0GRgGqsLrdCsQEL3C7lY6KA+U5vMYRBi22YS3Oy6XFpJ30D0vLPj9WwaBgkKCBoRSB0qKB41JimsgCAhDk5RLl5EJCUObTJ6RIApJCqWjQ6ahC0oLrUOtsGsMDEy0QrO4tlINDUy9Qry/ILxSDg5Mx0PGkQ8PTM5DzZEQ1EsQSdeRERFL3ETboRJM4kTkkRNL6EQT6kns7+0USvJJ9EQU+Pn6IBUVSf7/AArpR7AgQQsWiCRcghAEwoYKHya8cGFIxSUUhWTEuBEDBiEfmXgcM1JIhgwmmZxEuYWlEA0wNUiBGUrJBiYbchLRGYkDEx4OQIX4BDF0SAcmR5F2WEok6RAPTKBG9UBVKgirQQAAIfkECRQAHwAsAAABACAAHwAABf/gJ44kYJ4Aqa6sGLDB286jUNs3TQ8D2Ys8no5FKBKIxuNwVBAVnqqntLkUGayfK0lr0FZXh8NI/J0hVOdhgrVOrFXupUJBmtNZ9rtuQVrwP35/gIGCNAwqDImHI4qKQw0NKpAkkyORQw4qDpkjm2UPoCQPKqFLEKenJBAqqUsRrxEqsSSvVRK3LBIkuFUTEyy/I77BSxQsxiQUyCPKzSsVLNAjFdTT1NfXOhYqFtsi3eDh4DMXKhflH+fq6+wsGCsY8R/x9PX27yoZLBn8H/z9+f5pUDFwhYaDAwu2OLhhAwmHLBo2HOKQg0URHGZYvIhxY4sOID90oAFy5MgRIWcKeFjioaWKlR9CAAAh+QQFFAAfACwAAAEAIAAfAAAF/+AnjiNgnmSqrmOgBi4rk8Io1DY+s8NA+qJeb7cifAhGFXJJJBVEhWgqSn02RQbsJzsycL3ca+pwGJWJiF2atCYmVO/EOyW/KkiKPCuv3y1SC38fgSSBhkQMKgyLJIuOjDMNKw2SI5QplTIOKpsjDp9iIg8poyMPp6EfEBAkrCOrq6ERESS0I7OzoRISJLy9u6ETEynDI8LCoRQUJMvMyqEVFSnSJNHUVxYWKdok2dwr3tkiFxck5SrkK+Tr7BgYJO8q7vEi8+4pGBn6Ivsr/R/6ArLQQLDgQIIfCiKUsaGhiA0sHDacGIoDCw4WMVocoXHjig4dWID8MFJEyBEnVwt48MBi5QeWL1WEAAA7", + 6: "data:image/gif;base64,R0lGODlhIAAgAPQfAHP/c4r/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+QAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAfACwAAAAAIAAgAAAF/eAnisBojuWprl8QsC4rn0ItjPesDyfPf4MfUDgjfIzGIzJJaB51n8JIWqhWo9CTwWDifrzfLRc8O5zM6E9azc6OECL4CU53ixKJD16/59/tCgofgoMmgoSEdgsLKowfjot2HwwjDJaUmJWUbg0inR+foKChkiIOKqcfqaUfDyyurCMQECK0H7S2sRERH7u9vL2xHxIzxMITyCsTwiYUzR/OzCIVIxXU1NIfFhYi3NzZHxfiF+HgIhgmGOgn6utuGRkf8CLxI/XzdhoaI/v7Iv3/7GwYMfDDhoMDCx6UxOFDQ4ciGnKQCFFShw4fMGYcofFiLA8gQ4L8ENIclBAAIfkEBRQAHwAsAgAAABoAHwAABfLgJ44jQIrmSQbB2brrKYjCTI+1/eUqOYy/H1DYOxFEhGMyWWwWns9PoXkyGEhXkfWzLR4Oou/3Ay6DyUWESn1if9juXiLxmdPrd3xRwRf1FR+AfU0LCyqGH4gihVQnDI8MH5Ekk40NIpeYJA2ZVA4qn40nD0WkoiMQECKqH6qspxERH7GzsrOnHxJUurgTvj0TuCQUwx/EwiIVIxXKysgfFhYi0tIk0aIX2Rcf2yTd2VQYJBjiI+Ll5T0ZGR/rIuwj8OzwPRoaI/f3H/r8TRsj/z5sGCjw38CARTh8ULhQBEOGpzp0+DCRIsWKyDxo3NgjBAA7", + 7: "data:image/gif;base64,R0lGODlhIAAgAPUfAIr/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/3P/cwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAfACwAAAAAIAAgAAAF/+AnjmRpnugJqGk7BoEIxx/spoLw6fru97eBUDQYFYsfZJI4PBFEz+hHOq1Sn6fCqKDVfrzgr/eLMpDMBrQIrR6ZUYeDSE6Kl+h2F+Kz1/NRCYEkCR+EhCWGhYOCHwoijiOQjSSSkpOXCyMLmR+cnZybmiKhoyIMJacfqSgMp6umIw0NJLKxsre0tLMlDg4kviK9vSPAwcUnD8kiD8vNH8zPyjciEBAf1iXW1dMiEd7dH9/hEeHd4icS6SUSI+oi7CTp8CMTJhP1Ivj4H/f2IxQlKAAE+EGgQYIDCf4TUWFEhYYMGT6cGFGiQxEWMlogkXGExo0YQYbseOLCBREnP12YNIkSZcoWGDCMiDlTpgiaN22ayJCBRM+eJ376BDpCQwmjIpCSUKo06YgNJDZAFQG1atUPU7FmxSqCwwivX71yADv2Q9mvaD90WNsBxVoRb0+wbXvDg10Rdj3cCAEAIfkECRQAHwAsAgABABwAHwAABf/gJ44jQJZnqgaByLYfq86fINQ4ft/0OYy/30c47BGOH0JyqWQykaeCqCCVfqzYa/ZkGHUNX9E3LE4dRmfSIY1upxCIT7wnl89niU8+f9rrUwqBJAojhIWHhYELIguLH46Pjo0jkpIMJJcfmTMMl5uaDScNoSKjpqSloh8OrCQOI6ytIq+wsiIPuA+3ux+6vbe4dBAQH8QnxMN0EcsiER/Mz87O0dMjEtcnEtbaItzb2hMpE+Ei5OQf4+IUJBTr6x/t8e/u7yIUFfj4IxUi+fn9+/ypsGBhBEGCBgvSuXBBRMMPDBk6dPgwBQYMIy5mxChCY0eOIjJkIDFypIqSJEc4ajixUkRLEi9futwwYgNNETRz5vxwk2fPDRyCciAR9ENRo0OPihA6tEeHDiKe0unhoaqIqh56hAAAIfkEBRQAIAAsBQAAABYAIAAABv9AkHD4GRqLxqQQAFgynUpjIACiUqvYa1Qw5HJBX3AUNCCby2ezkiBkg9zwdrJQENJBdTw+fx8aQH9GBoF+gEYHIIhjQ4iKQgiPiyCQk0kJCZJCl1EKQp1Jn59RC0KkQ6amQwyrIAyqrq2wrbEMDUK2tou4tw5JvUIOvyDCwA/GD0PIScogx8wgEBBC0dPS0NZDEdrZQtsgEdnbEknjUeVDEhNDE+pC7e0g7OsU9BQg9vf19EL2+kkVQioIHBhwkQULQw4eTIjQyIWHQi5EfCgRREWKQjAMwaAxY0cQHDcKyUAyAwiTUUyWRKlEQ8tMQjaAkLmB5sxMHDiAyCmEJ08QmB06CAkKc4iHo0KOeogSBAA7", + 8: "data:image/gif;base64,R0lGODlhIAAgAPQcAKD/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3aVz6Ixz9H9z+Yr/c5hz7nNz/7Fz4wAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJGQAcACwAAAAAIAAgAAAF3yAnjmRpnuiGrqwIANyLvnBbBhx+Bjxvl4JVUCQY/lqDASepPHIIJ4J0BHVyCqYCVnu9cn8GkmHMGZvL5xG5dOC0RYe2fO52v+MoBEKk5+z9gH98fn0nCQkciIiJI4qJh4yHiyUKlSIKHJgmmpWamSgLIqEko6OiHKamJQwjrCKuJK6wHLMkDSO3Ire5Dbm6vysOHMLDJMQmxygPIssrzRzPLRAc0yTV1FYsESYR20cSJeDZ4yQTVhQs6Bzq5CQVKO/tIxYi9PTyFyb58vwmGCf/+gm0kcFEwYEoNCDMFgIAIfkECRkAHgAsAgABABsAHwAABdyg521iaZ6oCQDemrbuWwYenQY4LpeC3IuC3042GHiKxh0hRWiWlsMCqiCleqpWU9ZgMng93jBYLPp6DucSOn1At9ftc1yEQNA9dbsez+fnSwkJHoKCg4YihIaFgSIKjo0mCh6Sk5OPJZQeCyKbmyWeJp2fJQwipR6nqKqrqaseDQ0osbEptLQiDiW5uCi7Hru+KQ9DMhAixijIxCIRHs3LzNAeEiXUJ9YmE9Ii2jsUIt8e4SXj0BUy5+fbIhbryxfu8SYYMvTEHCX4+PLEGSX+LzQQEyivQwqDKEIAACH5BAUZABsALAIAAgAbAB4AAAXm4LYBYmmOAHmeQbC169vCcSlsd5zjez3Um8FP+AMCCcgSwSgqrApO6CYqNTlFBpNhu9l6u18sd3MwlQ/nM1mEJrc3CLgoPq/L6XGEvpRIbPx+fyKBg4KBfSIKiolAChuOjomRCwsrlSKXl5glmgwinp9MJqAiDRumpzGoqCWsDiKvG7Err7MrDzW4JrobvCYQRsAbwiLEJhERxyXJokASJc8bz9FAEyXWItbazUAUJd414CIV40zkG+foJhZG7CLu7twbFzX08h4rHvgi+/JAGEY4mBA40J+JDDUQGtEggqHBGh0MhgAAOw==", + 9: "data:image/gif;base64,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", + 10: "data:image/gif;base64,R0lGODlhIAAgAPUgAIr/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/3P/cwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAgACwAAAAAIAAgAAAG/0CQEPQhDo/IZLGYFAKOzycyCm0GhoHrFaQVdrncLfgoGArKZVBamEav18eBHDRA1ul2+ryJJAgJgIGAf3yFQgWISYgFho0GfI+NTQeUhpQHkkMICEecmp2emSAJCYakokkKfKpHCq6umQtJskMLtre2mQxHu0MMv8C/og1HxEINyMnKog5Czc7PQw7TqCAPD43XfBDcQxBJ30Lc4SDkSRHoIBFC6Onq6u7shhJC9PX2IPb49YUTQv4TAgoMCMJfwSMGk1AAsZDhEAoNHTpsuDDikQogMGqswLGjxowgPyaxAIJkySMWTAohaZLlySMXQFyIKSTmzJo2h9DMiQQDCEmfR4BiENqT6JEMIDIgrYZkqRANGkBE5QNV0lQQG7Bu2MoUSVYhHECEHZuEg9mwhtCC6LC2LVshHd7Ghfs2Sd1GHjwcycuHL4ggACH5BAUUAB8ALAEAAQAfAB8AAAX/4PcBo2ieaEqSaGC6aQx/Myrcn5Drtu7jMdNgKPwQB0JikMAkfJwnKNTkbE4/hVQWW+h6t9tTOGgop8qGYOzAPnzc63dbbUKI7Go8ni5KnPwmgH19CYWCKQoKdIkiiY6MagtBkh8LlpeWfB8MKZybDKChoZoNJ6UfDacmqap0DievQQ6xmh8PIrd0ubUfEBCavykRwyYRwsXEIsYxEs0fEiLNzs/P09FqEyLZ2tsf293e4SkUIuQU5+jnH+Tr5e0pFR/x8iYV8/T09vkpFh/9/xYCCvznr6C/figufFC48MQFhiIUQpSIAsMHDBZFWMSocaMJjxdPZMjwgaRIESNRN6IwWVKEhpcwg7zUpEHEhg83c/KKcfMDB59Af6LgQFSoGqNqOnQQoZTp0hRNNXnwcGJqEKsfQgAAOw==", + 11: "data:image/gif;base64,R0lGODlhIAAgAPUgAHP/c4r/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAgACwAAAAAIAAgAAAG/0CQcEgkAgBF0DHJbAoDSahzOhRUrUIstTkYDr5dYfi7JRAJ6LRaaDZPC0y4sCAHwetOQ1PPHxr6TgdbIIJJhUwIWwiJRYmMSQlOkQmRkJRMCk2ZIJucmwqZnUULSQukpKWoqEkMrEStsEWtTQ1FtbYgt7UNt00ORb8gwYNMD0TGIMjIycyDEEPPQhDR08/TxBERINpC3NzERBIgEuRC4ubh44MT7BNC7kTwIPLgIBQUSfhE+lQVFf1C/PmrN8WCQQtCEBJMcoFJw4VDMBSRKITiwgxFMFLRwFGDkI5DPDLpyDEkiA0nN6BUybIIS5UpVwqByaFmTRAccOq0idNmTjGfOXV26ACCqNGjRZMaVaoUqYenHoRAfQoCatWpV61eFfKhyIevILqKDUuWSNchH4IAACH5BAUUACAALAAAAAAgACAAAAb/QJBwSBQCAEXQMclsCgNJqHM6FFStQiyVOBh2hYPwF/QNUwlFgnrNFqLR0wJTLizQQfJ70+Dk+4cGf04HWyCESYdMCFsIi0WLjkUJU5MJk0mWl0UKTpycQgqfoSCfRQtNC6enpqurSQxMsEOwskS1SQ24urm8uU4ORcBCwoVJD0THQsnJIMfMUxAQQtLTINTR0tFbESAR3kPcQuHFQxLmEkLmROjlIOzFExNM8kL0hRRU+ET6VBXkQhX8/WtioWBBIRYGFrugsAgGIg+FRGyYgUjFJheFaNioQeNGjU44fgS5AcSGkyZPoiSiEqVKk0JQcpg5EwQHmzhp2qR5k+dNLpwdOoAQSrTo0KNEkSI16qGpByFOm4JwOjVqVapVhXwo8qEriK1gv4olsnXIhyAAOw==", + 12: "data:image/gif;base64,R0lGODlhIAAgAPQeAIr/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XP/cwAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAeACwAAAAAIAAgAAAF/6AnjmRpnqgIAOfqlm/qBTQZzLhN16ngCUDgT+QbBY+ywaC0XJKUUKWMkCJYR9asrFAqcEdfsDdlMHQ9ZpF5LVMfDiW4CS6XITz3e1uE0KcSgIGCeCSAfAltCh6KjIuKhYsjj3skC5KWlpGZMgydHp0MI6GfJaBtDailpKWplCQODiOxsa+wew+4uQ8eubyyvjIQwsPAwrwQJcgoEczMHhHP0M3TI9InEs/YzyUS3djd3CYTHuPj4uUjE+rr5iQUHu8mFPPxJfHzJxUe+vsV/v4i+AXsB7CNBQ8HDyIkYSGhw4YyLniQSJHEhYsYJ2ZMgcFDx44kMHwE6VHkngweUDGiHJGh5UoRLl+6IqFBw4maNmeS2MDzBM8NOjlw8CB0aImhQmd2INqhqYmlUHVK9RACACH5BAkUAB8ALAIAAAAcAB8AAAX/4Cd+3mia5amOALC2rQqvQXDa+F3XqvAJQOBvaAoaVYPBSak0JZ9JFWElIlhH1qyqcCpwR1+wt2sgl0XlNPXAPh1W7zf8g6BTVYg6PsHv80UJJn90gSoKH4eJiIeCiCOMJwuOC5SSIpSOk3cMnCoMl5GddycNH6WkDaejIg4OI66uJq2xKw+2tx+4D6+5tRC/v725EMMnxMYfERHJycvNysojy84iEszW1tcS28nZ0iYTH+HiJxPmI+bp5yYUH+0nFO3vI+/xqxX4+SYVH/n8VBYCChRhgWDBgB8EFjxx4UPDhg5HXJhI0WHFExg+ZNw4AsPGjCI8gjyR4UPJkiYyK6hEKWIly5QmY6bUsEKDzVUnNuhcoXMDTg4cPgANmlMo0TsdhHZYqiKp0xAAIfkEBRQAHwAsAgAAAB0AHwAABf/gJ45k6ZVoCqQfsKLumwYoTZdBnrOCQPrAX2/oKw0+g2QSKTqOlNAUgVCiUqvTKavA+hS+pC83ZSgZyqMyuvs5HMztdJyNqJcQKbw+/0n02SQJfikKhYaGIgqBin2MKAsfkJKRkCSTiYCWIwwMkSKdnSwNH6MNppufJaajKQ6uqqQorg6ZIw8Pth+4JLe7KBDAwcC6wxC5xsYkEcvMER/Oz8zPyigSz9bTEtba2tcj2yQTH+LkJRPnIufiI+siFB/v8CUU7/Hw9Pj2IhUf/CMVAAOS4OcPIBsLCBGKsLCQYcKEXS58kEhxxIWLGDFOZIHhQ8ePIjCI9DhS5EgWGVIvphShcuUIlR8y1GKpQUOKmjhnftjAswvPDYA4cNgpdCiKoULZdPjQoWnTFEujhgAAOw==", + 13: "data:image/gif;base64,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", + 14: "data:image/gif;base64,R0lGODlhIAAgAPQeALf/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/6D/cwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAeACwAAAAAIAAgAAAF/6AnjmRpnmiqrma3umwJkMDs2SIee0Eg9j2eT7gjCY7IJLJYGjhFA+iTaSJYrwQqqsD1cAvak6E0JpeZh1Fa7Tm4tYhRnISoMxMefGKf7+/xTAoKHoMig4KHhEULCx6NjI+OjFQMlZUelpiWDEwNnp8enw2hokwOpw4eqKiqp0wPHrCxD7SzsLdFEB66EL29Ir+8OxEexMURyMTII8oxEh7P0BLT0iTP0SoTHtrb29rcJd8rFBQi5OUe5ybl6CkVFSLvJPAn8ioWFiL5+B74+/kj+Km4cGEEQQ8EE4ooiJChCgwkII7AQFGERA8XU2QgkWGjh44bQ47wWETDCJMaUhd6MBnGw4YRG2K6nNnSAwebNjncvMkiBAAh+QQJFAAeACwFAAIAFQAeAAAF/6AndmJpjqcImMDquWoaBOI8ezdOp0Lv/75UaUAUDYxFoYnAbBKUqYLUIy1ErSdDtqQ1eIWHcPgkPiFEiHQa7VGnEgkRPO6Z1+8lhcKzN+31fSYLg4MehIaECycMjI0ejQyPkCcNlQ0elpaYlScOHp6fDqKjnqUmDx6oD6urqa2qJhAeshC1tSK3tCYRHrwRv7+9vCK+IhIex8gSy8omx8kTHtHT0ynVHhQU2Nki2dom2t8VFR7jJuQp5h4WFuvr7ezw7SLsIhcX9vj3+/Ye9yUYAJrAQFBEQA8HPWQokWGhwoYKI0o8oaFERQ0YPVSEsqHEho8eOnaE4oFDyZIcTASaTBECACH5BAUUAB0ALAUAAwAVAB0AAAX3YCcCYmmOpxiYwdq5aioI4jx3N06nQ+//vlSJQBQRjEWhqcBsFpQpg7QjNUBPB2zqkE0hSl9wB0EWJkpnU2J9UnTcivh7HnefFotOXpTH9/UmDAwdg4KFhIIpDYuLHYyOjA0nDpSVHZUOl5gnD50PHZ6eoJ0nEB2mpxCqqaatJhEdsBGzsyK1siYSHboSvb27uiK8IhMdxcYTycgmxccUHc/R0SnTHRUV1tci19gm2N0WFh3hJuIp5B0XF+np6+ru6yLqIhgY9Pb1+fQd9SUZ/iYyCBTxr0PBDhpKaEiIcCHChxBPbCgxcYPFDhOvcOiwkUPHjSlCAAA7", + 15: "data:image/gif;base64,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", + 16: "data:image/gif;base64,R0lGODlhIAAgAPQeAIr/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+QAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAeACwAAAAAIAAgAAAF/6AnjmRpnmg6AoCaBnBQwiI9xnIqiMLem72fZ+cajIweZFKkVLoIIqjUM5VCXaSCNrUdFbAkg0dMHofNYvBBdGizSes4WIQo1Un1/FyUGPVNCYFzCoQihYUlCmALCyKNJIyMkFgMJZUil5gjmSgNIg2enx6ho6KlKg4eqaojDqupr6wpDx60Ira4tbe3ticQIr8jEMHAJMPFJxEeyiQRzs/Lzc4oEtUSJdck2SbbIxMe3+De4+Dh3uYkFB7q6iPs6xTvJu0lFR72I/b69/z4+XsWLHgIKLCgQBIHwVzwcGHhQoYNH4qQ6AKDB4sYL2q0OILjnhEZVITco0FDiZImTCLu2bChBEuXHlpi4UDzBE0OJHBi6eCBZweeIn72HPqxqIkQACH5BAkUAB4ALAQAAQAaAB4AAAX/oCeOpAgAZToGbNl6r8gGqeAJNl7juTqMP09QKBoOSwRRculhLpMqUWEa9VCrJYNHy92mtNWD6EAek8ToKqK0Jq3f2MRIXpLbVYq8SK8n5RUqCyKCJAuGJYQlDCSLIo0ej5ApDSKUlR6WI5mZIg6dHp6doQ6jnyQPHqipIqqorqyrIxAis7S1tLK2JBEevCMRwMG9v76+EscSJMnKJcgiEx7Q0c8j0hPSJdAUHtvbIt3cFOAk4iMVHuci5+vo7ekk7yUWFh7z9Pf0JPkqFx4X/f38/QsogmAJDB4QKkzIEOEIh1hEZMAysYoGDSUupsBYZcOGEh5TfFTBoSRJkyI4EnhQWaKDB5cdXIqI+bLmTBEhAAAh+QQJFAAeACwDAAEAGwAeAAAF/6AnjuQIAGU6BmxQsiK8tqUgCjae4rpnp4NR0DMkiorFFEG0bHqczaVqVKhOPVbqVWTwdL9eErg7PYgO6DPJzN4iSm/Se771JEb3VGJ/VfhFf38lClMLCyKHJIaGiioMJY8ikZIjkyMNIg2YmR6bnZyfJQ4eo6QjDqWjqaYkDx6uIrCyr7GxsCIQuCQQuSO9uL2/ER7DJBHHyMTGxyMSzhIl0CTSKdATHtfYI9na2NwiE9kUHuPjI+XkFOgp5hUe7iPu8u/08PFbFhYe+fr9+iT/plzwcGHgQIIFD4pQmAKDB4cQH0p0OIJiHREZtmTcokFDiY4pPG7ZsKEESZMeShaq4MByZcsRHKZ08DCzw0wRNmnqLBECACH5BAUUAB4ALAQAAQAaAB4AAAX/oCeOpAgAZSoGbFCyqzu2sijYt3CXum6ng1HQMySKisUSQbQkOD3OJnSpEhWuVQ82WzJ4vOBvyps9iA7oM8nMziJKb9J7zk2M7CW7XqXoi/x+JH0KKgsihiQLioiHKgwkjyKRkiOTIw0imJkempybniQOIqKio6WkHqclDx6srSKurLKwryMQIre4ubi2uiQRHsAjEcTFwcPCwhLLEiTNziXMIhMe1NXTI9YT1iXUFB7f3yLh4BTkJOYjFR7rIuvv7PHtJPMlFhYe9/j7+CT9Khc8XAgYUODAgiIQlsDggaHDhhAZjpDIRUQGLhezaNBQYmMKjlk2bCghMsVIFRxSFqJUKYKDB5clOniQ2UGmiJozc94UEQIAOw==", + 17: "data:image/gif;base64,R0lGODlhIAAgAPQfAIr/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XP/cwAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAfACwAAAAAIAAgAAAF/+AnjmRZeiJqrqwIAB/8xq0Z2GKg73i9Ch9gcOgrfgaDo7JFMIqa0KbTVCiIrB/sVes0eL0ksOEznn4O5/NhXUKzWYgSIv6h10f0ub2WSHz8f30ifYB/TgofiIkiiIqKjEYLH5KTC5SVJJZGDB+cIp6doSOcoDUNJQ2nqagfp0UOK7CxTg8mD7e2tUYQECO8Iry9wB+/IxHHESTHH8nJzMjMJc4fEhIj1iLV1NTY1d7a2yITEyXk5iTm5B/q4+IiFBTv8vEf9PHwJPD49B8VFf3++on4RyIgwYECSViwIILhB4crFppgCPHDhQsiMFpscdEERo0iMGAISdKEyJErUDyOyJChREuXLV+aYElCg4YSN2uKyLmCp4gNHzYAFVoCqA+iLDiMUPqBg1KnLZ4yNdKh6ocOK6paxWrGTAgAIfkECRQAHgAsAQABAB4AHgAABf+gJ45kWQIiaprB6gVtHJOtawqioO92Tw4eYHBYIviKxuTRVxA1C81lyWDwVEVXbPZ46B5KXc83bEKUzGiE+pw+JhIjuEjukb99CoVHL8rz/X1HCx6DIoWDhyOFLgweDI0ij5COk42TJg0NmCOampw9Di4OoaMkpT0PK6kmqQ+rLhAQJbGysCIRuBEjuB66t765Jb4SEiPFxyLIHsTEyyUSExMl0R7SI9LY0drW0hQUIt8e3+Mk4+Hn4R4VFerr6ivs7iPr8h4WFiL49i73+yP4+jxcuCCCoEAXAw2SIGgQAwYRDz1EXOHQxMOIGTKU0GgiI8eOIzRoKDGShMiRJU0kiBSxwcOGli9LtGTpIqYJDiNwctCJ0wbPIx2CeujgIqjQDiEAACH5BAUUAB4ALAEAAQAeAB4AAAX/oCeOZEkCImquAdu+b9mupiAKeE7v5uD5v6CJwCsRiMii0lNgMpvLksEgonqsVazywOWSvJ5DWGxClMxohJqkTisTCVFcPpp77DuFwrPn60V6fYBFCx6FhiKFh4eJjCYMHgyQkZIjlZaROw0NJZwinJ4joSsOpKUOpSSoRQ8mD6+uHrA7EBAktSK4I7YevBG/ESO/HsHEIsDDJMUSEiPNzyTMIszQ0yITEyXZ2yTb3tjZIxQUIuQe5iXk4+Ll6BUVHu/w8Cvv8SPy9B4WFiL9+zv4legn0MOFCyIQGtxx0ARChRgwiJDogaKJiBcrjsiQoURHExw9fCQx0oMGDSVQKKYUoTJlyw0eNsCUaQLmDporOIzQKYKDTp85PQCN0qGohw4lihpFGgIAOw==", + 18: "data:image/gif;base64,R0lGODlhIAAgAPQdAKD/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+Yr/cwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAdACwAAAAAIAAgAAAF/2AnjmRpnmiqriUAnO/osmMgBjhp72VOiwJSMAjsEIujwUmp7DBFg6eKMKISqJ0ryVrClgokcAGcIovGJYNI3VGzDW/2uv0mHTr3Q150x/f3eioII4MdhQiDiYc/HQmNIo6Rj5KPKQoKIpiYI5sdnZuaKQsLHaSjIqSopammpScMHQyyI7Cxs7WxJbgdDQ28v76+IsIjxMPBHQ4OySTLzszPycsi08oPHdfYJNfc2tzZ2SLcEB3k5SfmEObl5OvpHRHwK/ER9CL2I/GMJRId/f8i+tGYMCFFwQ4HWVDosJBhwxMLH66o0KECxYoXRVDcyMJCB48eP4L8OGJkSBUXOi+kVCkipUuWK1lg6DDzRM2ZN2lkQLEzQ88OOxlpQDG0Q9F9GzokTbqPBoemUJuGAAAh+QQJFAAeACwBAAEAHgAeAAAF/6AnjmJHnp55qijguYArwjMZo2SQj4Gui78dTiTwCIpIYpI49AycT1FUSh1NcQQPITvkarmEQmE09ozLYlFabVaXPQY4PB6Xz0X1eZ50GB36fn2Cgh6ATR4IIomLiI2LiYcJIpKSI5UelwmXQwoKHp6dI52en6WHJAsLIqonqqyuhwwMIrO0OLO4OA0eu7u8v70iviMNwx4ODsfKyMvLyckizMkPDx7VKNfU2dYi2Q8QHuDhQ+AQ5ePi6BEeEevsp+3r7u/uEiL2p/ceEvwk+E0TJgAUIdBDQRQUPFBIqJAhCYYOD1UQUWGih4oXR2C0iMOCB48eRYD8SBLkyCEXPDCkFLFS5cqULXFg8DBT5ggMM3PSHJIhX08PP3820ZCv6IgNHjYgRWq0KIcRT5uKCAEAIfkEBRQAHgAsAAABACAAHgAABf+gJ45kSXZmSgIqu6pwIAb0KHtybsOjIPSinxA4TA1Mx6MnKRowSUoRYUSYVqVTqicrNRW8nsJXNR6JSYZR2pNeG9xrtlsU9xzs9vsdnxfp/Xt8IwiDIoQeCISKh4c8IwkekJGTkJWTlyoKCiKbmyOeHqCenSYLIgumqaYeq6ysq6muJgweDLYjtLW3ubUlvB4NDcDDwsIixiPIycMeDs0kztHP0s3OI9bODw8i2yPb3x7g2tzk4Q8QHujoKesQ6+nqJOoRHvSO9BH4Ivr1+x4S/wA6GgGw4D+CAwdOELEwoUMRFDxEfFihAg+LFhNa8LCRY8cSG0M6vODhAsmSJUg4qkQJA4MHly5fwnxJc2bCDB5w5hSBs+dOnzpVaEgx1EPRoUgHbvCwNMXSDU+ZOuQggqoJq1ZVhAAAOw==", + 19: "data:image/gif;base64,R0lGODlhIAAgAPQeAIr/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+QAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAeACwAAAAAIAAgAAAF+6AnjmRpnmgJeMCqrm5qBh5dkzZty7Ig+rzTADX0FE1HE4GQWjaZqQKqID1VUwbDSevhlrK8w0nsIZfMMgRJXWKL3LJEojSXe+Yke9CjKPX5fnsjCyKEhoYehImCHgyNjpAikQyRQQ0kl5cjmZiMHg4ioCOiop4mDyKopjIQIq2rJxEiEbIetbAeEhIiu7m8vaYTI8ITxMOmFCPJyR7LyowVItEe09LW1IIWI9oe3N7bexci4h7i5Obj6TwYHuztKO7s7jIZHvX2Ivf6+fgyGiT/RAQM6IFgQRkbRGxIOIIhQ4UOeXDgYIKiB4skJsro0OFExxEfS3DE5SkEACH5BAkUAB4ALAIAAQAcAB4AAAXuoCeOHlCa5FmmrBh4L0zGb9zeniDqeDrcP0+QNRwRPEcWIZk6MkmFWyHaorIMLaxHm+KmDi2wR/zFIUjnVFq0ZiUSKfjbAyfNcYpU3rMf9XELIoGDgx6Bhj0eDIqLjSKODI43DSSUlCOWlYkeDiKdI5+fmywPIqWjPRAiqqgsEREir7GwrRISI7ceubq7OBMTJMC/HsAjwzcUI8nLIszJzS0V0STSLNUkFiLZHtvd2t/cKRci4x7lJOfl6iQYIu0e7/As7/QjGSn39iL5+/geGiQ0AAwoYuAIgQQ3KNzAgqEIhykWQhzFodWoDolCAAAh+QQJFAAeACwBAAEAHgAeAAAF7qAnjiLgASZ5mqnqioEXy+Qcz28+CiKv6wNX0DMkFXUEgiu5VP4KuQL0Nc0ZDC6sR0u6/g4vsEesIucQJLRKLWLnEglVHO6Jk+g/j0K11/PzIwsigoSEHoKHgB4Mi4yOIo8Mjz8NJJWVI5eWih4OIp4joKCcLg8ipqQ/ECKrqSQRsBEisLOxeRK4uCoSIrwkuboiE8MuE8IexMbIxcMUJBTOI87R08/RIhQVI9ok2twi3irf2hYuFuUi6Oge5+YjFxci8CrxHvXv9fMqGBiuHvyuMogQ6O+FBhEHC7rYIIKhQhUcRER8OKIDCYt5QgAAIfkEBRQAHgAsAgABABwAHgAABeugJ44eUJrkWaasGHgvTMZv3N6eIOp4O7A/T5A0TBE8RxYhaUS2CrcC9HkztKwebEqbOrS8HnAXhyCVU2dRmpVIpNxtj5sUxylSd09+tMctRH+BgR5/hD0eDIiJiyKMDIw3DSSSkiOUk4ceDiKbI52dmSwPIqOhPRAiqKYsEREira+uqxISI7Uet7i5OBMTJL69Hr4jwTcUI8fJIsrHyy0VzyTQLNMkFiLXHtnb2N3aKRci4R7j5Czj6CQYIuse7eoj7fIjGSn19CL3+fYeGiQa/v6JCDgCoMANCDe0UCiCIYmEDntwWHWoA8UQADs=", + 20: "data:image/gif;base64,R0lGODlhIAAgAPQeAIr/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XP/cwAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAeACwAAAAAIAAgAAAF/6AnjmRpnqgIkKvXvmxKBrQY2LeX07lcCh6BcCgM+kqDpGiAYnqSzqOHMEVRqdJSwVPYjrrcrMkwMpjJIrR4dPC0S+33WoQYIe51+nyUECX+gH57IwoKJoWDIgsLKIt7DAwikJOTkpFZDSKZHg2dnpqgUg4joyelHqcyDyOrD66vrh6rIrMpECO3PrkeuycRIr+/KcHAKRIjxxLKy8zKHsci0CYTIxPWMtbUItolFCMU3t4p4eIe5SIVI+npHhXu7/Do7eokFh4W9iL2+Sb7I/j3RlzwMLBEQRQHBRIUgcFDQxMYIkqceKLhwwweMGIUkaEjio4bM4oMqcFDSZMnUS5qWMlyxEoRJVOW2HCCpgebM31w8LCTJ4efJH4C5UkURYcOHpAi9aE06dJEWUIAACH5BAkUAB8ALAEAAAAeAB8AAAX/4CeK3viVJ6mOqOkCwBh/sDjTt6sHwcf/P19PpxMIRkdi8mMkugaDT5QYhTqdhA8hO9pqr9fCqEAWi8xgneGzdq3baddhdKjPRfe4CSFC+P99ejoJCYOFgiYKCk6KiB8LCyKQk5OSkXEMIpkfDJ2emqBgDSajRKUip0QOI6sOrq+uH6sis0QPI7dpuR+7JhAjv79XwcA6ESPHEcrLzMofxyLQIxLTEtZg1tci1CIT3d7gYOET3h/lFB/oIuoU7e7v6yPo6BUf9Sb19zr5LvkWH/9cBHQycMQ/Cxc+JExo4oLDhxBdLFT4AUNFFxgsEsmI8aKTDCIyiBwpMqQgDRpcKqT8sHIEyjQbdMQcMdNETR0cPuTUyWGniZ47c/o00aHDB6NG0yA9mvRDCAAh+QQJFAAfACwBAAAAHgAfAAAF/+Anjh4plh+KpmPrfsAYw/MMv28gBjrv+x/eDtcSjIw45EdJFA0GHygO+mziCB8CdqTNWomFUWEcFpW/LsNHvWar2ejWYTT/1O1xF0K0H/X7eSMJCS+DgS0KCkSJhwsLIo8ukY5xDCKWHwyYmpedVg0toCINoh+lpk0OLaoOra6tH6ojsi4PLbZfuCK6IhAjEL6+TcHCH8URI8jKEczNzsofyCLSEh8S1dbXVtfY2tUTH+Aj4OJE5C3kFB/qI+wU7/DxIuzz6x8V9/n5+Dj4/P76PlgQ2GJgE4MiBiJscqGhw4eHRmDAQGRixAwiMmjcqDFjHg0aXIT8MHIEyC8bXiGkHLGyRcsXHD7ElMlhZouaM2PabNGhwwefPr8A/Rn0QwgAIfkEBRQAHwAsAQAAAB4AHwAABf/gJ4re+JUnqY6o6QLAGH+wONO3qwfBx/8/X0+nEwhGR2LyYyS6BoNPlBiFOp2ET9aV3V6JBVFhTBZ/nYZv+qw7jA5wt0jONiFEiLweX9clEn6AfSYKCk6Fgx8LCyKLjo6NjGwMIpQfDJiZlZtfDSaeRKAiokQOI6YOqaqpH6YirkQPI7JntB+2JhAjurpXvLs6ESPCEcXGx8UfwiLLIxImEtFf0c/OIxPXE9jYV9va1yIUHxTi4+Hk6Onh5+YVH+4m7vA68i7yFh/4LvpO/CP4Fi58ECjQxIWDCBO6IDjwAwaHLjA8JCIxIkQnGURk2Mhxo8Y+GjS4EPmB5IiQZzYi6FA5gqUJlzo4fJA5kwNNEzZpyrxpokOHDz9/ngkKVOiHEAA7", + 21: "data:image/gif;base64,R0lGODlhIAAgAPQdAKD/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7or/c4xz9H9z+QAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAdACwAAAAAIAAgAAAF/2AnjmRpnmg6bmrbAh3sjkFN1sHd5bMw+h1gUOQrugYlJHK0VA6WKYJJSqJ2CFKsqnDikrydglicMqDMI7TIYFabDin4SC4X1U2IVF60z/tJeyMJKoMig4WGiYgiCiqNHY+RJI8lCyqWC5kdmiSWJwwMKaGjHaEkpigNqicNI62trjMODiS0Hba3tTMiDyS9v7+8Hb0qEMYjEMjJyscoEc8k0NAdESfVJhISJdkd2iLe3CTeJBMm5R3n5eci6+glFCbwHfD0IvIuFSX5Hfv5/vwuLJCwIHBgB4EIZ1wYsfBEww4PXWCYeILiCAy7UmTIUIJjxhMaSmgI+fEEBxInSwaqXMmyRAgAIfkECRQAGwAsBAACABsAHQAABfHgJo7kBpQoGqxpsLlpKYzzJtR2HotDOfQbYHC4I6CMIqOSgEwVnKLnpvCkxgwp7Ea7NXi5pUNKvCGXxeYSIrXetNsieCmRotM3dvxuo0D1+YAjfzELCyWGhhuJiYo7DAwjkI+SkCKSew0jmZsbmZp7Ig4joqEbpKV7Dw8iq6usJK4xECOzG7MQt7QxEREjvSK8JL3DJRISI8YbycrFxscjEyTR0SLU1CXXFCTa2hvcIxTd4CIVJOXnG+Xpe+UWJBbuG+7z8jvuFyP4Ivj8G/qgGAKWwDCCIKgYGTKMUHgQhQYNIx42RMGBRMWJoDpg3BACACH5BAkUABsALAcAAgAXABsAAAXQ4CaOG0CeaLoFaioIKAy32yDao63TxEj0ot4PmCqMjEZRAZlEGUbPJ9RAlZ4OJCx2dNCqECMwWDQmpxKkBFqEbrcUIzh8MxfVTwtSPr/h80d/GwwjgwyGgoMkhSQNDSKOkBuOJ5MnDiKXmBuZI5wjDw8boaKfJ6MbEKkkEKiorKwisBsRJ7QiEba3uhsSJBK9vyK9vsAbEyPHxyLKE8rLyhQi0dEb1NTVJNcVFRvc3t3gJ9wnFhvl5+Yp5SoXI+00JxgYI/PwJBn39icaJPz6IQAh+QQFFAAcACwEAAEAGgAcAAAF7SAnjiS3lWgJrCnAuSkZjDMX1HYec0Ip9LxRD5gaoIwio3KARBFST06U8KSmClcRVlvobkuGVJgzJofLpENKzWGzRW8SIjWfc+wifCmB4nP4fiKBgSIKCiWHhxyKiouOJQsLI5KRlJIklykMI5udHJskoDENDSKlphynqDsOIq0cr7AksSgPJLa4uCO2JRC+IxDAwcAcwcMRyCTJyRwRJcjOHBIlEtPTItfV1CITJN0c393f3N4cFCXn6eYi5ynnFSTw8Bzy9PY7FvkWJPv9HPs7Al4YMTBgCgwIR2AwmCIDiQwOGZbQQIKiRA4hAAA7", + 22: "data:image/gif;base64,R0lGODlhIAAgAPQXAP/ic//Xc//Nc/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz///sc/+3c//CcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAXACwAAAAAIAAgAAAFkeAljmRpnmiqrmzrvnAsz3Rtx1Ve3STQ86IASQgUGI/AZMnCbDpvA1P0RqiKqgRewbTlGb5g4GEsGh9uCBFinb60Z4lLPEGfy2mKiyK/1/NpCxeBgYKFhDMMiReKiQw3DQ0kkDwOJpU3D5mamTwQIhCeF6E2ESIRpReoNhIXrK2vNhMishe0tDQUFBe6u7u8KSEAIfkEBRQAFQAsCgAJAAwAFwAABXBgJVZACYxokKKigLrsJc9szQ54ro9E3Y+FSlBIHBlqR9RhyWQhnqInYpQQJa7VSlVR4Sq+3u6ishiXyWZGRa1eu9WNeEUeb4wcDhQe9aj1RxCBgoEoESIRhhWJIhKMjRWPFRMik5KUIhQUFZqbm5ohADs=", + 23: "data:image/gif;base64,R0lGODlhIAAgAPUeAIr/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XP/c3Nz/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAeACwAAAAAIAAgAAAF/6AnjmRpnigJpGwaiG8ZB3FLCqKAj3tvkwNRMOgZEn8kgofAXDaVIyjSUyiYqtbqdGRIGbqe7/YwIpcOZk+6hRi1PW83Yg63JU730j1vU5QUfid+gTYLI4YpiD8MIgyMjZAkjI42DQ0llx6ZJJZbDiMOn58eoqBIDyKoqB4Pq6mqrC0QHhCzsyK2tCO5tycRHr8iwcHAwr/EKRISJMvLI8rO0C0TEyPV1SbU19QpFB7e3+HdFOTl4CMV6SIV6yXq6Ozv7CMWFvQe9iT5+fT1+ycXPARMMVBEwIMCTWAQsTBFQw8YIkJ8SCKDRYstLnrIsHEjRxIaRGgIiWIkSA8kUR2W2MCSxQYRLz2wbClzywkOOD1wELHTJpIOPm2GAAAh+QQFFAAgACwCAAAAHgAgAAAG/0CQcCj0eIjIpHIIADWZQoB0uQwIA1ZQNktdCoTfMOjbXQ5AgzRafUaXkwQCXCh/IwvJgh6E39tBBkOBgoGDfwdDiEgHioiKVAhKkUMIlSCTXQlICZqbIJ1vCkOiS6RvC0ILqKhLrKxUDAxLskOytG8NRLlDub27XQ4ORMJCxMXHVA9DD8rKIM5Czc/P0EMQIBDZQtfb3NzY4OFDERFI5ULl5Ojp50oSRO8gEvFC9O/zShNE+iD8+xP8AAJEQqHgEApCECopyJAhkgoVhEQEMXEJxIgQKS6xAILjEAsglYD06BHJBSEnQaRUaZLlyZdJMMgUgoHITJo1b9ZUkiHDkDaeRID6HNpFgxCjVIwiBbE0yYanSJ5uGDJ1KgirVt9wGLK1K1chW/90GDIWRFkhHc7+UfJBSRAAOw==", + 24: "data:image/gif;base64,R0lGODlhIAAgAPQbALf/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9KD/cwAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAbACwAAAAAIAAgAAAFuuAmjmRpnmiqrmzrbkD8tkEg2nMqiPuerwNR8JciiIxEU2FTaC6XSZLBsKFSo6WD9tDithCITXg1diUSLHRLoRixU23WYr6ZL+p30j2/Yvg3DCOBgCWDKw0NI4mLiIgijokrDiSTIg6Vl5kuD5wiDxufnyOdMxAQI6enWCURra2rJBKxsBsTJrZYFCMUuhu8URUiFcEbw8JJFhvJJcnLPxcb0CXQ0kQYKNdJGRko2z8aGhvhJ+HgtOewIQAh+QQJFAAbACwFAAMAEgAbAAAFouAmbkA5nqgYBGqaCiIMu+4g2jRKiLvbbwVgYQhMBUeGpDJlSB2eB1cUhUBsrCksKpFwdU8KxSg83ohHi8UmrU6j1SIGYzOP2+V0UUO/2Tf+gHsiDiOEg4YOhiIPI4yOORAQIpIblDQRESKYmzknEp6dGxMpozQUIxSnIqopFSKuG7CwKBYitba4KRcbuye7vSgYGCnCNBkuGccpGhouzcwoIQAh+QQJFAAcACwDAAIAEQAcAAAFriAnils5nigHACKLumPAyTJao4KYnzs6iL9TcETgEI7Fokh5KhQ4z+dIijJYDdUU53DYorpaBCI1PiUSo3NaLVIoOO63e/QeLTh3Uf6+yHMYDH+CgISAIw0iiImIDYoiDiOQkloPDyOWHJgpEBAjnJ9aKBEno6EcEimooRMirK2hFCKxsRy0KRUcuCK6uigWHL8jv8EoFxzGI8bIKRgYJ82mGRkn0qEa1ycaHNgiIQAh+QQFFAAbACwFAAMAEgAbAAAFqeC2ASNAimiaBoHYqjAqbHMcDyJuq4TYx79NQVgoCmFDlMGwYTJVz9RheohVVQjERgvjqhKJWDilUKDK540ZtVhs2u422y1iMDb3ut6OFzX8G38Ng4R/Ig4oiIeKDooiDyiQkjsQECKWG5g2EREinJ87KRKioRsTMKc2FCgUqxutNhUishsVtLQpFiK6uRu8KRcbwSrBwykYGDHIMRkZzM4qGtIxGhvTKCEAOw==", + 25: "data:image/gif;base64,R0lGODlhIAAgAPQdALf/c83/c+T/c/r/c//3c//sc//ic//Xc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/6D/c//Cc//NcwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAdACwAAAAAIAAgAAAF3mAnjmRpnmiqruzGviYAz11g06+g4+vg+7wUYTgMogpIpNFkaDoNy9FhSqVGryiOdsvlLhEdcHgcTZg757NRoeiw3/D2bEEf0e93UX7FODH+gCZ9KQ0oDYeIJ4UoDg4kjiKNjZGPkCYPmA8imCScI5odmaAlEB2lIhCnKKqlqiURI7ARsCeysSkSIhK7Hbm7v769ub0qEx3GyMYlE8rILBQi0BTTHdTT0jwVHdonFdw8FioW4TgXFyPm6eci6zMYIxjv8h3v9DgZIvgdGfwj+vowNHTQIFBEQYMED5YIAQAh+QQJFAAbACwCAAMAGQAdAAAFyOAmjqQIlGiKBmqLCrArb0M9t0Se32nh+zyUYTgMkg7I5MG46TifT6aUhKhar1deYrPleoOK8EYsvi0Wm7N6jW4xGKO3XC6Cpxqohn5P0pccKQ6CgyiAIg8liIcPjIeJIhAQJJIjkZOVkhGaESKaLpwbmxESG6QjEqYopKarGxMjE6+yJLOvIrYUIhS7G7y7vrm9uiMVG8XHFcXEycbHJRYi0NIbFtPVNxcuF9kuGBgk3t7gLhkjGeXo5SLqKhoi7hsa8u/w8BshACH5BAUUAB0ALAIAAgAZAB4AAAXKYCeOpLiVaIoCaosGsCt3Qj23Q57fKeH7PFRhOAySDMikwdg5OJ9PppTEqVqvVx4CtQ0mvh0wmKfoKM5o9GyxELHf7w5bxWCU6nj7qF5qpBqAgSh+Ig4tDoiGKYoPDySOI42Rj44QlhAili6YHZcQER2gIhGiKqWgoBIjqhKqKayrIhOyE7O2tbgdt7IjFB2+wL4lFMLAJRUiyBXLHczLyjIWHdIpFtQyFy4X2S4YGCPe4d8i4yoZIxnn6h3n7C4aIvAdGvQj8vIdIQA7", + 26: "data:image/gif;base64,R0lGODlhIAAgAPQeAKD/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+Yr/cwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAeACwAAAAAIAAgAAAF/6AnjmRpnmhqduoItCcgqwF81nUq7HzflwLRrzSwDYojZFIpIjifUAJJ6qFKr85SIVXoerbfEVg0HhnO6DTJ4GGX2G7UoXSoe+Z3Er6EQPD7gCR+gyJ+JQkiCYqIHoyJio2Rko4eCiQKlpaVmJiXJpoiCy2iIwuipKcepiMMIgyvsKywra6sHq20Hg26Jg2+vCK/uyfDDg4wxscjyh7HziIPDzYe0dHQI9LWIhA23CPc3iThESjkJRHoIuYe5OkjEifwKPIe8vD0HhMm+hP6Kv75TFAoMVAEhYMFByo0WHBEhQolIEKMONGDxIojLJjQ6IHjRo4gLXj0cEHEhZMjSkmmKKmSpUoMImCOkCnTBAaYNGOOyOCBJ4kMPIGiELqThAYRGpKOOIrUhFIVG0hEFRG16ogNVbFqPcGBgwevXlGEHQH267SzJUIAACH5BAkUAB0ALAEAAgAeAB0AAAX/YAd0ZGme4jiiZMC+pRvM8ynceI7b6F0OsB/w1wEaB8MOYclsmggkaPR5KrAK2I5Vi7JuTYawOAzuGFDn0uFwYqvXHbebNO8gSIh7Kc833f94JQmCCYMkhoeFHYOGjSQKj5ElCpSUJpAnmAsmmyidHQubnaKgmwwkDKmqJaqprK+npw0dsycNtyS1uLUoDQ4OQSW/JsAkwMcPD8Elyckkys8dzhDLHdQl1Ncm1BEv3ScR4STfHd3iHRIs6S/r6CTp6xMo8hPyQfYd+B0UJ/wkFAD98Rv4z1+HChVOJEyokOHBgw47WEAxUeILCxUzYiRxgeOFjhyDdAQ58gIGEidLPKRMiQLDyZUoO2SQeSLDTJsvcJaY2UEDCQ1AS/j8iSLoiw0mkJJAyrTEBqZPo57gwKFD1aovsJa4arVDCAAh+QQJFAAdACwBAAIAHgAdAAAF/2AHdGRpnuZIAmoZoDAZzN381jcp7Hy/nwIUrzSIEYskZBHZYXYI0GjURChVn0ZSAVXodrbfLMpALhtM5/NJTTq4TQf4Ox6Hd+qIEiJP2vtNeYF9JgkdCYWHJYUkh4iGjJAdCiYKk5SVliSZJZYLYiSeHQueoaSingwkDKusJayrrrGpqQ0dtScNuSW1urcoDQ4Onx3BJsIkwskPD8Mdy8skzNHOzBDD1iXW2CbWETHeJxHiJOAd3uMdEjDqMezpJOrsEyjzE/NZ9x35HRQn/SQUAv7rRxDgvw4VKpxQqHBhQ4QIH3awgILixBgWLGq02OECiQsgS3g04nFkyQ4YSD+kLLFyJQoMKVuiJJGhQ00TGWrmjLGT5k0NJDQILQE0KIqhMTaYUEpCqdMSG5xGnXqCA4cOV6/G0FoiK9YOIQAAIfkEBRQAHQAsAQACAB4AHQAABf8g0I1kaY6AKJ5jwL6kG8yzKdx4jtvnTQ6wH/DXARoHww5hyWyWCCNo9FkqvArYjlV7sm5JhrBYXDJ0zCb06HAgtU3s9vu9LiFGiHsnz8/b94CBIwmDCYSDJYaEi4gdhwojkB2SkQqWlJMnkgslnCeeHQucnqOhnAwjDKqrJKuqrbCoqA0dtCYNuCO2ubYnDQ4OQSTAJcEjwcgPD8Ikysojy9AdzxDMHdUk1dgl1REv3iYR4iPgHd7jHRIs6i/s6SPq7BMn8xPzQfcd+R0UJv0jFAL+60cQ4L8OFSqYUKhwYUOECB92sHCC4sQXFixqtNjhwogLIEl4hOFxZMkOGEY/pCSxcuUJDClbohyRoUPNEhlq5nyxk+ZNDSM0CCUBNOiJoS82lFA6QqlTEhucRp1qggOHDlevvtBKIivWDiEAADs=", + 27: "data:image/gif;base64,R0lGODlhIAAgAPQdAKD/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+Yr/cwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAdACwAAAAAIAAgAAAF/2AnjmRpnmiqrihQArDLpoEY3GQ9o4LAiz3fTjRIDYpE5I5wYnacTOeoUChRRdcpKdupigzfL7gzJhvO5HB6LTq03e426hB/kxAdBF6vF+FZf38dCYSFI4Q7CSKKHQqNCpAlkJErlCILHZiamZedKAuYnB0MDCKkpiSlo6Sqq6kkDbEdDSOxtCa2IrezIg6+Dh3AQyS/JQ/HxyPIOw8kEBAd0CLQ0tEq1CcRJdraKN0i3yQSHePl5Cnj4igT7B0T7u0i7yPzJPUlFB0U+fok/CL/RgRMUWFEhYIHD3ZQSILhCQsWRkRMMZFERRIXMIq4kDHjxg4eNZbAgEEESZMlS0COUElSZQeXIjKMkBmzQwaaMW/ivGlzhAYNPoP+9DkUKAmgRjd0ULpBqQimS0cwdfq0adQOHLBqHSYiq1euXEMAACH5BAkUAB0ALAEAAgAeAB0AAAX/YCeOI0CKQGqebNsFYiCT8Di7pyC4e9f3uNEANxgKgyRCS9lhEpidQuEkHVWtpOvUIOJ2DF5vF8wNf7uiQ1qtTuMO7Q5chOgg6vc7Hbm3dxKAgSOAfCIJhgodCouJJIyNQYsiCx2UlpWTmS4LlJUMDCKfoSSgHZ+ioaWjHQ2trCOtDS2xIrK1DrgOHbqFLLkjD8HBwMOFDyIQEB3KyMsjzC7K0CIRJ9XVLtjUJxId3d/eON0k4yQT5x0T6egi6iPu5iwUHRTz9CT2Ivkj+y0VIxX+BQzYgSAJgycsWBixEEdDEg9FXCAxscOFiRUtajyRsQMGDCI+hgQJckTJjyU9OI7IsLJlBpYrX8Ls8JJmBw0aRuQUkROnTp87dd7c0IHoBqIijBYdYRRp0qNFOXSQKrUXCapTO4QAACH5BAkUAB4ALAEAAQAeAB4AAAX/oCeOZEd6XWqebOsBIiCT8Di7ZxC4u9f3uJEAJxgKg6RBS+lhDpiE6ClKEElHVWy2WhB1PYUveBQOj8ffr0FkWK/ZuPZI7jnU7Ye8vY4U7e0IgYIjgX0iCIcJHgmMiiSMhouOCh6UlpUiCpqULpqZCwsioKIkoR6goyOmpB4Mrq0jrgwtr7MkDA25DR67kby/vL0eDsTEI8Z9xSIPDx7Ny87Lzy7N0yIQJ9jYhtsjER7f4eC+3ycS5x4S6UHqJO0nEx4T8fIk9CL3I/ktFCcU//9cBGxRYUSFgycKulBIwoIFEQ8hPozosEXEERcwYsyYkcSFjx09hPSAAYMIkydNPaI8eQLlygwjYIqAmUHmzJo2PdD0oEHDCJ8ifPb8ORToT54bPCTdkFTEUqUjljZ1ylQpBw9Xr/oakRWrhxAAIfkEBRQAHgAsAQABAB4AHgAABf+gJ45k2Z1dqa4eAIjuO8owzY5BwOoez98jwU0gDAJJg1XSs2QuCdASlOCJjqhXK7Ug4noK3m8XzPWauyJDWq1OswzttejgOdDt9vlRX/cg/oAjf3siCIUJHgmKiCSKhImMCiOSCpUilZYsmQoLCyKdK54enaAjop8iDKoeDCOqrSqrsK4NtQ0et4+4u7i5Hg7AwCPCe8EiDw8eycfKx8ssyc8iECXU1ITXIxEe293cutslEuMeEuVA5iTpJRMeE+3uJPAi8yP1KxQlFPv7LP0rFUZUGFgiIAuDJCxYELGQ4cKGClc0HHGBIsWKFUlc2JjRQ0cPGDCIEDlSJMmRJUg5nswwgqUIlhlcvowp0wNMDxo0jNApQmfOnT957sS5wUPRDUVFHDU64mhSpUiNcvAwdaquEVWpeggBADs=", + 28: "data:image/gif;base64,R0lGODlhIAAgAPQaAM3/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9KD/c7f/cwAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAaACwAAAAAIAAgAAAF/6AmjmRpnmiqrmzrvjAJxG9Ar4KYx0PvlwNRD+X7iQgkAjKpXI6UyVFBVJhSpVWN9Uq1bg0jA1gzJovPZJE4PDpo3Cb4Wy4nueUIDSIv4vNJfiN7eiMJJIaHIgmIiIWJIgookQqUlRqRJ5gaC5sknCILoaKhI5+gnSIMGqqqq6kMsLGts66tGg0luLgiDb2+I7q5Ig4qxA7HxsUjDyfMD87QGswm0yMQ19gQGtrXIt3c2d0wEeQRNxIm6BoS6uok7igTEyPy8/Ty9y8UIvsaFP0AW1QYMVDEwIIHCSpEYaGhCAsaIJaAKLGhRBMXSmTUsJHExo4iQI7AQJKkCAwaUBWOTHmypEoWGTTEjCmzJs0bOHOyCAEAIfkEBRQAHAAsAQACAB4AHAAABf8gp3FkaZ7oOXLblrJv2nIAQNsoHt98UAY+UjCYAv44AqQpSWIKmMtocsAZUElXrDVbLVm7BFOYNCaYOWN0Ka0umNwceLxAp8dJ8ruBs0f1+X9/Jnt7BxwHhiSGiSiLJYiHHAgmk5QkCJWVJZqSHAkvnwmio56gHAqnJqgkCq2urSWrrKkLHLUltwu6u7okt762HAwmw8IlDMjJxyTFzBwNJtAnDdTS0dckDg4p2xza2dzdJg/kJA8c5SXl5+jpMRAQHPHw9PPy8TsxEfsR+f4cEkhICAjwn4kJJSYoPLiQBMIYFCiQkMiBYsSJGCtSjFGhRMeOHD56/GeBRMmSJ04qmnxxgcOFli5JwDQBs2bLmSgwkNCpswTPnS8ycMhAVOjQo0aFKiVRdGkIADs=", + 29: "data:image/gif;base64,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", + 30: "data:image/gif;base64,R0lGODlhIAAgAPUgAIr/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/3P/cwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAgACwAAAAAIAAgAAAG/0CQcDj8fIjIYhIJaDqX0GcyAApQoVih9SoUgAReInhM9oLF3+FAOFiD2kg3e96uuwkgPGHPF+LzRH96gH8gBYaIBYpLh0KNjYhDBkKTBpVQk0iWmUQHB0ifQp6doqVYCAhCqSCorKtLr0sJIAmzQ7a1srRZUAoKIL+9WAtExEnGS8hEDEPMWc5J0EQNINRL1kIN2tjaSA5J30PhSw7lQuMgD+pDD1Dt6etE8SAQ9Fj19vn6+CAREUj/hARMMvCfQSQSJAhJuLAhEYUgGEZ0CGKCEItELGJMshGJRQpIQCYROZKCSZMgQFaoQISlEJcuQcSUmcSlBQsgcOIUsjPnkHyeOnX6xHkBxIWjQ4oKUZpEadGnRkFgwCC1ahaqQ6hqtYohg1evSDIQEStWyFcQZNGi1cC2rQYob0HEfUtXrhC2G/JuAJGXr5C9focA/qsX8AYOIDggXiwEMS8oHDpIlgyiQ2XLlYVgzqw5iWQPoEMLAQ3CQxLTRFCPBh0EACH5BAUUAB8ALAAAAQAgAB8AAAX/4CeOIwCQaJmiQeuu8JsKn0DDuGjf4vANPhJwSPQBhb8RQURYfpooJ3ParDoLH2xhyxVhs6SvFvz9GMxog3p1FrXb6NFBND/UYXOUPU9CIFB/H36AIoGBMAkJIoofiY05jDAKHwqTI5aWKZOZOSgLCx+gMKIrDCSmKailKw0jrTmvKbEkDh+1K7ciDru0uSIPKcAjwsEPxr8kEMojEDDNOMsiER/TMNXV1BHY1CMSEjjf3eIi3+UkE+gjEyLrH+3q5+7yIhQoFPWd9Pj7IhUV+f9QBEzxz4KFDwcNilCIEIfBhwk/XJB4YaIIixJJYMyIwiKGDxg+rhCZ4mNIkCg/V2bI8IElyxEvcbhsSbOlhps3P2iAsXPniJwkem4YuuHDUBJFRSRdajTFUA4fOECFGrWqCKpXR0y1GrWDV68fwHZAMVZEWbNfx3r1wLatCLZvUXiQS6JtCAA7", + 31: "data:image/gif;base64,R0lGODlhIAAgAPQeAIr/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XP/cwAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAeACwAAAAAIAAgAAAF/6AnjmRpnmgJeCvZAi+bmsFYe7cY1PlMCgJR0BMcEn2pgXLgYTaZTuSMQCV4qtRUYbv1FFDc74hbMhhGZt9ZtGaPDgcP/C0vxevze12E8PT9f38lfYIjCIIJHokjCY2NJIuLkCKLCjOWJAqWmCKYmiILUh6hoKMjoaQiDAyiq6wlr68iDSQNtrYmtB64uygODiLAHsK/xcTCwykPyyLMDx7P0NDRI8wpEBAk2R7YI9ve3N8lER4R5OflIubqI+vl5CUSI/Ly8yT1EvQi9SUToh7+/JEQWIKCCYMkEHpQKIKCwgojKkAkIbFiRRETMWa0wJFjCY8nLIgQOZKkiAsXSkagTHkCpQeXJ0lgwOBhps2aN0/MrIkiQ88MQIGeEHpCgwYTR4+KMKqUhFEUGzYgiSp1BNUUHLL+I5GVw4kOYDtsHRF27NgQACH5BAkUAB8ALAAAAAAfAB8AAAX/4CeOZGl+HnquJ/ABrujGrBh8N5njwb3XIsFIIPwIi0agaTAYNZsfZlR5IlitH+yVIMJSS4VweDT+FEiGdPpjqLVFb/jocJjXT/c6/ZMfIRAff36BJoKFhgkfiYqLiyOOjiKNHwqUJQqYlSSZliKamgtAoR+jIqWkI6EMDF+rqyKsH7EkDSUNt7cmtR+7vCcOI8Afwg7FxiLFwScPzA8izB/OztHR0yPN1iIQ2xAk3R/bI9/i4uMiER8R6Ovp5+gl6u/vIxL0H/X2+RL49fgkE18+AAQ4YgJBEhRMJByxUETDDxQaVhhRYSKJihgrUrxo0YJHjyVAmrAgguQIkyIuRlwooXKlCZUfYJ7AgOEDzZs2cZqgaXNFBp8ZggY1MfSEBg0mkCIVcXTpiKMrNmxQInWqiKosOGgNOEIrhxMdwnbgKkKsiBAAIfkECRQAHwAsAQAAAB4AHwAABf/gJ45kaXofaq4r8AGu6MasGHw3mePBvdciwUgg/AiLRqBpMBg1mx9mVLkiWK0f7JUgwlJLhXB4NP4USIZ0+mOotdml9+dwGNFX97q+Ph8hEB9/foEmgIUkCR+JiouLIo6OIwmLCh+VJAqZlyKalpicHwtKoqIjpSKlpQwMX6urIqwfsbIiDSQNuLgmth+8vSYODiLCH8TBx8bExSsPzSLODx/R0tLTI83YJBDb2iLc3iUQI98iER8R5unn5eYl6O3tIhIj8/P0JPYS9h/6JRNfIv79CziQBAUTB0ckFLHwA4WEFUZUiEhiosWJEiuKsMCRYwmPJixsZHHhQomSJk1BlPyw0gQGDB9eyow50yVMmCYysMjAs2dOnSY0aAj6YagIoUZHCDWxoSmVphtGQF3BoSrAElU5lOjAtcNVEl1FhAAAIfkEBRQAHwAsAQAAAB4AHwAABf/gJ45kaXofaq4r8AGu6MasGHw3mePBvdciwUgg/AiLRqBpMBg1mx9mVLkiWK0f7JUgwlJLhXB4NP4USoZ0+mNgtdlo0uEwmq/o+I9dT0IgPn4jf399K4QjCR+JiouLjCKOiI4KH5QjCpiWl5SalSKWCzWhHwujpCWhpgxfHwyuIqutI7ENJA23tya1H7u8Jg4OIsEfw8DGxcPEKw/MIs0PH9DR0dIjzNckENrZItvdJRAj3iIRHxHl6Obk5erm5+zsIhIj8/P0JPYS9h/6JROsH/79EzFhIAkKJhAeHKFQBAWFFUZUiEhiokWLIihmFGGhY8cSH1dY4LjiwoUSJk9Bljxp0gQGDB9eyow5c8XLmCYysMjAs+cKniY0aAj6YagIoUZJCDWxYQOVpk5HQF3BoSpAElU5lOjAtcPVEV0/hAAAOw==", + 32: "data:image/gif;base64,R0lGODlhIAAgAPQfAIr/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/wAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAfACwAAAAAIAAgAAAF/+AnjmRpnmgKrGlLBmMgi7PbCvgn6GJunwPSIBj8DH8mAiE5WiJJhU9hCh1FnyeDSDviYkWHzyEsJpG/iDQJUWJjE6KEHP6hx78jRUmfx38WCyWBI4NfDAwlhyOIiYwpDQ0kkB+Qk5KULQ4OH5qdnJsioKGcLQ8fpqinpiOrpyKtJxAQH7O1syW3srQtER8Rv8AovyLDKRItxyQSycknEzbPI8/TKRQi1tYm2dfX2yYVJOAi4ifi5CYWIukf6+sj7unuJhcj9CL29vck+ScYIv7+SAQcOCLgiQwjEH7IoFDhQhMOS2ggMXHExIofNGAUsZHEhhEfP34ICVKEyJEpOCKMUMlShEqXMGOe6DCCZgmbH2jizInCgwifJnwK/flhaIkQACH5BAUUAB8ALAMAAQAcAB8AAAX/4CeOI2CSaEoGY+CKryqLQv0JN43P6TCMvs9POOSNCB8C8sg0qgokqEjqRBlE11G2OjocRN8u94Mgm8+jMjfxYY/cIrhR8aHXRXb8eMFfkPwjgFUMDCiEI4UihzMNDSSNH42QIo6TKA4OH5ibmpkinpqfKQ8fpKalpCOpIqcoEBAfsLKwriO0tCMRHxG8vTK6wLsoEjzEJBLGH8kfE07NI83PzyIU1B/VKdjW19wjFSTfIuEq4+MfFiLo5+ko6uvsIhcj8vH18yTy9CIY+x/8JP8CjsDwT0SGEQc/ZEiYUGGKhh80kJA4QiLFiBdFZNwwgiPHDx47ivgIEgWHESdTHYo4ufIDy5YkOoyQiYLmB5k4b6LwIIJnCp5AnYQAADs=", + 33: "data:image/gif;base64,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", + 34: "data:image/gif;base64,R0lGODlhIAAgAPUgAHP/c4r/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAgACwAAAAAIAAgAAAG/0CQcEgcAo7HonLJDIACTijzuRQIlNasFbsdDkCDb3gcBouF5PGSIGQz3VO4sACi1wt4ur2o7y8NU4BKglNCB0WHIIkHjIyGioUISgiSlJaXIJJTCZxLnZydIKFTCiClRQqlqUSqp0wLsEsLILNDsbWFDAxLu7ogu7/BhQ0gxEXGxkPEyUwOIA7OS9FD0IVCDyAP2Evb19rdTBBCEOJL5Ocg5+VMESDtEfDw7u1E7/NTEiD5RRL5/voA/e1TMgFEwSUFJyg0aFChQyYUIkKkAEIiRYsUmVQAsVGjkI0VQoKcYkGIhZNFSqo8yRIEyiUXiFyIKVNIzJkzQeRcgoFIT1oQP4v0HEp0SQYiR5GCSHq0aYamTDQMkTpFqgarVplsILJVyIatX72CAEt2CQciZwudXctWSQcib4e8jStkboe7c5V4ILK30F4PgAGD6EvkQ2Frhj8oXmwYRBAAIfkEBRQAIAAsAAAAAB0AIAAABv9AkHBIHAKOx6IyAGIyl82AUzlkCkCCrDLL1W6vA1BYOCibxeEy2qweEtxU0Psdp4MKxIIej1fy/0QGcUKCSoVKB4lFB0KMiY8gjlQIIJRFCJSYmptxCZ6dCSCeo6GDCgpUpyCoQ6esSgsgsVQLs0S2SgwgDLq5ur2/vUoNIA3ERcTHRMZxDkLOVNBE0lQPIA/WSthE2NlUECDgEONF4+bh50oRIOtDEevvRfDs7UUSEkr3IPj8+/76SiZMoDJQYEEQBg0qoQCC4UKGFCA2hOiQSAUhFS4q0XgxY0YQGolYEFlkpEkLKFGCUEnkQkuXLYW4vEBzJkwiGIbkBLETJ09Xnjkx9BySgWiRokhBIM2QtIiGIU/jPNUwdaqSDUSwCtmAlSuIrl+7ah3CgUjZOGXTqi3SgUjbIW3fxu1AN24RD0TwxsHroW9fEHqHfCAyOM7gD4gTDw4CADs=", + 35: "data:image/gif;base64,R0lGODlhIAAgAPQeAKD/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+Yr/cwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAeACwAAAAAIAAgAAAF/6AnjmRpnmjZpWwrAm8LzGww2h6Ol/t+CiKgRygsFYepwUjJFCmTJ4JI6pFaq1MU1VQQdT3db9hbKnxPBlE6rfaw2ep16UA60Ef0vMfOv99LCIGAgggehYWGIoIoCR4JjY4ikJEkjy0KHpgKmJksnC0LJaEsoywMLiSnpywNJA2trB6wKA60JbUiuLgmDw8eviXAIsK/I70mECjJHsvLzM8iziQR1CLUESPYHtjX1traJxISIuMj4+Ie4uXp7CYTEyPwIu/w8h7v8fctFCP8Hvz+RAQEyKLCCIMiDCJMiFAhCwseLEAUAXEiRYkUI6a44IEjiQseRXAMORIFBg8nSTakTIHh5MoRGTJ4kFkiJs2aMmOa0OCBJ08SPnuWCPqTxAYPR08cXWoUqVNUIzhE9SAVqtWrIQAAIfkEBRQAHQAsAQACAB0AHQAABf9gJ44iQJ5oigYjq76jEItyV6fCTQ4j3/k+FDBFGBWLneMJKWJ2CiLocyqFSlHXjmG07Wq/3+1JPDocROczeq0mmUUIEiI+itvh9M5cP0r4T34JHYKEIoGGJAoiCoodjY6LkJGMKAsdlguWl5opmS8MJ6AwoikNMCimpikOJA6sMKyvJw8qtLUitiMQEB28J766wSK7IxEqxiTIHcbKyh0S0CLQEiPUz8/R19IoExMi3iPe3R3d4OPgIhQUI+vp6h3t6ezwKhUj9h32+CIV+PopFkRYCNiBIMGCAwUWRHGhw4WGIx5CdEhRRMOJIjB00EiC4wsMGj1myNCB5ImRJk8ikhw5QkMHly5JwHx5YmbMDhtwqsjJk0TPnKdEcBgxdOipEAA7", + 36: "data:image/gif;base64,R0lGODlhIAAgAPQeAKD/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+Yr/cwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAeACwAAAAAIAAgAAAF/6AnjmRpnmjZpePKnkAsxrJHv2jgBfrI77iUQGAaBk8DTzI5WiqPJQJBJJVSp9BCYaS9er8pg0hsIHvK57M5jTq4x/BDHH5+mxAevH6E5/v3fSQJIoOEhQmIh4V5hCUKHo+ECpGSgpMjj5SQJAubC52OnaKcIwweDKamp6qqIqysq6euDa6lsre0srm4uw6+DiTAwCXCwb/BDx4PySLMzM3QzcnLIxDK19bRJtnY3R4R3+EiEeDkJOYl5eIeEuzuEu3t7vPyIvHzKBMeE/wm/PpHKHgQSEHgQBIGC+Ko4KECw4YQRTgcwfAhCgseLGAUgXGjRo4eM7K4UOICyZMkUD+aTIEBQwmXImCSkCnzRIYRGW7GRKHTQ84TGkRoCOohKFEURoUeJbGhaNGmTVNAheq0BAcPV7Pi0KoVitcRIQAAIfkEBRQAHQAsAQACAB4AHQAABf9gJ44dQJ6nia5d4Iru28rsKnTCPeZ47Q8DFNDHInSMxhHySEQVCqLnMwptdgyGETaavXa9tYNIfCBfzeXreIVorzsI+Douh7tJCXk+L+L3R3t6eH99Ch2GgIeIh4SMCyMLkZCRjyKUkIwdDCSbnZuanwydmpykDQ2kmqipIqunraqaDg6wsLQdt7m4I7m0D78PJMHBJ8PCwCIQEB3KI8vMwsnOy80R0BHWzizZydbeEuDgJOEo4uPhEiwT6x3s7RPtViQU9D4UVhUd+fv6JPz5NSx0sCBwYEERBEkkXHGhw4WGIh46dAhRYkOJKzBgILFRREeOIz5yzADSIwuSJlEnaOigoSVLEStXxFzZMuaIDS834MRZY+fOlzc7cBAqdGjPoUiJdggBADs=", + 37: "data:image/gif;base64,R0lGODlhIAAgAPQcAIr/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XP/cwAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAcACwAAAAAIAAgAAAF/yAnjmRpnmiqigCwBvA6wnQq3PeKc7hwDsCBSPgLcoRI4ojALBFIzKjoSeU8RwVOVpQteLXesKmrFRk4ZzM6bWi3Vef0gTSvH+5zET5fupsQHAiCgIOFhn8lCRwJjIwijY6QjiSKHAojCpeXJJqZlp+eIpsiCxylpiMLp6Snpa6rJQyyDCOytbaxHLQlDRwNvb2+JL8pv8ElDskOJsvLKckmDyLSKw/WJNbUJRAQMtwc3yPhMiYRESPmIubn5CcSEiXv8CoTKfUT9SL4+SsUKf4UAgpsV6GCCoMI23GwwNCCwnYXLqiI+FAEBg4YLprIiLEihwwiQJLIAFKkRw0iNBSoXMkBpUcTGzjEjPmyps2bOEeEAAAh+QQJFAAeACwBAAEAHAAeAAAF/6AnikAJjGhqpmPgBTDMtrGMCh4uCvzc4zydaDBIEVnHorIoIsw8BOcoCp1CpZ6CSMvNbgtgVhdl8JQNaDN6PUuPDp6DXB6f059wEcKD2Pf/f3p9KXsJIwmGiImKHoqOIoYiCh6TlJWWCpmTmposC5+fKAseo6Gkp6YeDKqrqyMMrqyurawoDbcNtra5Kbm3Ig7AKMEjDsQsxsciD08PzMvOKdEeEBBP1tbU2Nna3E8pEREj4ePi3ywSHukpEu3nMxMTKfHy7ykUHhT4+fr59iwVPFQYOFDgEwvvECr0gPDbhYcOPVyQaA+DxYvvMLzLwFFEBhYdP9rT4IEkCw0kTRm+2zCCZcsNLF3+Q8Ghpk0PHGY+6eCB55MQACH5BAUUAB8ALAEAAAAdAB8AAAX/4CeOZGmKnncCLHuubRl8c2DPr3jfo/D5PQHw5Cv+gIPBKWliKp8fJSH3IUxH1qpWNCUUTN9CWCQugz9fA0nNbhve6tO7dKjb7/bcoYRAfPx9gYF/fSZ+HwkjCYmLiIuNj4+KJAoflZaXCpqbmJuXJguhoSMLH6WjpqmoIwwfDK2tIq+ss662tSQNug0iurm8Jby+Iw4iDsXIxscvx8slDybQ0CIP1dMf1iYQVB8Q3t3bIt8jERHc5uYi6eXp3CUSEu/w7iYTHxP29/j39BQl/hQCBvzgj14FEwcTfjhI74MFCyYgQmw44oJFiycufNBID4NHKhgofsgw8kQGkiQbIWoQsZKEhpUtKW74sGEmTZs2RY7gwJPnBw46TXT4MPRFCAA7", + 38: "data:image/gif;base64,R0lGODlhIAAgAPQeAHP/c4r/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9AAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAeACwAAAAAIAAgAAAF/KAnjmRploAIpGfresEYv6Mg2i2O094g+i1gjyciGF0EYqkwYjKXypFBNPVUq9QTtnUgHbojcOnbQiBKZ8/ZfEqLEqSEHH6i0xQKEj6fj5YWCySBHoB+JAwiiIcjilEMDSOQJZKSJpWRIg4jmpsknCafJQ8kD6WjpC2nqB4QPK0tr6ytESK0L7ZREiK6L7xREyLALsJEFCIUxjTJLsgeFYbPI9ElzxYWJtcl2STW3CUXFyLgI+Ee5eXm6OQjGOwi7fAe8Rj07SftGSP5Ihn7HvsA/wnkR9CDhoNKNBgcoVBEQ0MeNoiQOGIDRYoQPXA4sVFjxhcdOnwcSVJECAAh+QQFFAAcACwBAAAAHwAcAAAF6CAnjmRpjoAIpGfrBiPsloLA1aZ9z+Ug+icgkMchGAkuJFFUKJCczZJTWjJYR1eO4bQlZUeHcOvAIYvMYBJCvS6t2xz4KZEw1ed0nkIx2vP5SyYLIoMkC4WBIwsMI4wiDI48kY8iDSMNlpaVPJolDjwOny2iI6IPPKcuqQ+nECKuM7CBESK0LraJEiK6LrxEEyITwDPDLsIcFInIJcnMHBUVPNEi0NPQI9MjFhYi3N0c3ibbJeEXI+boHBfmIujr7CXmGCPzIhj1JfP6JPgiGf+BMnAQOHAEQGUkNHBQuJDhQoQzNkjcEAIAOw==", + 39: "data:image/gif;base64,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", + 40: "data:image/gif;base64,R0lGODlhIAAgAPUgAIr/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/3P/cwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAgACwAAAAAIAAgAAAG/0CQcEj8GInIpFIJEAKezCd0SQyAAlYhdrjlUocCUFg8LhMF6PRyABqwh+x4u/2GKwlLPIiA1yP5SQVEBYJDhCCChYaKSAZCBo6OQ5KRIJCWkJdJBwdDnZ4gnZ9KoyAICEmoQ6ispqynp0QJQgmztEi1ILZKuwogvkIKvsBEw7+/wslDCyDMC89CzEjOzUTSRAwg2dvZSdva2t3gRA0NIOboX+fr5eVLDiAO8PBf8+pCDyD5+vf89xAQhgT81w9JhAj3EBYkIkECCIdKIC4kMmHCkooTkVBYQqFjRiIVkoQcGfKjBSIWToI4yfLjhSEvYYJ4GXMihiE3cd7M+TEDCC2fRHwK/QhCgxCjRIxqQJpxgxCnRJxCzchBSNUkHK5O7NABBNclXTN6GOvhXhAAIfkEBRQAHwAsAQABAB8AHwAABf/gJ44jYJJoqqaBGLzr266k8Am2iI94fvuqwUc4JBpXxBThQ1iOllCmqEltpgor7KeA1aq8HwPJIB6Rw2iU+Dw6iA5ud/v9kcPr9xQCMeL3P3x+Kns0Hwkkh4mGCYmMIocfCpKTkSiSlSuXHwsoC54pnKEinqSbHwwiDKqoKqiuKKysDbOFHw22uLQitygOIg7AvjS+xMLCIw/JJA+FzMwfyc+1ELUf1NUoEdXa2CQS1d/dIxPjKuTiIxTqK+voIxUrFfLuIhYq9vj27hckF/wf/AK6wzCCYMEPBA2iyyCCYUOGGRy60/CB4giKGOl92CCCY0eOGzyi4yCC5AgOJE0SouvQ4QNLFC/peZjpAUVNFCEAADs=", + 41: "data:image/gif;base64,R0lGODlhIAAgAPQeAKD/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+Yr/cwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAeACwAAAAAIAAgAAAF/6AnjmRpnmhqdiKbAioKezMa3HgQ6/wdj4KgsBQkngZI5HFAYoqcyhJhRKhaqVjPdFs1FQqnrwjsIXtRhrR6ZBC1PW/27zA60D30+120jyH+IggegoOBI4Q/Hgkii42KjCOLiSIKCh6Wl5SZmpMjCx4Ln6ImnyQMpx6nqiIMqayvJa0jDbQeDSW1t7YitSa6Hg4OwDHCw8YjxSIPDx7MP8zLzcrTIhAQHteJ2djc3SIRER7hJeMn4CblEhIi6yTtne8TEx7zJfLyJPUj9foeFCL/RlAICHDgP4IBCXqoIILhwgoOT0AcwXCiCQsiMGZEgVFjRw8WNI644IFkyZMnTEqiJKHSAwaXIl6+RCGzBIabMzN40DlCJ88TP0X85KnBQ9ERRY+a0KCURNIRGzxEhSrVxIaoV6dSHcGBgwevIrp+JQE27NhOaE+EAAAh+QQFFAAdACwAAAIAIAAdAAAF/2AnjmRpAmhqrqwYBC75vm0tCsKId3neDsBgBzgaFI8rgtJEEDU7T1JUVKgWRtYqddu5krwig2EkHpPMY/R5dWiP2u7OQS6a0+ssRAfB14v4e4F+foE2IgmIh4odCYwjjYYiCpIdCpOXJpORHQsLnCKenyWhmwwMIqcdpiupLA2vrx0NsiKztCS2Iw67HbwtDr3AwL0iwx0PyMeRDyPMzMojEBAd05vU1STYEREd3JHeI97gHRIS5DXl5eci5usjExMd8CTx8PEi8/jy9yQUFB3/+gXsB1DEv4MDO1RQSKLCwhUPGYpwSHGhhQ4XLWi82CIjRxEfLVzoMLIkyUgXUi+OJLESQweXMCO5fDmzRIYON3NGynCzhYYOP4Nas7GhQ9GjQ1tw4NBhKVOmSUeEAAA7", + 42: "data:image/gif;base64,R0lGODlhIAAgAPQaAPr/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+eT/cwAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAaACwAAAAAIAAgAAAF/6AmjmRpnmiqrmzrvnCMZiUtmwAw5jca/JpAENjTCI5IkqA3GGiaIucIGiOICNZsyRoraAreryn8MmjMIvQIbVC7DgdN3DSXw1sIVF6P2J8SIoCAgRqDKAmGKQoniyoKjyYLJ5IqlCOWIwwlmpoqDJ0ioBoNoyMNpCaopqOqqhoOJrAisA6yI7a0Jg8au7u8Ig/BvyO+wMMkEBoQycvKI8zPydEoEdUa1REj1tnaJNwmEhIi4SXiGuTj5igTIuwaE+7tJPD08SUUGvgj+iL8Jv4jKlQ4IVCEwIEEEY6wYEFDQxIMRTB8eIKiiAsaLmAkoVHjCoweV2DAoIGkCpIoiwO4CAEAIfkECRQAGQAsAQAGAB4AGQAABecgkI2ZSJ5oigYByapwnAn0PNdyPOz8OeQqAiEjHA1JRSCpMCownyimcmTIGKrWFFZ5yHRHX9L3EAYiEBl0Sp0+5xIweDwhRylG9zs+o4cp+ioLgTkLhScMKogyiiQMjA0okJAyDZMkkA4ZmSMOmyienJqbng8ppSOlD6ckq6erEBmwsLEjELa0JLO1tyQRGRHAv8IjwL7Exr0pEhIjyyjMzCTOMBMj1RkT19bW2tjdIxQZ4STj4CgU6OgoFRUq7CPs7e7yGRYW9Sj2I/b3MP0ZFwAGPHGh4MAYAQvKwIAhQ8OFDiNmCAEAIfkECRQAGgAsAQAFAB4AGgAABepgpo2aSJ5oigIAyapwrAX0bMu4oO+jjsODgSY4EhZ/KcKIoGySmMhTQVOYUlNWpEGzHXVR3+jhoCGjzOMoArceId6yREwOS9hVilE+r9fwYQp/KguDOAuEJwwqijKMIwyOGg0ok5MyDZYjlg4anCMOniihn50nng8pqCOoD6okqrAnEBqzs7QjELm3JLa7vRoRwBHBxCTDwSPDxsgoEhIjzs0azyTRMBMj2BoT2tnZ3dvgIxQa5CTm4ygU6+soFRUq7yPv8PH1GhYW+Cj5I/n6MABquDCQ4IkLCA3GIIhQBgYMGiA6jEhRQwgAIfkEBRQAGgAsAQAFAB4AGgAABe5gpo2jSJ5oegIAyapwrAX0PNdyLOz8KeSqwUAjHA1JRSCJMCIwnyimclTQFKrWFFZp0HRHX9LXEAYeDhp0Sp0+5xAweBwhRyVg93ssoVcpNH8ogTEKgyMLhyeIMouHC40MKJGRMgyUJJENGpojDZw5mp6dJA4ppSinpKoaqQ8arq4nsLEktK+3JBAaELq8I7y9J7rCKhHGGhHIJMbJI8c5EhIj0SjS0iTUMBMj2xoT3dzc4N7jIxQa5yTp5igU7u4oFRUq8iPy8/T4GhYW+yj8I/j1gzFQwwWDB09cWJgwxsGFMjBg0DAxIsWLGkIAADs=", + 43: "data:image/gif;base64,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", + 44: "data:image/gif;base64,R0lGODlhIAAgAPQfAKD/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/4r/cwAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAfACwAAAAAIAAgAAAF/+AnjmRpnijppSwKvCLwyW0tBsGHj7ltCoJPEAgU+kiDUfIzaDqZxxGB8JlWp1hrVFQofLpgbvcLHrMM6DSalDYZWof45zAX0efy0h2F6JcQI32AJoMmCR+HIomKigmLJI6PIgoKkyOUmJQflSWcmiILHwuhoKOio6gnpKAjDK4ir64MH7KvJrOtIw27H7u8Dbq8JsAnDsYfxw4lxsfLJw/Q0SUPH9HUzyUQIhDc2tsf3dwp3iIRJBHo5h/p6OvqJu8fEiUS9fb2I/Mo+h8TJhMAA/YbARCFPxEUUCRMaIKCw4YjKmz5UEGiCYsiLETReILjiAsmQKIQGbIEBhMnUTCkNGkiwwmXImB+kFmCpggNJ3Ca0FmCZ4kNJoAGPSHUBAejRo+WUHqiQ9MSTqGiCAEAIfkEBRQAHgAsAAACACAAHgAABf+gJ44iQJ5oegasGHivKquC4NWjPcvD4Pm93m+XIoyMHoJymSSiCgUPVAqtTp0ng8Gj7Yq8Xe/sQC6TSWXUYYdoexBvEfztPsHbc1Jif0qM9n4ogR6AIgoeh4YkiQqNKYkjiQsLIpSVk5iUliebIwweDJ8ioZ+kpCqiJw2rIqyrr7AqDSkOtR61uA63uSq6KA/AHsDBIsPDKQ8oEMvMyyPNzioQJBEiEdfYHtjbM9UiEiQS4uPk4OYq4CITJxPt7u4k6yryFCgU9/ge9SP3KvsVKgACTFGhIIqBFrCcsJAQRcMLCkdATDHRAwYUF2dkxDgiAwqPM0CeEOlBQwqTKlAkolDpYUMKlyNgipBJgqYIDihwqtB5gueIDiiApugglETRESEAADs=", + 45: "data:image/gif;base64,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", + 46: "data:image/gif;base64,R0lGODlhIAAgAPQeAKD/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+Yr/cwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAeACwAAAAAIAAgAAAF9qAnjmRpnijadeSankAMjLMn17Utm0HvBb+RTwgUAY9DkcCzXDKVz6dzKiUNPNcrdisaaLfaLHdE8JTLZrRaRFifX6SCqECXe+zwkYFk2Hv8gH4igigHJYaHiXkIJowejiWQKQkoCZQil5h5HgoKIp4moJyimwsLHqckqaabJQwkr68isa0kDSK3Hrm2tSQOJr++vR4PJcXGwx4Qecu9ES/PHtG9Eh7VJNfV170TEyLeJt3DFK3ktRWt6K0WveybF7XwrRgnGPQm93AZJ/se/ST/4GjQQGKgCIMjEMLZsMFDQ4YmID5s+IKDB4scLKbIeLFjsmQhAAAh+QQJFAAdACwCAAIAHAAdAAAF6mAnjiQAlCeprmMgBrDbyawo3AJ56/mI94NgZzAcEYlFZHIYJHSczqdURIhKo9BnobPdcgvesAgs7nYM57QIfTa41yO0vCY61O+dg53eQZD8fiqBfywJhSKGK4ksCoyNIo+QNQsklCuWHQuYLAwMI54koJ18JA0NI6enIqmkIw4irx2xJLOtDyu3JLmkECq9vq0iEa3DrRJ8xx3JrRMdzSTPzc+tFBQi1ivVwRXBHdykFt0d4XQX4h3mdBgsGOsq7jUZLPId9CT2LBoaJPoi/SP/WGzY0IHgwBUHDRJcwaFDQw4N6UB0SFFECAAh+QQJFAAeACwCAAEAHAAeAAAF76AnjmTXlSepriMgArDryWwtBgGJ26PgCyQg0CMM/kSDpGewRI6UziYzOSB4rNardpvFiryEgkcsHhfK57MovR67DR44XDSv00fyOM9zWPX7PAgkgoIqhYMsCYkiiiuNLAqQkSKTlDULJJgrmh4LnCwMDCOiJKSheyMNDakeqyKrrqgOIrMetSS3qA8ruyS9exAqwcKoIhGox6gSPMsezagTHtEk09HTqBQUItor2cUVxR7gexbhHuU2F+Ye6jYYLBjvKvI1GSz2Hvgk+iwaGiT+RAQcMZDFhg0eEB5csVAhwhUcPETkENEGRYkYRYQAACH5BAUUAB4ALAIAAQAcAB4AAAXtoCeOZNeVJ6mKQAuMr+fGseyKQe4F+6j7PFwvFxB4jMajKElKOpWCgUcqnVpFg6q1SrUSPN+vSEwej8Lg1ahQELHZ7rZ6ZFDVPfe8fXUg9fsqgH5qCIQihSuIagmLjCKOj3MKJJMrlR4Kl2oLCyOdJJ+ccysMDCOmpiKooyoNIq4esCSyrCIOK7ckubUPKr2+tSMQwcPBEazHHsnBEh7NJM/Nz8ETEyLWK9XBHhTb3MEV3uGsFt4i5aMX5uqsGGoY7ivxahn0IvUq+HMaGiT8Iv9GBFSzYYMHgwVXJERocAUHDw85PBwlEaJFESEAADs=", + 47: "data:image/gif;base64,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", + 48: "data:image/gif;base64,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", + 49: "data:image/gif;base64,R0lGODlhIAAgAPQfAKD/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/4r/cwAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAfACwAAAAAIAAgAAAF/+AnjmRpnmgqemzrqfAIzHQdp0Gu7/ltCsCgUCAi+kaDpFIpWh4/hKhUCp1Gj4WsNvvZem+GsDj8GRtE4tthzT582u71201CnBD4/CeP3+vtIwmCJYKFhoeIIwoiCospjZCRkSULIguVlpeXI5qbnCUMoSKioaWlI6IfqSUNHw2tIq+yr66wI7O2JQ4OH7u+u728vCLAwcUfDyUPy8zIyyTJJs8iENUf1djZECTb19Yj3yUR4+QmESLk4yTqHxLuIu7vJRLw9PX27R8TEyP8+yL++AE0sU/gBwoURiRMeFAEQoQHHzJUyLACiQoWL2LEOGIjx44ZSVgYSXLkB5MnSEaOQEniwocLMF3GFDFzRM2XJjBgIKFz54eeOksETZFhRIajJo4iNVo0hYYPGp46jUqC6pMTG7KS0HrVBIevJDh0PdGhQ4kQACH5BAkUAB8ALAAAAQAgAB8AAAX/4CeOZOmdqFeu7Aq8cNzOZGDfuE3PQu//AlFwtxoYj0cRkkgiOJ/PDzTK/BSu2Ks1m2UavuDvJ2wQgZmHtPrwWbPTbTYJwULY75+7PY+njxKAO4CDhIUjCiIKiIeKioyNkI4kCyILlh+WmZmVmyOUJAyhIgwfoaaioqWkqiwNHw2ur7CzrrCvJLSxKw4OH7y/vb8lvCLAIw8kD8rLzCXIK8ojENMi09YQLNgf1iTULBHgEd8i4eAk5h8S6unpEiLu6+7tI+ry7BMTIvn5H/z4+PpW/BtBgQJBgyQKKvygsGAJhx8qkKhAsSLFiBJHWMwo4uIKCx8siAQ5skVJESJXQVy4QGIlyw8uX4pwOUImCQwjMOgUobMnzps/Z2T4kGEoi6JFSSStMkODUxJPmbbYQJVEVaksOGglwQFriw4dSoQAACH5BAkUAB8ALAAAAQAgAB8AAAX/4CeOZOmdqFeu7Aq8cNzOZGDfuE3PQu//AlFwtxoYj0cRkkgiOJ/PDzTK/BSu2Ks1m2UavuDvJ2wQgZmHtPrwWbPTbTYRQa9/6vS7HVFKEBOAgYKCJAqGCoWHiCKKjYYkCyMLkx+TlpYil5orDAwinp2hnR+jpKWmJQ2qDSKrrh+qsCSrLA4iDra4urm4Jbu9JA/BD8TFxSXCI8YkEM0izdAQLNLT1BErEdnX2CLa293XEiIS4uXiH+bo4+TsJOQiE/Af8fPwE/fyJPf09RQUIv5K+Bv4YeC/EQQLVqgwYqFDhx8Wkng4keEHCyUwWtioceMKjiQ8XihxYeSIkiZRPZIoufIDhhUvRWCYKXOmzRE0a7bI8CEDTxY+f/YUKrQKCQ1IR2hQapTFhg0jnjalwYHDiKpTW3ToMGKriBAAIfkEBRQAHgAsAAACACAAHgAABf+gJ45kCZwoUK7sGrxw3M6kYN+4Tc9D7/8DUXC3IhiPRxGSSCo4n08PNMr0GK7YqzWbZR6+4K8nfBCBmYi0GuFZs9NtNilBpCfudw/eTlL4FX1/gCKChX8jC4gLiYuNjSKOkYkkDAwilpWZlR6bnJ2eJQ2iDSKjph6iqCSjLA4iDq6wsrGwJbO1JA+5D7y9vSW6I74kEMUixcgQLMrLzBErEdHP0CLS09XPEiIS2t3aHt7g29zkJNwiE+ge6evoE+/qJO/s7RQUIvYl9vse+/cj/PpVqDBioEGDHgaSOLiQoAcLJCxAlChRRMUSFCNCvFCCY8cLHEF6FAGSBEcMJVA3ksDA0gPLlypdxmy5IsOIDDZr4ryZ00PPKiQ0CB2hgShQFhs2jEh6lAYHDiOeNm3RocOIqiJCAAA7", + 50: "data:image/gif;base64,R0lGODlhIAAgAPQeAIr/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+QAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAeACwAAAAAIAAgAAAF/6AnjmRpnmjqAYDqmgEZo/M7CiKOl8JujwNR0DMUDoo/AknpISidzl9hSqKKqNYrysAtGVJfUdh0OJBJ5lI6XUIgTO+2mzT3xEeJU76UyO9FfR5/CgonhYaEhyOKHgsnjj8kkAwelCWWKgyYIpYNDSWeJp8kox6epyIOHqqpKKyrrA6xqyIPD7W3Kbkjux63uRAeEMEkxMIjxscoEREezSXMIs/PzioSHtcn2dgi290oExMp4iLhHuTn5icUKewkFPAe7vEmFSn2Ivb6I/smFin/RvwL6CEgQRIXUiRMqBAFBhIPRUT0gGHijwwlMmg0gbGjDQ0nNIAkAbKkjQ0bTBygRFkiZUobHGLK5OCBJs1ILjp46KBTJ86fLkIAACH5BAkUAB4ALAEAAQAeAB4AAAX/oCeO5AgAZaquZMC67Cp4cynUMTmIu9fzg19ORBgVPYRiMjkcFZxPUeE5JUVThuzIwOKKvKXDIUwakz3mEQKRYpfWbtFaLkokVPfS3U7i3xUKKoGCgIMjgwsqiU0lCwwejyWRMQyRlZUNDSWZKZoknh6aog4epCKmKagOpqunpQ8PIrAxsSS1JRAeELkkvLojvr8pEREexSXEIsfHxisSHs8q0dAi09UpExMs2iLZHtzf3iUULOQkFOge5ukkFSzuIu7yI/MkFiz3I/f5Hvn8IhdYBAwoMAUGEgdFJPSAYeGQDCUySEwBsWIODSo0YCSBsWOODRtSgARZImTIHBxSEKrk4IElS0YxOnjoIFNmjhAAIfkEBRQAHgAsAQABAB4AHgAABf+gJ47kCABlqq5kwLrsKnhzKdQxOYi71/ODX85DIBWJRYLyOCyQCk4R1DMdRVeGURarTR2+39GBNC6VyyIEQrUuqdvp9jqRWNVLdM9dlK8rFCqAgX+CI4ALCyqJQykLDB6PJZExDJMiDA0NJZkpmiSeHpmiDh6kIqYpqA6mq6elDw8isDGxJLWyHg8QHhC7JL68I8DBKRERHsclxiLJycgrEh7RKtPSItXXKRMTLNwi2x7e4eAlFCzmHugU6+ki7CQVLPEiFfXzHvX4JRYs/DEW/khcYDFwIKMRGEgkFLHQA4aGQzKUyEAxhcSLOTSo0KCRhMaPOTZsSCFSZImRI3MTcFjJkoMHly4PxujgoQNNmjlCAAA7", + 51: "data:image/gif;base64,R0lGODlhIAAgAPQeAP/3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/7f/c83/c+T/c/r/c6D/cwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAeACwAAAAAIAAgAAAF+6AnjmRpnmiqrmzndmwsZmNGy6qm656Gq5tS8CfiGEfHJJITAwBET0909HRCiYFswKPNEkcCAVjsIYvCuIFowFazPW01PEYQ1T31PH7/K3j8f4GCfoA/Bh6HiCOHjF8HHo+QIwePlV8ImCKZCB6ZXx4JKqFfCiKlJKenRAsirCWurj8MHrMmtbU4DSK6Jry8OA4eDsEnxMQyDw8eyiTMy8mfEB7S0tPWnx4RItra2dufEiLhHhLh5eJEEyIT6use6u3tMhQi9B70+Pf1PxUi/f0e/gX0h8OCCAsGDXpQmPBgjAsiLkD0AFHiRIsRWWDYiMHDRo8iOHYUeSIEACH5BAkUAB0ALAQAAwAWAB0AAAXiYCeOZGZmZKqK2qi1a7elW13LccdxJN+PvhRgBBgWO0NRchQQBZpNEjRKElQFVqx2ZCUNviNwZ+BVEUSE9DndUZ9jBVF83qHXU4Z8vmMY6fl9Kgckg4Q5HQgpiYiJizEJkCkJHZE5CoeXMQsimySdC50kDAwjpCmmpiQNIg2rKq4dsCIOtB0OK7e0tzEPvIciECnBvyMRHcbGx8o5EiLNzSPQ0CkTItUd1dcT2ikUIhTeI+He4yQVIucV6ecd6egjFiIW8fEd8/D28h0XIhf8+wD3/fM3EINBDB0OIhyhMOHBEAAh+QQJFAAZACwDAAcAGAAZAAAFv2AmjmQGnECpjkHAsq67ZgI9Cjhu7+ogDj5gRhj8qQiEEbK0FCVVhYIoKqVKpzORYWTYZrxdb/ZALh8y5KwKkWGT3GpRYpaYxxUZ/Eq/WvgXan4zDCSEhYcrDYoZDSqKjYxZDg4rlBmTljMPK5txIxAroJ4iESWlpaMSEhmrq6yvcRMisrIjtLUqFBQZuiK7u7zAvSQVI8UVx8UZx8YjFiIWz88Z0tPU19cXIhfaGdrd293c4hjlGBnm5yXp6OYhACH5BAUUAB0ALAQAAwAWAB0AAAXkYCeOZGZmZKqK2qi1q7iRW113cyxyI0/6HWAKAOgQjcWiSEkKiJzOZicQTQkEoitWex1hVYNwRzwmDXQiAqGjZqvXsYJITu/U7SmDXt8xjPZ9fioHJISFaAgpiR0IiYsxCZEpCR2SOgpomDELIpwkngueJAwMI6Upp6ckDSINrCqvHbEiDrUdDiu4tbgxD71oIhApwsAjER3Hx8jLOhIizs4j0dEpEyLWHdbYE9spFCIU3yPi3+QkFSLoFeroHerpIxYiFvLyHfTx9/MdFyIX/fwC8gP4jyCGgxg6IEw4YqFChCEAADs=", + 52: "data:image/gif;base64,R0lGODlhIAAgAPUgAIr/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/3P/cwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAgACwAAAAAIAAgAAAG/0CQcDj8EI/IpBIAUBKbTCcxQK1ar6BA9qpNCgRSIRg0DgsHxIEanWabkYS4nEhI1oUFZx5U6BP9f3sGg0oGQoOGQ4mKhAcgB5BOkJFCjo6VjwcIQwidSZ2eQpsgo6OkRwmpUqkJQ62tZgpEskK0Q7ZvQgu7vEgLuUQMQsIMxUPGwEINRw3NzSDL0NFhDg4g1ddC1dtH2E4PQuBDD+Dk5kjm4iAQ7OsQRO9D7O1J8SARQvhI+kMR/Pz3kEhwMnCgEIMFJShMBmJCQyQOHTIUQoFIRYoTw1QQsjGJhY8gPx6xAEIkyZIi31y4QITlEZdOYArBAILmzJtDMNjEWVMnkVAMQoCCEDqUaNGgGYAmTaqhqYYhT58KkSp16tSmV6tuALF1a64NYMEK8SqEAwizHNKqXcv27NqyIDoIkRv3TQe6dYfgBeGB75u+fYUEFgwiCAAh+QQFFAAfACwAAAEAIAAfAAAF/+Anjh9AnmiqBoFKtqxLCnRt35+Q33o6DDIR8DMMiggoghJ5ZCZHBVdhShVFU1ORYasyaLkfMGnrPXwO6JT5nD6jzGjECEFX0esfvEi+PyX+KH+AHwkihYRGHwouCosijokoCyOTlJEnDJmamJckDSKfDaIjn50iDicOqqokrIkPIrCwHw+1tSezMhAiu7y7EMDAJ70qESLGxyQRy8jKKRLQ0CQSJ9Ii1CPYIxMi3Cjc3h/e4OPhIxQq6Ogn6h8U7ZEVJPIi9CkW+Pn4JxYf+/39/EW6cIFEwRMFCR5EeALDB4ciIEKMOPHhCAwYSWQQsfFDR48fQXLMsJEkSQ0oNT+MUKlSRMuWLl2ilAlzwwebNiNt2LlTRE4RHD4E5UC0qNGjQo0C/dBBRFOmiTo8hTpi6gcPVxNhxSqCa9cPIQAAOw==", + 53: "data:image/gif;base64,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", + 54: "data:image/gif;base64,R0lGODlhIAAgAPUgAIr/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/3P/cwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAgACwAAAAAIAAgAAAG/0CQcEgEfT7EY3HJLAKewycgOm02A9hsdri1LgVfARgkHg/LzQFooF6y30T4kkAA1elMOl6oXxYKRH+ATYKFg0MGXkyJQgaOjEQHkpMHQ5VCl5WXmJJFCEKfoAijRKGfp6JLCSCrQwmtRK2rs0KzsEMKQgq5Rby5vyC/u7xLCwvFRMfKIMrGDEMM0dFF09Qgz8/X0w0g3ELeQw3e4N/d5uJDDulF6kTt6+rxQg9D9ET2IPj48/n8EEUQ/oEQOIQgQSH/ElqJEIFJQxAPhTScyLCJBAlMMArRuBEExotWJjARKYTkEJEorVBoshJESyItXyoiUkFIzSY3rVgoslNIz1SZF4AKCVqEKNGZIDAkHaJUSFMmGYhEBTF1yNSoVaUiJaKhSNcmX2duGLJhLAizQtAW4cCBSVshbOOy9dKhrt0OQuoOucsX794OHgILHky4sOHBQQAAIfkECRQAIAAsAAAAACAAIAAABv9AkHBIFH6KoCNyyQQBAMRnc0oMWIfWAFZLLQq+YPBQ3B0OkIO0MH0mspcEAigOj9OH9mJhL+QXlnt8fYJDBkgGiFOIi4lEB2WOQweTj0UIl5eWSAggnEOYRQlCogmlpkSiIKSqo6lECiCwQwqyr0KwuLexCgtFvSALv77AxL3Gwb0MDEXKS8tCy9Eg0c1CDQ3W2EXX2yDY2tfaDkIO5UjjIOhD4+zp4w8PRPHy80L19iDx+kgQRBD9QgCCEBhwYMEiEYYkRChkIZGEEJdImCgBSUUhFzGCqEixyYQlH0GEHPKx5EgKZVAKUQkCpcuWTSowkQmCphCZNG12sSCEJwhan0gs8LzQhCgRoyCIIu2CAURTJE+fFpEqJEOGIleRZM3aRYMGKl/LhBWyYQOTskPMkkWCdgiHt0XgCuFA5C3duXaHdNjLVwjfDiAAB/5LuK+Hw4gTK17MGHEQACH5BAUUAB8ALAAAAQAgAB8AAAX/4CeOpAgAJVquLBkELtzOpWCPtoDr9Dr8QOBI2CMRWITjJ6kcMVmFwicKjVJH1pJhK+IaWttvl0s6rA5oGnqdJiGKpbcIQZeTEnh8MfHhj/IlCiKCCoWDJIIfhIqDiSQLH5AjC5KPIpCYl5ELDAwkniKgJZ6kH6WdnSINDSWsK64frLKxsasfDiIOurkluyS4wLm7DyUPxCTHxyPEzB/GHxAl0SQQ0yLW19Da2BEf3STf3iLhI93f5CISIxLqJO3t6R/q8ywT9iUTH/n6+Pz2ExTgjAj4geDAggjhVBix8EPDhRAdShQ4woIIixU/WLSAccWFGR8/hBwR8sJIEhhoWKT8sFJEypYrMpCQOVMEzQ8ZZOrE+UHDCA0+VwAN+lPEUKIkNmwYobTph6VPRUCV2nQqh6tXP3AYkVXrVq8lsF7tQLYs2RFmSZwVYdash7dw48p9S2Ku3BAAOw==", + 55: "data:image/gif;base64,R0lGODlhIAAgAPQeAIr/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XP/cwAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAeACwAAAAAIAAgAAAF/6AnjmRpnqgIpGzrBYEre8JY1zM7DCPPk7+chzAcEY5GIlFY8DSdzmZB+nzKDB5s1sDFarvZ2WFMHnsOInQarUYh3nBPfC4XvVuJvD7v2etFCYB9KQoehQqHiIaGiIWLio4tC5MilB6TlAuVmpojDB6foaCgoQyfpKeppyINra6tHrANsa60sLG4JA67ux68Iw4iv76/wS0PDx7JI8nIyMrOyiwQHhDU1CPY1tfXKRERHuDh4yTg3+LmJxLr7CISHusk7+zzJxP39x75+hP8Jfj9+pGgQJDgiIIeEBqkkDChQRIVIkY8IVGihwoXL1YkYaFjRxMePYoISXLEhZMnTVyg9JCSJcsLL1d6wIBhpk0SNHPerKmTZ80MGTwEFTFUqNGhSIMCBUrUgwanJJ5CfSoVqggNVLFe9bCB64iuIrqKDft1A1izJTh4UJt2rdsUHOLm6OCBLl0heGWEAAAh+QQFFAAdACwBAAAAHwAeAAAF/2Anit5onmh6AoDqqsEYx28tCsKY5/Y7dD/RYHgK9kSETlKpXDKfx0JHOi1Yq9MR9WXoeg2dbxgcFpFdh7R63TmI1O33C9GhI+4ien2E1x8THQmCgoGFgYAiiDUKjI2NIgqQHZGTJgsdl5mYl5ubnJmaJgyjpKQdo6cMqaiqqacmDbGxHQ20tba1sre7ty4ODiLAv8Adw8TCKg8dD8rKyyLMzdHNKRAQHdfW2CLa1tfY3tsmEeTlIhEj5h3q6OgmEvDx8O8SHfX38fb6IhP9/hP8+AH012EgQYAiKChciGKhwoQdKERkKLGCxYsnLlbosHHExo4aLYjsYIFkSREiU0ymHKGy5YULHWCKkPkyps2bMGvmfImhQ08RP30K/Rm0J4ajQ3tm6JBhqYmlUFE0ZdrUqVMXGjpk1ZDVBFetX4+42EBWRFmxNjioHRECADs=", + 56: "data:image/gif;base64,R0lGODlhIAAgAPUgAIr/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/3P/cwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAgACwAAAAAIAAgAAAG/0CQcEgUfo7IonK5BACITqZUGQiAqtWrdcoVgATgMHc8HJjPAzKXwCYI2WpuoQCi1+nzeZxoAPUNgIGCfXEHB0OGIIlEi2MIj0KPCCCQknsgCZlCmQmYm5x7CqJCo0Oipwp7C2oLq2oMQwywUrNkDWq3t2MODkO8Qr0gwcNjD0IPyMfGyiDLzVMQQ9FL09NC1koREULb2yDe30Pg4UoS5kIS6OpD6esg7UQTQxPyQvX19vP6RRRCFP3+/P0bAhBEwYJDKghRmBBEhYcPFzZ0yMSCBSIWM2q8eBFERjUXhlwYGVIkiJInyWCYgqHlSiEvuWQgkqGmzZsgZs4co6GnzyqfP0H4nLKhqNGjSzZM4cC0qdMxHJh0mEoVRAclV5dkJeOhSNeuS8ASCQIAIfkEBRQAHwAsAAABAB4AHwAABf/gJ46kCJxoqa5lEJAuK5OC8NX1bc/y8A3AIG/4IRiPBKKswCyImEqZwfChVqnTaVR0+HQP4LC4S0QgRuZPmrSeJd6id+IDl0cVeBFe8eH390oLgiKDI4KHC0oMiotDDVGPQw5Kk5MsD5gfDyKZmpybm5wlEKSjECKlqB+pqyQRK68fEbEitLYkEiK5HxK5u7jAuiQTIhPGI8QfycXMzSQU0CUUItMj1dUf2DMVIhXeI9wf4eJEFh8W6OnoIupEFx8X8fLv8iPvPBgyGPv5Iv0zGUZkGEiw4IeAAXloWMiw4UIRDFlsmEixosQVHDJq3EiEQ4kOIEOK6KCC5AqTPDwJlFCpckVLESEAADs=", + 57: "data:image/gif;base64,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", + 58: "data:image/gif;base64,R0lGODlhIAAgAPQbAOT/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+c3/cwAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAbACwAAAAAIAAgAAAF9+AmjmRpnmiqrmzrvvCozbEKAOON12SABj7eRjAiloy1gWigNDVjBMJKCitsCtiUFWbYGL6q7uuwOZjJKTQLsUG426v3KrFJ2OsluumOUig2fiJ/JIMnhRsLI4kLjIgniY8kDAwbk5WWlCaZmSOcIg2gG6ANnyekpCSnIw4brA6vrCKxJK4lsyIPDxu5uSS6vrjAJRDExcPHGxAkyiYRzhHNJdAb0yLVLhIk2SLbGxLdLRMTJeLjI+PmLRQlFOsb7iPwKxUl9PQb9/gi+SoWJRb+RgQc2OLCiAsGDR4UgXCDwhUYTEQcMRFDxIksMmjcaIKjRiEvQgAAIfkEBRQAGgAsAQAFAB4AGgAABeugJo4kYJJoqo5BwLZrTAqrQMvrMOooj6MEESGYIv5GhQJOedQYnIZnLHo8aA7YH9YaQ2gQYO9RnEpoEuhzU51SaBTw99qNWiw0dtE9ta/fGSOADIMagCqGhiKGDQ0ajI6PjSmSkiKVGg6ZmJqYKg4inyOhGg+kpA+oI6Ukq6sirhoQELGysyO2tyK4sSQRvr+9Eb0jwsQoEsgSJMrLzSLKzDETEyjT1iTU1DIUKBTcIt8a4eEpFSjmGujo6eoxFijvGvHx8hbzKxcjF/n5Gvwi/fwBVIEhRUENBQ8eFJFwRYaHEDU8HBGRxMMQADs=", + 59: "data:image/gif;base64,R0lGODlhIAAgAPQfALf/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/6D/c4r/cwAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAfACwAAAAAIAAgAAAF/+AnjmRpnujpeSKbvp0Yj9080+8IfLvOA8CeT3gKfIzGYyCZJDFRgmiUJK2KBNcpaiDijrxcb3dAJpsIaMIHPWKf3epS4TMv2O2jO57Op99LBoGCBh+EhYWGIoM5HwcjB46NkZOQjpONJAgIIpqbnh+anKGboJ85CQkiqSSpq4wjCrEfCrOxtLW4KQsiuyMLvbvBH728wyYMyCPIDB/MzSLJyc/TIg3WDSbX2Ngf1iXbIw4f4uPhDuLn6Orm6SMP7x8P8STw9fLuIvAiECMQ/v38Pvj7N3BfwIAmIkT4sFCEQoUMG454+HCEhIsYJVi8+IEjRhEaNaaY8GGCSZIjSIWaNHFSBMoSFCh8iCmTZs2YImjmlJmiQoUPPoEC/Tnip1GiJSxYELH0g1KnUJU2dfoUKokLWC+IyPoBa1etWr+C9UoCwwgMaM+aXWv2Q9q0bktkIJGh7ge7defm1XvXrgkNGkQEDjwCsOHBhhltELFhsePHjz80bsyIA4cPly1rxqw5M4oQACH5BAkUAB4ALAEAAgAeAB4AAAX/oCd2o2ieKImigNeawPuy7ioGHo7f+372K4FQaBJ4hkSR8ZhEDURP6CAaNU2vVQ9hS9B2RdwweAs+FTznglotOqPfb/fa7THY74Z6Pb/C20wHgIEeB4WFIoaBg4ciCAiNjh6Pk4+SkZWRkn8eCQkinieeoJsnCqYeCqimqaqtpCgLCyKytB6ypAwiuR4Mvby6urm+fw3FK8XGDSLGJsrKIg7RDifSHtXR1tPQ2w8e3d7gJg/d497fIuThEOse7CLu6+zxJvHrESYR+R73Ivn6+if4ATwhoaCJghI8GEQoImFChSImSJw48cQEDxJXUMxogoIHjxRCfgwJUuRIkzYqcXiooJLlypUqTbSEKSKmBQsicHq4ubPnTZ07eQYVcaHoBaJFPSRdivSoURMYoGKIKmKqh6hWr2KlStVDhhMZwnr9GpZsWa9jv57QYIIt27Ya4sb1IPetjQ0bROD1kHcv3r6A927iwMFDYcKIDSM+bCMEACH5BAkUAB0ALAEAAwAeAB0AAAX/YCeOJACIJ6muYyC6Lwy/7Cp0t3gLPE/uNdGgMywOhkQVErkiOJ2jp7RDED2DBVFWy912CuDwykA2dMgitKqcXh0674NcLqKP4vW5CsHvIzp/gXwifkEjCYeIHYoiCY6Iio4qCgojlB2VlJeYnJiVnSsLCx2iIqOnpIYdDCKsrayusbCuLA22I7e2uSK3uB0NIw7CDirCHcPHxMYixMcdD88i0NPUz9Uj09EdENzbECTd3N3eI+LcESMR6h3o6+rt6+ki8SQS9vUSHff69/n5+iImBJxAkGAHgwILqiiosAOFhw4dQpRIQcTDihcNVehQYWNHjhw/ivAIUoUFCyJQYHY4ubLlSZYrWapEeaHmBRE2O9TUefMmz542b2IYgaEo0aFIh3YwanTpiAwkMkjtMFUqVKtXqU4doYFE165cNYgV22Es2BUb0opQu6ED27du07YNwoFDB7t1897Ni5dFCAAh+QQFFAAfACwBAAEAHgAfAAAF/+AnjqTniSepruzYdSLczivwAThOs4HYf4Ggj/TbCT7HkWDJTCKfs8FHKp2KqKRqdUXodkfflndWEJVHhXQarV6rDHDDBz6S00Vx/Orw4R/+fyKBfYR8fYAqCIqLCB+Nj40ijDsfCSMJlpUkmJianiQKCiOhH6KhpKWppaaiLAsLH68isLSxOwwiuLm4ur28uiwNwiPDwsUiw8QfDSMOzg4qzh/P09DSItDTHw/bItzf4NvhI9/dHxDo5xAk6ejp6iPu6BEjEfYf9Pf2+ff1Iv0kJAgMKOHDQIMDCxY0KGJCwwkQIX6Q6DCiiogWP1DYqFEjR48URGwMOZJGhQ8VTm6mRIlypQiVLFVYsCCC5oeZN3POxHkTp02aF4JeECH0Q1CjQ4ciTSp0KIYRGKJCfUr16QepUq+OyEAig9cPX71yFTsW7NcRGkSkXUtCg9u3H96mZbFhw4i6H+zirau3L94ZHDh8EBy48ODChFmEAAA7", + 60: "data:image/gif;base64,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", + 61: "data:image/gif;base64,R0lGODlhIAAgAPUgAHP/c4r/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAgACwAAAAAIAAgAAAG/0CQEAQYGo9IYTEJCgSY0KEzKQBVo9Dq1TgAdbHM7tdIEJbBx/P5WBC20e540jCko+0gPPIw5GP9IIBMCEMIhEmGhWAJRgmMR46NaApDlAqXmCCUQptMC58gC0KiUKSin6RHDCAMratYrquvSA1CtQ24tUe5t7ZMDkLARsLBR8LESA9MyiDMyVEQRhDRSdPSWBFCEdvbRtzdINlYEkIS5CDm5efp6GgTQu/w8vPxYBRDFPn3IPr7/HAgKhwRGHAgQBAWhCREqLAhQ4AXQES8EHEIRYkYD2LAAILjxo0dO3I8KCRDBhAmS55MaWQlHA0gNMiECTOmkJkzj2wAsdNIT0UkG4L+HPKTg1GjIJAmRcLBiNKlTTsckQqig1SqQq5qrWp1iAcQX4V4GOsV7NivYdEeCSvkg1sQH+DKbRu3rdy4bt+CCAIAIfkECRQAIAAsAAAAACAAIAAABv9AkHAIGBqPSGExCQoEmNChMykAVaPQ6tU4AHWxzO7XSBCWwcfz+VgQttHueNIwpKPtIDzyMORj/SCATAhDCIRJhoVgCUYJjEeOjWgKQ5QKl5gglEKbTAufIAtColCkop+kRwwgDK2rWK6rr0gNQrUNuLVHube2TA5CwEbCwUfCxEgPTMogzMlREEYQ0UnT0lgRQhHb20bc3SDZWBJCEuQg5uXn6ehoE0Lv8PLz8WAUQxT59yD6+/xwICocERhwIEAQFoQkRKiwIUOAF0BEvBBxCEWJGA9iwACC48aNHTtyjJIBREkjGUqmFLJyZRQNMGMK0TATREyaNLFsQLKh585DJD+H7AzKAURRIRyOIkVyNKnRpE6NdJgKgqpVqVU7CNGKFYSHI1+/evXqoexYIWXFjhX7oe0HEG/jDmk7F65dt0OCAAAh+QQFFAAgACwAAAAAIAAgAAAG/0CQUAgYGo9IYlIYCCyfw2ZSAKJCn1SrcQDiXpdcr5EgJH+PZvOxIGSf2/CkYTg/10F35GG4v/ZBf0sIQwiDSYWEXwlGCYtHjYxnCkOTCpaXIJNCmksLniALQqFPo6Geo0cMIAysqletqq5IDUK0Dbe0R7i2tUsOQr9GwcBHwcNID0vJIMvIUBBGENBJ0tFXEUIR2tpG29wg2FcSQhLjIOXk5ujnZxNC7u/x8vBfFEMU+PYg+fr7byAVjgQEKPAfCAtCEB5MyHDhvwsgIF6AOGRixIsGMWAAsVGjRo4cNxoUkiEDCJNDTJYcKURDSxAaYrp0CfPLBhA3h2zIiWSnkUCbPIVwGDoURFGjSDgIVUr0KIgOR6A+hSpVCFWpVa2C8LB1iIevXrd+5cpVyNiwZUF8WKu27YchbIW8nas2LoggADs=", + 62: "data:image/gif;base64,R0lGODlhIAAgAPUgAKD/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/3P/c4r/cwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAgACwAAAAAIAAgAAAG/0CQcEgsFj1CD9LIbBY/H2HUaQRQQQAr9joMBLreLhj0vQoEQ7RQrU6D2s3BQDgn1uvDOb5J6DP7BEaBgVcFBSCHiIpNh4lUBkWQTgaUXAcHRJhOlyCaRggIIKChoqGgn6RNCQlCq66rraxDrLJMCgpEt7q5uCC4vUwLC0bCwkXGw8NMDAxDzc7PINHM0k4NRNcg2dja3EwODkLgROEg4eXm5uhGD0Lt7kMP7/Ag804QQvj5TPpcQhH/hgA0MtBJQSESEA5JWIShE4dCJgyRCGICRSIXmWQUQmFIRxAfOYJ0QiEkkQpDUFZAedLJSiEWisQEMTOmhZs3neS8wLNIT00hPINeADHUSFAMSJE6SVoEg5GkGaJKbZKBSVUiUjNo2MpVgxGvTcCC6Kphg9mzZ5uYZYLWLIe3cOMOift2Lt24HfLq3dsBBN+/gPMGAQAh+QQFFAAeACwAAAIAIAAeAAAF/6AnjmRplgBwruwZtKQAmzI8DOONi/vOwwTCSCgiGonFVqEgYpKcTk80ujJYT1YDSSvitg4HT1hMNo3HMERJvVKzV4mEJ06S00tx+UqhEPH7Hnx+JoKAJQsLI4iLiCKNih6JJwwMJZSXJJQilR6cJQ0NI6EioKAeo6empysOJK0erQ6vsSWvJw8juLgeu7oiu7wtECPDHsUQxcYiyMkrESPPHtEk084lEiPYItrZMNwjEyLh4iXjLOYjFOnrJOorFO4lFSPzHvX2+CsV9RYl/SL9AloY+O/EQA8XEpa4IIJhwocOTzzEQJFiCYseKl40UTGDx48rMpwQSeJjBg0oUytqMLFyRUsPKjVsmEmT5oqZJ2rO5MCzp88RPnkCDeqzg9GjSDt4SMq0qdEQADs=", + 63: "data:image/gif;base64,R0lGODlhIAAgAPUgAHP/c4r/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAgACwAAAAAIAAgAAAG/0CQcEgEAYiA5LHIHAaaT2E0QG0yBSAsUcDdDrVW4UA8HJNB47Q5DCII3e24e06Eswuggj5fxPOFfmwGIAaFQoNDiIOLbEIHjkOPkpCRjQgITZggmpyabAmgTQlCoSCjjUIKCiCrQ6pWr02qrQsLILW1qLZMuEIMIL++wEPBw8JFDMlCDcvMQw3QINDOz0XTQg5EDtlh3CDe2NtCD0zkTeTmIOkP6VYQ7kIQ7+/xYRERQvj5Q/r7+P1hJIAQyITgEAkCDbKZwLBIQ4cTUAmhQLGiRSYV2VQAsXEjE49EKoBsYgFESZNFSp4cslIiiAtDLsB8OfOlSyIYhGDIOYQnzz2bQjIEBZFBKFGgTDQIUQqCKVOkQjYMkQqCalWoQjhkHaJ1K9YOQsAOESsWqgchZ4mcTYv0g1u3Rd5+YBMEACH5BAUUACAALAAAAAAfACAAAAb/QJAQBBgaj8ikMcBcIplNpVFAnR4FQipWOhwYB2CkVziWEoxnYVoNOhPWyELBOK+D5kJ8XmlA9o1/QoGBRwdJhkOIQoaMhQeGCEiRk0aRQpaVCJEJSZxCnqCeRwmkQgpJCqcgqaZSqacLC0ixSrGyR7YgDLtDvFxCDEa+IA0NxMXEyULGy0bMykMODknTINXVRtLYRg/d3kLf4d1D30cQ5krnQhDs7EoRRvBJ8kL0ShIgEvj5Sfv8v0YmgBAohODAggCRUFh4hGHCJBUiSpz40IgFEBcvItFY8QIIjx+PeARZ8QiGIRhOgkhZ8kgGIRleDpHZUogGmzhB3KwJYsMQJZ89f/LkIIRo0SFGW3YQsnRI06YtPQiRakQq1ZIfsmY9ovWDlCAAOw==", + 64: "data:image/gif;base64,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", + 65: "data:image/gif;base64,R0lGODlhIAAgAPQeALf/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+Yr/c6D/cwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJCgAeACwAAAAAIAAgAAAF/6AnjmRpnic3qiXnuu1rdjTt2WJX6jnJiwAUYOgJGovD4CjpCYycImhzSpIGrlCnQLT1dLlegXgsBnO/g9Mg7Vmz22k36e0h2O+EEt5Oyo/8IgUjBYIlhIeFHomBKAaNHo6OjycHKCaVlygIJZsnnZwoCSSiJaQepiKoJAolrB4KsK6wryOuJwsluJYeC726KAwlwbsew7sNJcgmyiLMlg4mDtLPxB4PJw/Z2tvZ1R4QJRDgluPEEREk6Ooe6+veHhLx8fD0EvX27x4TI/v9+v/+3lEYMbCgh4IDD76rUKKCQ4YOSTD0ZsFERQsYS1T0dsFERxEfR4TchaFkSREYSCGkLHHSUgYTL0nEhGlJgwmbJHDetLShp8+eJn7+zEfURAgAIfkECRQAHgAsAAABAB8AHgAABf+gJ3KiR5ZoWnLsWXYw7Mlv3KH3WwKqCPw8FPAn/AVKR1HSc2wyn8qAVCkQVT1XazVrLWUF10FvIPaQz+gzquwhuN8E1LvkbtfppUJenyr4/3l9KgY9HgaHiIWGKgeKjY8ejYwpCCqVhZeUKQmbPZwinyWhJQoppSIKqaepHqetPQspsYoiC7azKgwpurQivIUNKQ3DKsElxoUOPcq0zIoPKdAP09TV070QKRDbtNm9EeDgHhHj5eTn5b0iEuzsHhLv8fDu6iITJff5Hvr69RQl/wJ6CPhvYL0KKSooRKgQBUJ1FlREtEAxRUR1F1RkFLGxREdFGEKGFIEBRckUIwsbZVCxEkVLloU0qJCJgubMQhty6sypYudOFCEAACH5BAkUABwALAAAAwAfABwAAAX/ICcCIkeWI6Ce5cqKQRxzMx2gdHnrpYD3Ap+QIwz6gIJBSSliDpTMpfPpJIisHCxBu+12r6WtqIArkEvmM8e8ZqNLhrj8J5/DUYbSQf/jHP6AfCh7Pwh9HIaJh4h9CYs4jj+RKAo/lX2XOJklCzidniILn5x9DDimHAyqqKuoqYcNOLGPHA22iw44ubS7iw8/D8EovyXEixB9EMrLzMq0HBE4EdGL1I8SEijZ2xzc3M8cE+Li4eUT5ufgHBQl7O7r8O/gFSX09hz29PjgFjgW//3+oej37MIPgxcS4jBIC4NDhyIwoJCIA+KhDD8wotCY8ZCGHx9RhAR5aIPJkyZ/BaBEiSIEACH5BAUUAB4ALAAAAQAfAB4AAAX/oCeOJMmdZ6mS3diy5St2tCwCOO7pe08Ct98osPIEjsbSETk8CkZPUfQpqFqtUqxHMBB1Pd9BWDwii7/gL6FEWJPacLdI7pEX7ngVPj8qkPwiBiOCK4KGgyWEJQdFjYsrCCWRkJQqCSSXJZmZmioKJZ8eCqOhpKArCyWpjqserSUMsI4iDLWNDSW4s7qNDioOwCS+I8ONDysPycrLybMeECUQ0I3TjhERJNjaHtvbzh4S4eHg5BLl5t8eEyPr7erv7t8UI/P1HvXz998VJRX+/P5I8HNmQUVBCwhLFHR2QUVDEQ9HRGyEoWJFERhIZCxxsUgGFR9JhARZRIMKkyRQDZ4ssqGly5YqXr4kEQIAOw==", + 66: "data:image/gif;base64,R0lGODlhIAAgAPQZAPr/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+QAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAZACwAAAAAIAAgAAAF/2AmjmRpnmiqrmzrvnAsz/QJqEGe5cGuoz+TQJAhEkXG4pGUNA0Go2cUKpKSqNQSIUPYcr/crVcrLhUyhfNILUqjUWe2yJChG+hzez2lHx0yfyIHf4OCg4EnhCQICCuMjSiNkBkJlCOVIpiWCZycJpWaCgoZo6SiIqOnJKKnrSMLGbCvJLALsia2sSMMGbwMv77AvcMpvCQNyBkNJcvIyynPJQ4k09Mj1inYJA8PItzf3t0j4tspEBAl5yLo6yfsJhEZ8fPyIvEj9yT5JhIZEv/+/vUTOBDgCIMnJoxQmGGCQoYNI5aAOIICBREWMV68WFEjxwwfRVQQOVJkhgolSS6iHLEypQULImDGhClzJs0SNzNc0KlzJ88LQEnsDDoC6FARGDIkTSpjqdIaLEIAACH5BAUUABkALAEABgAfABkAAAX/YCZmAECW56iuo6kGQRaLMcze8iwI2b73PiBOxRMMjgNVcoRc4pZJQkZKkIqq0+wwKy1kCt6vFywCk4djkcGwXa/bGfYhMxfV6aP5naUfIRAZgIF/IoCEf4QqhiMJGY2MKo0JjyKTk46YGQqamgqenZ+bmzehIwsLIqgqqqdbGaojDAwisrW0s1u4Kg0rvLuuvisOI8PDIsbELMgrDxkPz8/OIs3TN9QrEDfZGdsi3SPfKhEZ4+Xk5RHp5yvqOBIj70PxKvMqEyP3GRP3+fr+K/1EUKAgkGCGgQdVGBxoMOGICiIqQIyYQaIKiRYjQpxowYIIjx89ggwpckXJCxlQGF5AmTLlShUqWYpYqTIDBps4Xd24yTNDCAA7", + 67: "data:image/gif;base64,R0lGODlhIAAgAPUfAIr/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Ixz9HNz/5hz7n9z+XP/cwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAfACwAAAAAIAAgAAAF9+AnjmRpnigJjOv6tWxaBiL90TZe77Io+J9fUPgj9j4D0SCZPDGbzRRhNBVVqx8sVlbojgofL1jUHcsMJLRatEaP3KmD/CCSk+yfOf04Qnz8fn+CgXwjCQkiiCWKh4UmCo+OMgsklJIpDAwimZcpDR8Nn5+dJg4OJKakIw8PIq0fr6ykEB8QtLW3trWdER8Rv8DBvpcSIxLHIsfFyZITIs4n0NCFFCIU1djWH9mOFR/e3iLh4N+SFh/n6egi6ueOFx/w8iMX8/CSGBgf+iL8+vmqRGQgkWFgwA8aRiQUsfDghw4PRUB0WGIDxREePmQUsfGiCA6OQgAAIfkECRQAHQAsBAABABgAHwAABd9gJwLi2JFnWqJiUL5w3MaCWNfdbcOD2MvA309EIHaKBOTRCCuUnFBR1CkVGaydqza77WJhh044LC6TYYhOeo1Il9prtTyW6NTr9jw+phD1FX0wgB2BgUALMYhAQAwvjYtADQ0ikpBADh0OmJiWJQ8PIqAdop+WEB0Qp6iqqaiQER0RsrO0sYsSJRK6Irq4vEATIsEyw8MxFCIUyMvJHcwyFR3R0SLU09JAFh3a3C/d2jIXHeLiMOTjixgYHeoi6+3tnTIZ8i8aIvca9/X8ixsd//4B7EdwEYcOHA4iBBICACH5BAUUACAALAIAAAAcACAAAAb/QJDwIyyCiMSj0rgUApzMZ3QKkoICzKzWiAUJmF9jOFwkC78DYdqYXreZ7i2IMBcS6HV8tiDkgwp8gX+CgX6GIAZCiYqIjY2Ji46RRgcHIJaYmJeXlloICEagokKjoEWfWwkJIKqrRa2srnJFCiC1tba5uHILC0K+vVnBviDBs0IMWcnHcg1GzsxyDg5C09FyDyAP2dnXRhAQQuEg4+DeESAR6Onr6unXEiAS8/T18tETRRP7Qvv5/cwoCBGohSDBWRWEVEjIJKFDZhZARJxohGLEYxdAZMwohONGjcwwgBApUkhJkiOZZQCxsqURlyuZadCwheZMb0U6CNHZQSdOFSEbigQFMfRnFg8gkBoVwgFE02tBAAA7", + 68: "data:image/gif;base64,R0lGODlhIAAgAPUfAIr/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/3P/cwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAfACwAAAAAIAAgAAAF/+AnjmRpnmj6ASyrvmUgzwEMCziZ2+kwmD8eikAQFY9CVKFgYiZNhqhU+jQdrofRtSpCeL9gcDJBLpvPZZtizW673a+FXF6a1+0ohn5vYvT5Jw2Cgw02hCgOiYoONouMJQ+RkpIiD5CVk5YlEJydH54onqAkEaWmER+mI6giqqesIxKysxIftLe0trkkE70fvr3BwsO/wiUUyBQiycwjzMjL0CQV1NQf1dYm2NfVJRbf3x/gFing4uYkF+rqH+sv7OsXJRj09B/1L/b1GCYZ/hkf/r3wF1BgCQ0jNChEqELhh4UMSWwYMXHDRBUWP1jMaIKDCI8cQpLwOBIkSZIlOhh0EKFSJYqWH1ayVOGhps0SNm96ELHzQwgAIfkEBRQAIAAsAgAAABwAIAAABv9AkHA4/BiPxKRSCWg6m8soMUANDKtSqWCb5GaXgzBoMB6Tv0qCOrlGJwvwuNydNNjtwvudfuj7/4AHXwiEhYaHhVIJi4yNjo5LCpKSSZOVlkQLmptKC52cRAyio26jokQNqapuqqlDDrCwILJCDkm2srG2IA+9vrwPUr3AvxDGxxAgx0PJQsvGyskR09QRINXY2ELUIBLe393f4uPe4eUT6Okg6epC7Ojr6hTzIPTz90n39vgV/RVC/votCQiCoIWDB0EgtCAFoUKHFyJGBCHxy0SJF0Bg2LhRY8csHTliAJGhZEmSJ7OcTJlBg0uXIF5+galhSM0NODcIyZkF584lnxyGBOVANKhQoUSFFBXSYUjTDlChJokqdYkHIR6yat3KVWuSIAA7", + 69: "data:image/gif;base64,R0lGODlhIAAgAPQdALf/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+aD/cwAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAdACwAAAAAIAAgAAAF/2AnjmRpnmiqrmzHvW+rAiI90rZcBrzZ6yaBSCAkdozA0QC1XCZFBBQhOpUVCh3s6SrCalMGgyjcIZdJ4nI4bTqUDm64SO7uyO11EqK07yD2fyJ/gYF+fSMJJYmJJoyIjyQKkQqSJ5WTlyMLCyKbnJwmoCSgoh0MIgynp6YmqiWrqyINI7Oys7Udt7i5tbsOIw6/vx3CwcQiwcbCJQ8iD88dzSbS0SPS1CMQ2tknECTb3iLhIhEj5eTnHRHpJOvr6iQSI/Ii8hL39fQd+Pr6HRMiJgD8F/DfQIECSSA0QYFCB4cQSzh8SHHExBUVRFTYqHHExo8ZM66wQMKCSZIiUDl2OKlSxQUSF17GfAkz5goMODGIyEkiJ0+dKTKQEJpBaAmjHYoWRaGBqYmmT1FsmEp1qtSqVJ8ACQEAIfkECRQAHAAsAgADABwAHAAABf8gJ47kCJxnqa5cILqjC7OrYKs3zQ7iwPscoK5EYBWLQ1KBVVg2aYYox8CSTq+qw+ig5Yq02y8XLEKUEGZ0Ob1ucxIl+BuekNfrcxFeUeLzVX8jgXwLJAuHLIUlh4oMDCKOj48qkySTDA0iDZmZHJ0knCWdDQ4jpSIOpaccqquspw4PIw+yshy1tLcitLm1HBAiEMK/K8DBI8bGEcsjESrOJMzQHBESI9YiEtba2yrc2xMj4Rzj4RPl5+ki5RQiFO3wJe0c8SPv8xUVHPr6+/37I/LlC8jCAgmDHBAmHGGhocISFyByuEAxIomKKzBoJLFRBAaOHz+WyDAiA0mTJEsXouSAMqUIDSxglpA5k8SGmzhxqsjJMwQAIfkECRQAHAAsAQADAB8AHAAABf8gJ47kCJxnqa5qwLkjDLM0Jwgqjtf0wA0+oEjIWxFYR4KyyCkUmjQnVMoyGETW6hVrzZYO34NYBB6Bx+SyCFFir90ItpwTH9VFiVI+j+fzR38cfAochCIKiCyGJIiJHAsjkAuTjyuQJZeVDCSbmxyenJ8loJ8NJA2mHKiqI6arrakiDQ4jDrYctLi4t7m2vLu5D8IPI8QqxhzIyMkjECLOHNAl0tHO1tYjEdkiEdrc3iXd4OASIhLlHOXn6Ocj7evtJBPzIhP1HPT48/Yj/DUUHACSEAhQoAiDNCqIqMBw4QiGEBUqrGGBhIWLFUVk5IBxI40LJC6AFAkypMgaGFIoYhChkoTKlitZZCAxM8PMEjc52LS5QgMLnyWABl2xoajRoiyOHhURAgAh+QQFFAAdACwBAAIAHwAdAAAF/2AnjuTInWeprirQuSMMs3QXBCqO17TQCT6gSMhbDVjHY1FFYBGaz2Wh0KGupiIqlmUwiLodcJjkDXfFpEPpoGaL3OqO+x0XIUr3DuK+t+/5eXqBCSWEhCqHI4kdhwodjiIKkiyQJJKTHQsjmgudmSuaJaGfDCSlpR2opqklqqkNJA2wHbK0I7C1t7MiDQ4jDsAdvsLCwcPAxsXDD8wPI84q0B3S0tMjECLYHdol3NvY4OAjEeMiEeTm6CXn6uoSIhLvHe/x8vEj9/X3JBP9IhP/OvgT2A/gCIM1KHRQSIKhQoYiINKoIKKCxYojLGqkSLGGBRIWQn4UMbKDyJI0LjOQuKCSpcqVLGtgmIlBBE0SNG/WZJGBRM8MPUsE7QAU6AoNLJCWULp0xYanUJ+yiBpVRAgAOw==", + 70: "data:image/gif;base64,R0lGODlhIAAgAPQeAKD/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+Yr/cwAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAeACwAAAAAIAAgAAAF/6AnjmRpnmfnqSbbvStbyiPg2TcJ2LzZkwFR0DMEEo9GYUkg8DCbpKcTuqSiPAPRILvtZrXb0fdKKHvKZvT5Si6I3O51Ic5+jwx4j0F/t/P3VweCB38khCKHgnWIIwgejo2NkIuPkQkil5eYlCMKHgqen5ugm5yiCySopyKqnAwMJbAesrCvpg0NsbO5syK4lA7BJMHEIw6+x3UPD8PLHsvMIszObBDWECPYz8/a0twoEeEiEePk5h7i5egnEh4S7e8i8CPt9PT1JBMe+vsi+vz+AP6bQNAEBQ8HSVBYqJChQRMVREQcUWEixYokKka0OMKCBwseRYA0ATJkCZNXLj2oNLGyRMs6GGKaiInBVIkMHjLgHKGz585FGkRoCOqBqNCjRets2FB06QinTZ8KZXqCgwirV1FgLbHVptcQACH5BAkUAB0ALAEAAgAeAB0AAAX/YCcCHSmeJqCW5um6QRfLZxDfL613gtjzr54w6HsNBp2jUanMiZDODkFEmFavUyo2eip4pd4CWCx+lTsGcxrNZhvW3Db6cHCf6vI6/oXoIzp/f3eDgH1xCSeIiImJi3EdCoyRkJQik4+UCwuWnJqcmB0MoS6io6aljw0NL6umo6qpDjmyDrIitrVcD7svu74uD7fBThAQvcUdxcYnxsg5EdARLtLJydTM1i4S2ycSItze4d7d4ScTHRPnIurn6ugv7ukiFB308/f28/n59fQVIv9eVBjoYmDAgh3+WRCx8IWFhiceQmTIcOGFDhddXNiYY2NGjRhdYBCJYeSLkiZPMZhMmSNDhwwuVcKc2fKFBhEabnbQibPnThc8d24QOhRn0Q1FfwrNwUFEU6dRnr6QGgIAIfkECRQAHgAsAgABAB0AHgAABf+g14leaXYjOpJmu3oAXMZmbNOtXQZ73/LAls/D8wgExqNQeUQKk0/ToDSYVq9TalUa9RC+3i8hPB53n4VCSa32hs9rk2HuMdTl8bv9eegf9C1/JYJ9cAgmh4eIiIqGiwklkJCRcCYKHgqXmJSZlJWbCy2hoCWjlQwMQqkeq6monw0NqqyyrCWxcA66Lbq9Jg63wF0PD7zEHsTFJcXHURDPECbRyMjTy9VCEdolEdzd3x7b3uEtEh4S5ugl6Sbm7e3uHhPyJfP09vX48xP8+BQe/1pQGCiQ4JOAHiqUUGiiAsOGDls4VPjQggcLFktgfIIxoxCPTy6IDHmBJBwMKJ8xoMTwSUgGDxlemohJU+YZDSU04PSwM6dPnl02bOAp1ERRokZzDm3BoURTp0GjPPUQAgAh+QQFFAAdACwBAAIAHgAdAAAF/2AnAh0pjiSgjmfrikEXy2dsz+2MCyLf+b2f0OUDigaDDtK1RCZfR6iIMKUSrtgT9irVFgqd7zc8BrvM4bNBtF6nDe5u53A62Od4tl5PfyH+CHiBdYRzf3IJJ4mJioqMch0KjZKRlSKUkJULC5edm52ZHQyiLaOkp6aQDQ0urKekq6oOL7MOsyK3tl0PvC68vy0PuMJQEBC+xh3GxyfHyS8R0REt08rK1c3XLRLcJxIi3d/i397iJxMdE+gi6+jr6S7v6iIUHfX0+Pf0+vr29RUiALqoQLAFQYEGOwC0IIKhCwsOT0CM2LAhwwsdMLa4wPEFR40bM7bAMBIDSRcmTzKeOKnyRYYOGV6ujEnTpQsNIjTg7LAzp0+eLXry3DCUaE6jG4wCHfqCgwinT6VAdTE1BAA7", + 71: "data:image/gif;base64,R0lGODlhIAAgAPUgAIr/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/3P/cwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAgACwAAAAAIAAgAAAG/0CQcEgkfo7FpHIpBAydzGgyMJVaQYKiIHuNDoTfcDdKABHKwrJ6TCwk3aACnA0yCO1FvB3fPYD8QoBFglEIIIaHQgiIiESGjUsJIJJJlJVRCiCZRQqdTJtMCwtXo0OjpUsMIKpDrEWuq0sNILO0RLVJuLhJDkO9Qr0Ov0TDwUoPIMjJUcrKy0oQQtHRTNQg1NZDESDb20LeSt7g4EQSQuYg6Erq7EkTQu/wTPEg8e/0QhRD+iD8/Er+mFQAMZAgkQoFhQxMmDCJBQtDIBaRCELiw4pdLhDRqHFIxwsgrWAAMVJISZIm6QjJAIJlSyIuXY7RIIQmzSE3QeSkswFETx4iP3/S4SCE6BKjYzoQUboUBNMxHkBEnUqEatQlQQAAIfkEBRQAHwAsAgABAB0AHwAABf/gJ46kCJxlqqrB2K5wKahzDA/lgNswIfpAHqzwKRBFxKRwZEg1P4YnlHcQVUvX6jWFIHW7InBJrEp8zGdRAo0mmdslxUeeotdVi0++tOjD9nsjDAxChIIfhh8NI4sljY4kjyIOH5SVJJYpmZkjD52fD54loh+epB8QqCKpMKysqh8RIrKxtTC0trgSH7u7Ir4qvsDAHxMixsUwyMnHyRQiz9Aw0R/Rz9EVI9kf29sq3t4iFh/j5CQW5eLm6iUXFyPv7STv7h/xMBgk+R/7/CIYAGFkGDgiQ0ERBpd80LBQBMMRDx/y2CCCIsURFz9kFMJBREcSHz+EtNGBREmTH04M8vDwgaVLEi9ZqggBADs=", + 72: "data:image/gif;base64,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", + 73: "data:image/gif;base64,R0lGODlhIAAgAPUgAHP/c4r/c6D/c7f/c83/c+T/c/r/c//3c//sc//ic//Xc//Nc//Cc/+3c/+rc/+fc/+Sc/+Gc/96c/tzevFzi+dznNxzrdJzvshzzr5z3bFz46Vz6Jhz7oxz9H9z+XNz/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAgACwAAAAAIAAgAAAG/0CQcEgsCgFI4xAJUDqFAVBgGoVSpU+noCjocrPKwYAoFo7FY7CRMCS43SA2W20sFEB2vPCepxsNBkOBQoB+SgdEiEOKfgiOSghDkYYJlZVGlyAJhgqdngpGoIYLC0KkpSCkRKioTwyvILAMsbOvs7F0DbpCDUW9uru9YA5KxMRGDsdPD0bMziDMRdHRRRBOENjYStpOEYZFEd5KEuSGEkTlRhMTROxZ7kLrShRF9ET2Q/ggFPxFFf7+KvwjMhDEv4IgLBCxwHChwoYLhTRUKORCEYsVL2AEoRHjRo4ghWAoMhJESSUlT448CSLDEJdKYBqBmUEmCA1DcH7LqUGnkDUNIIAC/TlUyYaiSIVwALGU6dKmYKByeCqkAwirWHdeHWIVhAevXr9qBUsWxAezaMd+WDskCAAh+QQFFAAgACwAAAAAIAAgAAAG/0CQcEgsCgFI4xAJUDqFAVBgGoVSpU+noCjocrPKwYAoFo7FY7CRMCS43SA2W20sFEB2vPCepxsNBkOBQoB+agdEiIZZCEONiwmRQglEkotCCpmZSgqXIAugoQtGo4YMDEKnqCCnRKtqDbEgsg2ztbG1s0K5Tg6+Qg5Fwb6/wSDGSg+XD8pZEE7Pz0oQ0koR1iDX2kYR10oSEk7g4+LgRhPohhNE6UYURe9E8UPzIBT3RRVG+kMV/vn9QPATYsFIwSEWCiYscnDhQRAXiFyIKGQiRYgTK0qEOARDEY8gQCoBKdKjSBAZhqRUstLIygwtQWgYMtOTTA01hWwAsXOnTjCfSjYAHSqEAwijR40iBbOUg1IhHUBEneopKlQhHkBk9ZDVZteuID6EHWvzg9khQQAAOw==", + 74: "data:image/gif;base64,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", + 75: "data:image/gif;base64,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", +}; + +/** + * Get the on-chain data URI for a beast image. + * + * @param beastId - Beast type ID (1-75) + * @param shiny - Whether to use the shiny variant + * @param animated - Whether to use the animated GIF variant (default: false for PNG) + * @returns data:image/... base64 data URI, or empty string if not found + */ +export function getBeastImageDataUri( + beastId: number, + shiny: boolean, + animated: boolean = false, +): string { + if (animated) { + return (shiny ? BEAST_GIF_SHINY[beastId] : BEAST_GIF_REGULAR[beastId]) ?? ""; + } + return (shiny ? BEAST_PNG_SHINY[beastId] : BEAST_PNG_REGULAR[beastId]) ?? ""; +} diff --git a/sdk/images.ts b/sdk/images.ts new file mode 100644 index 0000000..f509637 --- /dev/null +++ b/sdk/images.ts @@ -0,0 +1,89 @@ +/** + * Beast SDK Image URL Generation + * + * Generates local image URLs for beast NFTs based on their attributes. + * Images are stored locally in /public/images/beasts/ + */ + +import { getBeastName } from "./lookups"; + +/** + * Image asset path structure: + * /images/beasts/ + * ├── static/ + * │ ├── regular/ # {beast_name}.png (75 files) + * │ └── shiny/ # {beast_name}.png (shiny variants) + * └── animated/ + * ├── regular/ # {beast_name}.gif + * └── shiny/ # {beast_name}.gif + */ + +/** + * Convert beast name to image filename format + * Handles special cases like "Nemean Lion" -> "nemeanlion" + */ +function toImageFilename(beastName: string): string { + return beastName.toLowerCase().replace(/\s+/g, ""); +} + +/** + * Generate the image URL for a beast based on its attributes + * + * @param beastId - Beast type ID (1-75) + * @param shiny - Whether the beast is shiny + * @param animated - Whether to use animated GIF + * @returns Local image URL path + */ +export function getBeastImageUrl( + beastId: number, + shiny: boolean, + animated: boolean +): string { + const beastName = getBeastName(beastId); + const filename = toImageFilename(beastName); + const variant = shiny ? "shiny" : "regular"; + const category = animated ? "animated" : "static"; + const ext = animated ? "gif" : "png"; + + return `/images/beasts/${category}/${variant}/${filename}.${ext}`; +} + +/** + * Generate both regular and small image URLs for a beast + * (Currently returns the same URL as we don't have separate small images) + * + * @param beastId - Beast type ID (1-75) + * @param shiny - Whether the beast is shiny + * @param animated - Whether to use animated GIF + * @returns Object with imageUrl and imageSmallUrl + */ +export function getBeastImageUrls( + beastId: number, + shiny: boolean, + animated: boolean +): { imageUrl: string; imageSmallUrl: string } { + const url = getBeastImageUrl(beastId, shiny, animated); + return { + imageUrl: url, + imageSmallUrl: url, // Same URL for now - could add resized versions later + }; +} + +/** + * Get a static (non-animated) image URL for a beast + * Useful for thumbnails or performance-sensitive contexts + * + * @param beastId - Beast type ID (1-75) + * @param shiny - Whether the beast is shiny + * @returns Static PNG image URL + */ +export function getBeastStaticImageUrl(beastId: number, shiny: boolean): string { + return getBeastImageUrl(beastId, shiny, false); +} + +/** + * Check if an image URL is a local beast image + */ +export function isLocalBeastImage(url: string): boolean { + return url.startsWith("/images/beasts/"); +} diff --git a/sdk/index.ts b/sdk/index.ts new file mode 100644 index 0000000..ea33d48 --- /dev/null +++ b/sdk/index.ts @@ -0,0 +1,185 @@ +/** + * Beast SDK + * + * TypeScript SDK for Beast NFT data lookups and local image rendering. + * Provides static lookup tables and utility functions for working with + * Loot Survivor Beast NFTs. + */ + +// Re-export types +export type { + BeastApiResponse, + SummitBeastRow, + SummitBeastListResponse, + BeastOnchain, + BeastRenderData, + BeastFetchResult, + BeastDataSource, + BeastCombatType, + BeastTier, + BeastId, + BeastInput, + ValidationResult, + BeastMetadataAttribute, + BeastMetadataJson, + BeastMetadataAttributesParsed, + MetadataValidationIssue, + MetadataValidationResult, + ParsedTokenUri, + TokenUriParseResult, +} from "./types"; + +// Re-export lookup tables and functions +export { + BEAST_NAMES, + BEAST_TIERS, + BEAST_TYPES, + ITEM_NAME_PREFIXES, + ITEM_NAME_SUFFIXES, + BEAST_NAME_IDS, + ITEM_NAME_PREFIX_IDS, + ITEM_NAME_SUFFIX_IDS, + getBeastName, + getBeastTier, + getBeastType, + getBeastIdByName, + getPrefix, + getPrefixIdByName, + getSuffix, + getSuffixIdByName, +} from "./lookups"; + +// Re-export image functions +export { + getBeastImageUrl, + getBeastImageUrls, + getBeastStaticImageUrl, + isLocalBeastImage, +} from "./images"; + +// Re-export on-chain image data URIs +export { getBeastImageDataUri } from "./image-data"; + +// Re-export SVG functions +export { generateBeastSvg, generateBeastSvgFromNFT } from "./svg"; +export type { BeastSvgInput } from "./svg"; + +// Re-export utility functions +export { calculatePower, calculatePowerClamped, isHigherRank } from "./utils"; + +// Data client +export { + createBeastSdk, + normalizeStarknetAddress, + resolveBeastRenderData, + resolveBeastRenderDataList, + toBeastSvgInput, +} from "./client"; +export type { + BeastSdkConfig, + BeastSdkClient, + GetAccountBeastsOptions, + GetAccountTokenIdsOptions, + GetBeastsByTokenIdsOptions, +} from "./client"; + +// Validation helpers +export { + GENESIS_DEFAULTS, + validateBeastId, + validateBeastAttributes, + validateBeastInput, + createGenesisBeast, +} from "./validation"; + +// Metadata helpers +export { + decodeTokenUriJson, + buildTokenUriFromJsonString, + buildTokenUri, + parseTokenUri, + decodeSvgDataUri, + encodeSvgDataUri, + getAttributeMap, + validateMetadataJson, + parseMetadataAttributes, + parseTokenUriDetailed, + parseTokenUriSafe, +} from "./metadata"; + +// Import for local use +import { getBeastName, getBeastTier, getBeastType } from "./lookups"; + +/** + * Compose the full display name for a beast + * Format: "Prefix Suffix" BeastName (e.g., "Apocalypse Bane" Dragon) + * + * @param beastId - Beast type ID (1-75) + * @param prefix - Prefix name (already resolved, e.g., "Apocalypse") + * @param suffix - Suffix name (already resolved, e.g., "Bane") + * @returns Full display name + */ +export function getFullBeastName( + beastId: number, + prefix: string | null, + suffix: string | null +): string { + const beastName = getBeastName(beastId); + + if (prefix && suffix) { + return `"${prefix} ${suffix}" ${beastName}`; + } + if (prefix) { + return `"${prefix}" ${beastName}`; + } + if (suffix) { + return `"${suffix}" ${beastName}`; + } + + return beastName; +} + +/** + * Check if a token is a genesis beast (first 75 minted) + * Genesis beasts have token IDs 1-75 + */ +export function isGenesisBeast(tokenId: number | string): boolean { + const id = typeof tokenId === "string" ? parseInt(tokenId, 10) : tokenId; + return id >= 1 && id <= 75; +} + +/** + * Get the display color for a beast tier + * T1 = Orange (rarest), T5 = White (common) + */ +export function getTierColor(tier: number): string { + const colors: Record = { + 1: "#ff8800", // Orange - T1 (strongest) + 2: "#8c00bf", // Purple - T2 + 3: "#0066ff", // Blue - T3 + 4: "#00cc00", // Green - T4 + 5: "#cccccc", // Gray - T5 (weakest) + }; + return colors[tier] ?? "#cccccc"; +} + +// calculatePower is re-exported from ./utils above + +/** + * Get complete beast info from a beast ID + * Useful for enriching minimal beast data + */ +export function getBeastInfo(beastId: number): { + name: string; + tier: number; + type: string; + tierColor: string; +} { + const tier = getBeastTier(beastId); + return { + name: getBeastName(beastId), + tier, + type: getBeastType(beastId), + tierColor: getTierColor(tier), + }; +} diff --git a/sdk/lookups.ts b/sdk/lookups.ts new file mode 100644 index 0000000..a43f24a --- /dev/null +++ b/sdk/lookups.ts @@ -0,0 +1,317 @@ +/** + * Beast SDK Lookup Tables + * + * Static lookup tables for beast names, tiers, types, prefixes, and suffixes. + * Based on Loot Survivor beast data. + */ + +/** + * 75 Beast Names by ID (1-75) + * Order: Magic (1-25), Hunter (26-50), Brute (51-75) + * Within each type: T1 (1-5), T2 (6-10), T3 (11-15), T4 (16-20), T5 (21-25) + */ +export const BEAST_NAMES: Record = { + // Magic Beasts (1-25) + // T1 Magic + 1: "Warlock", + 2: "Typhon", + 3: "Jiangshi", + 4: "Anansi", + 5: "Basilisk", + // T2 Magic + 6: "Gorgon", + 7: "Kitsune", + 8: "Lich", + 9: "Chimera", + 10: "Wendigo", + // T3 Magic + 11: "Rakshasa", + 12: "Werewolf", + 13: "Banshee", + 14: "Draugr", + 15: "Vampire", + // T4 Magic + 16: "Goblin", + 17: "Ghoul", + 18: "Wraith", + 19: "Sprite", + 20: "Kappa", + // T5 Magic + 21: "Fairy", + 22: "Leprechaun", + 23: "Kelpie", + 24: "Pixie", + 25: "Gnome", + + // Hunter Beasts (26-50) + // T1 Hunter + 26: "Griffin", + 27: "Manticore", + 28: "Phoenix", + 29: "Dragon", + 30: "Minotaur", + // T2 Hunter + 31: "Qilin", + 32: "Ammit", + 33: "Nue", + 34: "Skinwalker", + 35: "Chupacabra", + // T3 Hunter + 36: "Weretiger", + 37: "Wyvern", + 38: "Roc", + 39: "Harpy", + 40: "Pegasus", + // T4 Hunter + 41: "Hippogriff", + 42: "Fenrir", + 43: "Jaguar", + 44: "Satori", + 45: "Direwolf", + // T5 Hunter + 46: "Bear", + 47: "Wolf", + 48: "Mantis", + 49: "Spider", + 50: "Rat", + + // Brute Beasts (51-75) + // T1 Brute + 51: "Kraken", + 52: "Colossus", + 53: "Balrog", + 54: "Leviathan", + 55: "Tarrasque", + // T2 Brute + 56: "Titan", + 57: "Nephilim", + 58: "Behemoth", + 59: "Hydra", + 60: "Juggernaut", + // T3 Brute + 61: "Oni", + 62: "Jotunn", + 63: "Ettin", + 64: "Cyclops", + 65: "Giant", + // T4 Brute + 66: "Nemean Lion", + 67: "Berserker", + 68: "Yeti", + 69: "Golem", + 70: "Ent", + // T5 Brute + 71: "Troll", + 72: "Bigfoot", + 73: "Ogre", + 74: "Orc", + 75: "Skeleton", +}; + +/** + * Beast tiers by ID (1-5, where 1 is strongest) + */ +export const BEAST_TIERS: Record = {}; + +// Generate tiers programmatically +// Pattern: Within each type (25 beasts), IDs 1-5 = T1, 6-10 = T2, etc. +for (let id = 1; id <= 75; id++) { + const positionInType = ((id - 1) % 25) + 1; // 1-25 within each type + const tier = Math.ceil(positionInType / 5); // 1-5 based on position + BEAST_TIERS[id] = tier; +} + +/** + * Beast combat types by ID + * IDs 1-25: Magic, 26-50: Hunter, 51-75: Brute + */ +export const BEAST_TYPES: Record = {}; + +for (let id = 1; id <= 25; id++) { + BEAST_TYPES[id] = "Magic"; +} +for (let id = 26; id <= 50; id++) { + BEAST_TYPES[id] = "Hunter"; +} +for (let id = 51; id <= 75; id++) { + BEAST_TYPES[id] = "Brute"; +} + +/** + * 69 Item Name Prefixes by ID (1-69) + * Used in beast names like "Apocalypse Bane Dragon" + */ +export const ITEM_NAME_PREFIXES: Record = { + 1: "Agony", + 2: "Apocalypse", + 3: "Armageddon", + 4: "Beast", + 5: "Behemoth", + 6: "Blight", + 7: "Blood", + 8: "Bramble", + 9: "Brimstone", + 10: "Brood", + 11: "Carrion", + 12: "Cataclysm", + 13: "Chimeric", + 14: "Corpse", + 15: "Corruption", + 16: "Damnation", + 17: "Death", + 18: "Demon", + 19: "Dire", + 20: "Dragon", + 21: "Dread", + 22: "Doom", + 23: "Dusk", + 24: "Eagle", + 25: "Empyrean", + 26: "Fate", + 27: "Foe", + 28: "Gale", + 29: "Ghoul", + 30: "Gloom", + 31: "Glyph", + 32: "Golem", + 33: "Grim", + 34: "Hate", + 35: "Havoc", + 36: "Honour", + 37: "Horror", + 38: "Hypnotic", + 39: "Kraken", + 40: "Loath", + 41: "Maelstrom", + 42: "Mind", + 43: "Miracle", + 44: "Morbid", + 45: "Oblivion", + 46: "Onslaught", + 47: "Pain", + 48: "Pandemonium", + 49: "Phoenix", + 50: "Plague", + 51: "Rage", + 52: "Rapture", + 53: "Rune", + 54: "Skull", + 55: "Sol", + 56: "Soul", + 57: "Sorrow", + 58: "Spirit", + 59: "Storm", + 60: "Tempest", + 61: "Torment", + 62: "Vengeance", + 63: "Victory", + 64: "Viper", + 65: "Vortex", + 66: "Woe", + 67: "Wrath", + 68: "Lights", + 69: "Shimmering", +}; + +/** + * 18 Item Name Suffixes by ID (1-18) + * Used in beast names like "Apocalypse Bane Dragon" + */ +export const ITEM_NAME_SUFFIXES: Record = { + 1: "Bane", + 2: "Root", + 3: "Bite", + 4: "Song", + 5: "Roar", + 6: "Grasp", + 7: "Instrument", + 8: "Glow", + 9: "Bender", + 10: "Shadow", + 11: "Whisper", + 12: "Shout", + 13: "Growl", + 14: "Tear", + 15: "Peak", + 16: "Form", + 17: "Sun", + 18: "Moon", +}; + +/** + * Reverse lookup maps for name -> ID. + */ +export const BEAST_NAME_IDS = new Map(); +export const ITEM_NAME_PREFIX_IDS = new Map(); +export const ITEM_NAME_SUFFIX_IDS = new Map(); + +for (const [id, name] of Object.entries(BEAST_NAMES)) { + BEAST_NAME_IDS.set(name.toLowerCase(), Number(id)); +} + +for (const [id, name] of Object.entries(ITEM_NAME_PREFIXES)) { + ITEM_NAME_PREFIX_IDS.set(name.toLowerCase(), Number(id)); +} + +for (const [id, name] of Object.entries(ITEM_NAME_SUFFIXES)) { + ITEM_NAME_SUFFIX_IDS.set(name.toLowerCase(), Number(id)); +} + +/** + * Look up a beast name by ID + */ +export function getBeastName(beastId: number): string { + return BEAST_NAMES[beastId] ?? "Unknown"; +} + +/** + * Look up a beast tier by ID + */ +export function getBeastTier(beastId: number): number { + return BEAST_TIERS[beastId] ?? 5; +} + +/** + * Look up a beast combat type by ID + */ +export function getBeastType(beastId: number): string { + return BEAST_TYPES[beastId] ?? "Unknown"; +} + +/** + * Look up a prefix name by ID + */ +export function getPrefix(prefixId: number): string { + return ITEM_NAME_PREFIXES[prefixId] ?? ""; +} + +/** + * Look up a suffix name by ID + */ +export function getSuffix(suffixId: number): string { + return ITEM_NAME_SUFFIXES[suffixId] ?? ""; +} + +/** + * Reverse lookup a beast ID by name (case-insensitive). + */ +export function getBeastIdByName(name: string | null): number | null { + if (!name) return null; + return BEAST_NAME_IDS.get(name.trim().toLowerCase()) ?? null; +} + +/** + * Reverse lookup a prefix ID by name (case-insensitive). + */ +export function getPrefixIdByName(prefix: string | null): number | null { + if (!prefix) return null; + return ITEM_NAME_PREFIX_IDS.get(prefix.trim().toLowerCase()) ?? null; +} + +/** + * Reverse lookup a suffix ID by name (case-insensitive). + */ +export function getSuffixIdByName(suffix: string | null): number | null { + if (!suffix) return null; + return ITEM_NAME_SUFFIX_IDS.get(suffix.trim().toLowerCase()) ?? null; +} diff --git a/sdk/metadata.ts b/sdk/metadata.ts new file mode 100644 index 0000000..4f4545e --- /dev/null +++ b/sdk/metadata.ts @@ -0,0 +1,259 @@ +/** + * Beast SDK Metadata Helpers + * + * Utilities for decoding and parsing on-chain token URIs. + */ + +import type { + BeastMetadataJson, + BeastMetadataAttributesParsed, + BeastMetadataAttribute, + MetadataValidationResult, + MetadataValidationIssue, + ParsedTokenUri, + TokenUriParseResult, +} from "./types"; + +const JSON_DATA_URI_PREFIX = "data:application/json;base64,"; +const SVG_DATA_URI_PREFIX = "data:image/svg+xml;base64,"; + +function decodeBase64(data: string): string { + const globalAny = globalThis as unknown as { + Buffer?: { + from: (input: string, encoding: string) => { toString: (enc: string) => string }; + }; + atob?: (input: string) => string; + TextDecoder?: new (label?: string) => { decode: (input: Uint8Array) => string }; + }; + + if (globalAny.Buffer) { + return globalAny.Buffer.from(data, "base64").toString("utf8"); + } + + if (globalAny.atob) { + const binary = globalAny.atob(data); + if (globalAny.TextDecoder) { + const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0)); + return new globalAny.TextDecoder("utf-8").decode(bytes); + } + return binary; + } + + throw new Error("No base64 decoder available in this environment"); +} + +function encodeBase64(data: string): string { + const globalAny = globalThis as unknown as { + Buffer?: { + from: (input: string, encoding: string) => { + toString: (enc: string) => string; + }; + }; + btoa?: (input: string) => string; + TextEncoder?: new () => { encode: (input: string) => Uint8Array }; + }; + + if (globalAny.Buffer) { + return globalAny.Buffer.from(data, "utf8").toString("base64"); + } + + if (globalAny.btoa) { + if (globalAny.TextEncoder) { + const bytes = new globalAny.TextEncoder().encode(data); + let binary = ""; + for (const byte of bytes) { + binary += String.fromCharCode(byte); + } + return globalAny.btoa(binary); + } + return globalAny.btoa(data); + } + + throw new Error("No base64 encoder available in this environment"); +} + +function sanitizeJsonString(raw: string): string { + return raw.replace(/[\x00-\x1f\x7f]/g, (c) => { + if (c === "\n") return "\\n"; + if (c === "\r") return "\\r"; + if (c === "\t") return "\\t"; + return ""; + }); +} + +/** Decode a data:application/json;base64 token URI to JSON text. */ +export function decodeTokenUriJson(tokenUri: string): string { + if (tokenUri.startsWith(JSON_DATA_URI_PREFIX)) { + const base64 = tokenUri.slice(JSON_DATA_URI_PREFIX.length); + return decodeBase64(base64); + } + + return tokenUri; +} + +/** Build a token URI from a JSON string. */ +export function buildTokenUriFromJsonString(json: string): string { + return `${JSON_DATA_URI_PREFIX}${encodeBase64(json)}`; +} + +/** Build a token URI from a JSON object. */ +export function buildTokenUri(metadata: BeastMetadataJson): string { + return buildTokenUriFromJsonString(JSON.stringify(metadata)); +} + +/** Parse a token URI into its JSON metadata object. */ +export function parseTokenUri(tokenUri: string): BeastMetadataJson { + const raw = decodeTokenUriJson(tokenUri); + const sanitized = sanitizeJsonString(raw); + return JSON.parse(sanitized) as BeastMetadataJson; +} + +/** Extract the SVG string from a data:image/svg+xml;base64 URI. */ +export function decodeSvgDataUri(imageDataUri: string): string { + if (!imageDataUri.startsWith(SVG_DATA_URI_PREFIX)) { + return imageDataUri; + } + const base64 = imageDataUri.slice(SVG_DATA_URI_PREFIX.length); + return decodeBase64(base64); +} + +/** Build a data:image/svg+xml;base64 URI from SVG markup. */ +export function encodeSvgDataUri(svg: string): string { + return `${SVG_DATA_URI_PREFIX}${encodeBase64(svg)}`; +} + +/** Build a trait_type -> value map from metadata attributes. */ +export function getAttributeMap( + attributes: BeastMetadataAttribute[] +): Record { + const map: Record = {}; + for (const attr of attributes) { + map[attr.trait_type] = String(attr.value ?? ""); + } + return map; +} + +/** Validate a metadata JSON object shape. */ +export function validateMetadataJson( + metadata: unknown +): MetadataValidationResult { + const issues: MetadataValidationIssue[] = []; + const isObject = (value: unknown): value is Record => + !!value && typeof value === "object"; + + if (!isObject(metadata)) { + return { + ok: false, + issues: [{ path: "", message: "Metadata must be an object" }], + }; + } + + if (typeof metadata.name !== "string") { + issues.push({ path: "name", message: "name must be a string" }); + } + if (typeof metadata.description !== "string") { + issues.push({ path: "description", message: "description must be a string" }); + } + if (typeof metadata.image !== "string") { + issues.push({ path: "image", message: "image must be a string" }); + } + if (!Array.isArray(metadata.attributes)) { + issues.push({ path: "attributes", message: "attributes must be an array" }); + } else { + metadata.attributes.forEach((attr: unknown, idx: number) => { + if (!isObject(attr)) { + issues.push({ + path: `attributes[${idx}]`, + message: "attribute must be an object", + }); + return; + } + if (typeof attr.trait_type !== "string") { + issues.push({ + path: `attributes[${idx}].trait_type`, + message: "trait_type must be a string", + }); + } + if (typeof attr.value !== "string") { + issues.push({ + path: `attributes[${idx}].value`, + message: "value must be a string", + }); + } + }); + } + + return { ok: issues.length === 0, issues }; +} + +/** Parse on-chain metadata attributes into a typed structure. */ +export function parseMetadataAttributes( + metadata: BeastMetadataJson +): BeastMetadataAttributesParsed { + const map = getAttributeMap(metadata.attributes ?? []); + const num = (key: string): number | null => { + if (!(key in map)) return null; + const value = Number(map[key]); + return Number.isFinite(value) ? value : null; + }; + + return { + tokenId: num("Token ID"), + beastId: num("Beast ID"), + beast: map["Beast"] ?? null, + type: map["Type"] ?? null, + tier: num("Tier"), + prefix: map["Prefix"] ?? null, + suffix: map["Suffix"] ?? null, + level: num("Level"), + health: num("Health"), + power: num("Power"), + rank: num("Rank"), + adventurersKilled: num("Adventurers Killed"), + lastKilledBy: num("Last Killed By"), + lastDeathTimestamp: num("Last Death Timestamp"), + shiny: num("Shiny"), + animated: num("Animated"), + genesis: num("Genesis"), + }; +} + +/** Parse a token URI and return a richer typed view of the metadata. */ +export function parseTokenUriDetailed( + tokenUri: string, + options?: { decodeSvg?: boolean } +): ParsedTokenUri { + const metadata = parseTokenUri(tokenUri); + const attributeMap = getAttributeMap(metadata.attributes ?? []); + const attributes = parseMetadataAttributes(metadata); + const imageSvg = options?.decodeSvg ? decodeSvgDataUri(metadata.image) : undefined; + + return { metadata, attributeMap, attributes, imageSvg }; +} + +/** Safe parse with optional validation and SVG decode. */ +export function parseTokenUriSafe( + tokenUri: string, + options?: { decodeSvg?: boolean; validate?: boolean } +): TokenUriParseResult { + try { + const metadata = parseTokenUri(tokenUri); + + if (options?.validate) { + const validation = validateMetadataJson(metadata); + if (!validation.ok) { + return { + ok: false, + error: "Invalid metadata JSON", + issues: validation.issues, + }; + } + } + + const value = parseTokenUriDetailed(tokenUri, { decodeSvg: options?.decodeSvg }); + return { ok: true, value }; + } catch (err) { + const message = err instanceof Error ? err.message : String(err); + return { ok: false, error: message }; + } +} diff --git a/sdk/package-lock.json b/sdk/package-lock.json new file mode 100644 index 0000000..94ef6da --- /dev/null +++ b/sdk/package-lock.json @@ -0,0 +1,1644 @@ +{ + "name": "@lootsurvivor/beast-sdk", + "version": "0.1.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "@lootsurvivor/beast-sdk", + "version": "0.1.0", + "devDependencies": { + "tsx": "^4.0.0", + "typescript": "^5.6.0", + "vitest": "^3.0.0" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.3.tgz", + "integrity": "sha512-9fJMTNFTWZMh5qwrBItuziu834eOCUcEqymSH7pY+zoMVEZg3gcPuBNxH1EvfVYe9h0x/Ptw8KBzv7qxb7l8dg==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.3.tgz", + "integrity": "sha512-i5D1hPY7GIQmXlXhs2w8AWHhenb00+GxjxRncS2ZM7YNVGNfaMxgzSGuO8o8SJzRc/oZwU2bcScvVERk03QhzA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.3.tgz", + "integrity": "sha512-YdghPYUmj/FX2SYKJ0OZxf+iaKgMsKHVPF1MAq/P8WirnSpCStzKJFjOjzsW0QQ7oIAiccHdcqjbHmJxRb/dmg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.3.tgz", + "integrity": "sha512-IN/0BNTkHtk8lkOM8JWAYFg4ORxBkZQf9zXiEOfERX/CzxW3Vg1ewAhU7QSWQpVIzTW+b8Xy+lGzdYXV6UZObQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.3.tgz", + "integrity": "sha512-Re491k7ByTVRy0t3EKWajdLIr0gz2kKKfzafkth4Q8A5n1xTHrkqZgLLjFEHVD+AXdUGgQMq+Godfq45mGpCKg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.3.tgz", + "integrity": "sha512-vHk/hA7/1AckjGzRqi6wbo+jaShzRowYip6rt6q7VYEDX4LEy1pZfDpdxCBnGtl+A5zq8iXDcyuxwtv3hNtHFg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.3.tgz", + "integrity": "sha512-ipTYM2fjt3kQAYOvo6vcxJx3nBYAzPjgTCk7QEgZG8AUO3ydUhvelmhrbOheMnGOlaSFUoHXB6un+A7q4ygY9w==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.3.tgz", + "integrity": "sha512-dDk0X87T7mI6U3K9VjWtHOXqwAMJBNN2r7bejDsc+j03SEjtD9HrOl8gVFByeM0aJksoUuUVU9TBaZa2rgj0oA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.3.tgz", + "integrity": "sha512-s6nPv2QkSupJwLYyfS+gwdirm0ukyTFNl3KTgZEAiJDd+iHZcbTPPcWCcRYH+WlNbwChgH2QkE9NSlNrMT8Gfw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.3.tgz", + "integrity": "sha512-sZOuFz/xWnZ4KH3YfFrKCf1WyPZHakVzTiqji3WDc0BCl2kBwiJLCXpzLzUBLgmp4veFZdvN5ChW4Eq/8Fc2Fg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.3.tgz", + "integrity": "sha512-yGlQYjdxtLdh0a3jHjuwOrxQjOZYD/C9PfdbgJJF3TIZWnm/tMd/RcNiLngiu4iwcBAOezdnSLAwQDPqTmtTYg==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.3.tgz", + "integrity": "sha512-WO60Sn8ly3gtzhyjATDgieJNet/KqsDlX5nRC5Y3oTFcS1l0KWba+SEa9Ja1GfDqSF1z6hif/SkpQJbL63cgOA==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.3.tgz", + "integrity": "sha512-APsymYA6sGcZ4pD6k+UxbDjOFSvPWyZhjaiPyl/f79xKxwTnrn5QUnXR5prvetuaSMsb4jgeHewIDCIWljrSxw==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.3.tgz", + "integrity": "sha512-eizBnTeBefojtDb9nSh4vvVQ3V9Qf9Df01PfawPcRzJH4gFSgrObw+LveUyDoKU3kxi5+9RJTCWlj4FjYXVPEA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.3.tgz", + "integrity": "sha512-3Emwh0r5wmfm3ssTWRQSyVhbOHvqegUDRd0WhmXKX2mkHJe1SFCMJhagUleMq+Uci34wLSipf8Lagt4LlpRFWQ==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.3.tgz", + "integrity": "sha512-pBHUx9LzXWBc7MFIEEL0yD/ZVtNgLytvx60gES28GcWMqil8ElCYR4kvbV2BDqsHOvVDRrOxGySBM9Fcv744hw==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.3.tgz", + "integrity": "sha512-Czi8yzXUWIQYAtL/2y6vogER8pvcsOsk5cpwL4Gk5nJqH5UZiVByIY8Eorm5R13gq+DQKYg0+JyQoytLQas4dA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.3.tgz", + "integrity": "sha512-sDpk0RgmTCR/5HguIZa9n9u+HVKf40fbEUt+iTzSnCaGvY9kFP0YKBWZtJaraonFnqef5SlJ8/TiPAxzyS+UoA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.3.tgz", + "integrity": "sha512-P14lFKJl/DdaE00LItAukUdZO5iqNH7+PjoBm+fLQjtxfcfFE20Xf5CrLsmZdq5LFFZzb5JMZ9grUwvtVYzjiA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.3.tgz", + "integrity": "sha512-AIcMP77AvirGbRl/UZFTq5hjXK+2wC7qFRGoHSDrZ5v5b8DK/GYpXW3CPRL53NkvDqb9D+alBiC/dV0Fb7eJcw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.3.tgz", + "integrity": "sha512-DnW2sRrBzA+YnE70LKqnM3P+z8vehfJWHXECbwBmH/CU51z6FiqTQTHFenPlHmo3a8UgpLyH3PT+87OViOh1AQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openharmony-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.3.tgz", + "integrity": "sha512-NinAEgr/etERPTsZJ7aEZQvvg/A6IsZG/LgZy+81wON2huV7SrK3e63dU0XhyZP4RKGyTm7aOgmQk0bGp0fy2g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.3.tgz", + "integrity": "sha512-PanZ+nEz+eWoBJ8/f8HKxTTD172SKwdXebZ0ndd953gt1HRBbhMsaNqjTyYLGLPdoWHy4zLU7bDVJztF5f3BHA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.3.tgz", + "integrity": "sha512-B2t59lWWYrbRDw/tjiWOuzSsFh1Y/E95ofKz7rIVYSQkUYBjfSgf6oeYPNWHToFRr2zx52JKApIcAS/D5TUBnA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.3.tgz", + "integrity": "sha512-QLKSFeXNS8+tHW7tZpMtjlNb7HKau0QDpwm49u0vUp9y1WOF+PEzkU84y9GqYaAVW8aH8f3GcBck26jh54cX4Q==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.3.tgz", + "integrity": "sha512-4uJGhsxuptu3OcpVAzli+/gWusVGwZZHTlS63hh++ehExkVT8SgiEf7/uC/PclrPPkLhZqGgCTjd0VWLo6xMqA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + "dev": true, + "license": "MIT" + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.57.1.tgz", + "integrity": "sha512-A6ehUVSiSaaliTxai040ZpZ2zTevHYbvu/lDoeAteHI8QnaosIzm4qwtezfRg1jOYaUmnzLX1AOD6Z+UJjtifg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.57.1.tgz", + "integrity": "sha512-dQaAddCY9YgkFHZcFNS/606Exo8vcLHwArFZ7vxXq4rigo2bb494/xKMMwRRQW6ug7Js6yXmBZhSBRuBvCCQ3w==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.57.1.tgz", + "integrity": "sha512-crNPrwJOrRxagUYeMn/DZwqN88SDmwaJ8Cvi/TN1HnWBU7GwknckyosC2gd0IqYRsHDEnXf328o9/HC6OkPgOg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.57.1.tgz", + "integrity": "sha512-Ji8g8ChVbKrhFtig5QBV7iMaJrGtpHelkB3lsaKzadFBe58gmjfGXAOfI5FV0lYMH8wiqsxKQ1C9B0YTRXVy4w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.57.1.tgz", + "integrity": "sha512-R+/WwhsjmwodAcz65guCGFRkMb4gKWTcIeLy60JJQbXrJ97BOXHxnkPFrP+YwFlaS0m+uWJTstrUA9o+UchFug==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.57.1.tgz", + "integrity": "sha512-IEQTCHeiTOnAUC3IDQdzRAGj3jOAYNr9kBguI7MQAAZK3caezRrg0GxAb6Hchg4lxdZEI5Oq3iov/w/hnFWY9Q==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.57.1.tgz", + "integrity": "sha512-F8sWbhZ7tyuEfsmOxwc2giKDQzN3+kuBLPwwZGyVkLlKGdV1nvnNwYD0fKQ8+XS6hp9nY7B+ZeK01EBUE7aHaw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.57.1.tgz", + "integrity": "sha512-rGfNUfn0GIeXtBP1wL5MnzSj98+PZe/AXaGBCRmT0ts80lU5CATYGxXukeTX39XBKsxzFpEeK+Mrp9faXOlmrw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.57.1.tgz", + "integrity": "sha512-MMtej3YHWeg/0klK2Qodf3yrNzz6CGjo2UntLvk2RSPlhzgLvYEB3frRvbEF2wRKh1Z2fDIg9KRPe1fawv7C+g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.57.1.tgz", + "integrity": "sha512-1a/qhaaOXhqXGpMFMET9VqwZakkljWHLmZOX48R0I/YLbhdxr1m4gtG1Hq7++VhVUmf+L3sTAf9op4JlhQ5u1Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-gnu": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.57.1.tgz", + "integrity": "sha512-QWO6RQTZ/cqYtJMtxhkRkidoNGXc7ERPbZN7dVW5SdURuLeVU7lwKMpo18XdcmpWYd0qsP1bwKPf7DNSUinhvA==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-musl": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.57.1.tgz", + "integrity": "sha512-xpObYIf+8gprgWaPP32xiN5RVTi/s5FCR+XMXSKmhfoJjrpRAjCuuqQXyxUa/eJTdAE6eJ+KDKaoEqjZQxh3Gw==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-gnu": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.57.1.tgz", + "integrity": "sha512-4BrCgrpZo4hvzMDKRqEaW1zeecScDCR+2nZ86ATLhAoJ5FQ+lbHVD3ttKe74/c7tNT9c6F2viwB3ufwp01Oh2w==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-musl": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.57.1.tgz", + "integrity": "sha512-NOlUuzesGauESAyEYFSe3QTUguL+lvrN1HtwEEsU2rOwdUDeTMJdO5dUYl/2hKf9jWydJrO9OL/XSSf65R5+Xw==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.57.1.tgz", + "integrity": "sha512-ptA88htVp0AwUUqhVghwDIKlvJMD/fmL/wrQj99PRHFRAG6Z5nbWoWG4o81Nt9FT+IuqUQi+L31ZKAFeJ5Is+A==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.57.1.tgz", + "integrity": "sha512-S51t7aMMTNdmAMPpBg7OOsTdn4tySRQvklmL3RpDRyknk87+Sp3xaumlatU+ppQ+5raY7sSTcC2beGgvhENfuw==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.57.1.tgz", + "integrity": "sha512-Bl00OFnVFkL82FHbEqy3k5CUCKH6OEJL54KCyx2oqsmZnFTR8IoNqBF+mjQVcRCT5sB6yOvK8A37LNm/kPJiZg==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.57.1.tgz", + "integrity": "sha512-ABca4ceT4N+Tv/GtotnWAeXZUZuM/9AQyCyKYyKnpk4yoA7QIAuBt6Hkgpw8kActYlew2mvckXkvx0FfoInnLg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.57.1.tgz", + "integrity": "sha512-HFps0JeGtuOR2convgRRkHCekD7j+gdAuXM+/i6kGzQtFhlCtQkpwtNzkNj6QhCDp7DRJ7+qC/1Vg2jt5iSOFw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-openbsd-x64": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.57.1.tgz", + "integrity": "sha512-H+hXEv9gdVQuDTgnqD+SQffoWoc0Of59AStSzTEj/feWTBAnSfSD3+Dql1ZruJQxmykT/JVY0dE8Ka7z0DH1hw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ] + }, + "node_modules/@rollup/rollup-openharmony-arm64": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.57.1.tgz", + "integrity": "sha512-4wYoDpNg6o/oPximyc/NG+mYUejZrCU2q+2w6YZqrAs2UcNUChIZXjtafAiiZSUc7On8v5NyNj34Kzj/Ltk6dQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.57.1.tgz", + "integrity": "sha512-O54mtsV/6LW3P8qdTcamQmuC990HDfR71lo44oZMZlXU4tzLrbvTii87Ni9opq60ds0YzuAlEr/GNwuNluZyMQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.57.1.tgz", + "integrity": "sha512-P3dLS+IerxCT/7D2q2FYcRdWRl22dNbrbBEtxdWhXrfIMPP9lQhb5h4Du04mdl5Woq05jVCDPCMF7Ub0NAjIew==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.57.1.tgz", + "integrity": "sha512-VMBH2eOOaKGtIJYleXsi2B8CPVADrh+TyNxJ4mWPnKfLB/DBUmzW+5m1xUrcwWoMfSLagIRpjUFeW5CO5hyciQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.57.1.tgz", + "integrity": "sha512-mxRFDdHIWRxg3UfIIAwCm6NzvxG0jDX/wBN6KsQFTvKFqqg9vTrWUE68qEjHt19A5wwx5X5aUi2zuZT7YR0jrA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@types/chai": { + "version": "5.2.3", + "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz", + "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/deep-eql": "*", + "assertion-error": "^2.0.1" + } + }, + "node_modules/@types/deep-eql": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz", + "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/estree": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz", + "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==", + "dev": true, + "license": "MIT" + }, + "node_modules/@vitest/expect": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-3.2.4.tgz", + "integrity": "sha512-Io0yyORnB6sikFlt8QW5K7slY4OjqNX9jmJQ02QDda8lyM6B5oNgVWoSoKPac8/kgnCUzuHQKrSLtu/uOqqrig==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/chai": "^5.2.2", + "@vitest/spy": "3.2.4", + "@vitest/utils": "3.2.4", + "chai": "^5.2.0", + "tinyrainbow": "^2.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/mocker": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-3.2.4.tgz", + "integrity": "sha512-46ryTE9RZO/rfDd7pEqFl7etuyzekzEhUbTW3BvmeO/BcCMEgq59BKhek3dXDWgAj4oMK6OZi+vRr1wPW6qjEQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/spy": "3.2.4", + "estree-walker": "^3.0.3", + "magic-string": "^0.30.17" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "msw": "^2.4.9", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0" + }, + "peerDependenciesMeta": { + "msw": { + "optional": true + }, + "vite": { + "optional": true + } + } + }, + "node_modules/@vitest/pretty-format": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-3.2.4.tgz", + "integrity": "sha512-IVNZik8IVRJRTr9fxlitMKeJeXFFFN0JaB9PHPGQ8NKQbGpfjlTx9zO4RefN8gp7eqjNy8nyK3NZmBzOPeIxtA==", + "dev": true, + "license": "MIT", + "dependencies": { + "tinyrainbow": "^2.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/runner": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-3.2.4.tgz", + "integrity": "sha512-oukfKT9Mk41LreEW09vt45f8wx7DordoWUZMYdY/cyAk7w5TWkTRCNZYF7sX7n2wB7jyGAl74OxgwhPgKaqDMQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/utils": "3.2.4", + "pathe": "^2.0.3", + "strip-literal": "^3.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/snapshot": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-3.2.4.tgz", + "integrity": "sha512-dEYtS7qQP2CjU27QBC5oUOxLE/v5eLkGqPE0ZKEIDGMs4vKWe7IjgLOeauHsR0D5YuuycGRO5oSRXnwnmA78fQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/pretty-format": "3.2.4", + "magic-string": "^0.30.17", + "pathe": "^2.0.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/spy": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-3.2.4.tgz", + "integrity": "sha512-vAfasCOe6AIK70iP5UD11Ac4siNUNJ9i/9PZ3NKx07sG6sUxeag1LWdNrMWeKKYBLlzuK+Gn65Yd5nyL6ds+nw==", + "dev": true, + "license": "MIT", + "dependencies": { + "tinyspy": "^4.0.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/utils": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-3.2.4.tgz", + "integrity": "sha512-fB2V0JFrQSMsCo9HiSq3Ezpdv4iYaXRG1Sx8edX3MwxfyNn83mKiGzOcH+Fkxt4MHxr3y42fQi1oeAInqgX2QA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/pretty-format": "3.2.4", + "loupe": "^3.1.4", + "tinyrainbow": "^2.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/assertion-error": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz", + "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + } + }, + "node_modules/cac": { + "version": "6.7.14", + "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz", + "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/chai": { + "version": "5.3.3", + "resolved": "https://registry.npmjs.org/chai/-/chai-5.3.3.tgz", + "integrity": "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==", + "dev": true, + "license": "MIT", + "dependencies": { + "assertion-error": "^2.0.1", + "check-error": "^2.1.1", + "deep-eql": "^5.0.1", + "loupe": "^3.1.0", + "pathval": "^2.0.0" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/check-error": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.3.tgz", + "integrity": "sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 16" + } + }, + "node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/deep-eql": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz", + "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/es-module-lexer": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz", + "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==", + "dev": true, + "license": "MIT" + }, + "node_modules/esbuild": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.3.tgz", + "integrity": "sha512-8VwMnyGCONIs6cWue2IdpHxHnAjzxnw2Zr7MkVxB2vjmQ2ivqGFb4LEG3SMnv0Gb2F/G/2yA8zUaiL1gywDCCg==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.27.3", + "@esbuild/android-arm": "0.27.3", + "@esbuild/android-arm64": "0.27.3", + "@esbuild/android-x64": "0.27.3", + "@esbuild/darwin-arm64": "0.27.3", + "@esbuild/darwin-x64": "0.27.3", + "@esbuild/freebsd-arm64": "0.27.3", + "@esbuild/freebsd-x64": "0.27.3", + "@esbuild/linux-arm": "0.27.3", + "@esbuild/linux-arm64": "0.27.3", + "@esbuild/linux-ia32": "0.27.3", + "@esbuild/linux-loong64": "0.27.3", + "@esbuild/linux-mips64el": "0.27.3", + "@esbuild/linux-ppc64": "0.27.3", + "@esbuild/linux-riscv64": "0.27.3", + "@esbuild/linux-s390x": "0.27.3", + "@esbuild/linux-x64": "0.27.3", + "@esbuild/netbsd-arm64": "0.27.3", + "@esbuild/netbsd-x64": "0.27.3", + "@esbuild/openbsd-arm64": "0.27.3", + "@esbuild/openbsd-x64": "0.27.3", + "@esbuild/openharmony-arm64": "0.27.3", + "@esbuild/sunos-x64": "0.27.3", + "@esbuild/win32-arm64": "0.27.3", + "@esbuild/win32-ia32": "0.27.3", + "@esbuild/win32-x64": "0.27.3" + } + }, + "node_modules/estree-walker": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz", + "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0" + } + }, + "node_modules/expect-type": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz", + "integrity": "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/get-tsconfig": { + "version": "4.13.6", + "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.13.6.tgz", + "integrity": "sha512-shZT/QMiSHc/YBLxxOkMtgSid5HFoauqCE3/exfsEcwg1WkeqjG+V40yBbBrsD+jW2HDXcs28xOfcbm2jI8Ddw==", + "dev": true, + "license": "MIT", + "dependencies": { + "resolve-pkg-maps": "^1.0.0" + }, + "funding": { + "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1" + } + }, + "node_modules/js-tokens": { + "version": "9.0.1", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-9.0.1.tgz", + "integrity": "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/loupe": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz", + "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/magic-string": { + "version": "0.30.21", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz", + "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.5" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/nanoid": { + "version": "3.3.11", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz", + "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/pathe": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz", + "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==", + "dev": true, + "license": "MIT" + }, + "node_modules/pathval": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz", + "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 14.16" + } + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true, + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz", + "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/postcss": { + "version": "8.5.6", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz", + "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.11", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/resolve-pkg-maps": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz", + "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1" + } + }, + "node_modules/rollup": { + "version": "4.57.1", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.57.1.tgz", + "integrity": "sha512-oQL6lgK3e2QZeQ7gcgIkS2YZPg5slw37hYufJ3edKlfQSGGm8ICoxswK15ntSzF/a8+h7ekRy7k7oWc3BQ7y8A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "1.0.8" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.57.1", + "@rollup/rollup-android-arm64": "4.57.1", + "@rollup/rollup-darwin-arm64": "4.57.1", + "@rollup/rollup-darwin-x64": "4.57.1", + "@rollup/rollup-freebsd-arm64": "4.57.1", + "@rollup/rollup-freebsd-x64": "4.57.1", + "@rollup/rollup-linux-arm-gnueabihf": "4.57.1", + "@rollup/rollup-linux-arm-musleabihf": "4.57.1", + "@rollup/rollup-linux-arm64-gnu": "4.57.1", + "@rollup/rollup-linux-arm64-musl": "4.57.1", + "@rollup/rollup-linux-loong64-gnu": "4.57.1", + "@rollup/rollup-linux-loong64-musl": "4.57.1", + "@rollup/rollup-linux-ppc64-gnu": "4.57.1", + "@rollup/rollup-linux-ppc64-musl": "4.57.1", + "@rollup/rollup-linux-riscv64-gnu": "4.57.1", + "@rollup/rollup-linux-riscv64-musl": "4.57.1", + "@rollup/rollup-linux-s390x-gnu": "4.57.1", + "@rollup/rollup-linux-x64-gnu": "4.57.1", + "@rollup/rollup-linux-x64-musl": "4.57.1", + "@rollup/rollup-openbsd-x64": "4.57.1", + "@rollup/rollup-openharmony-arm64": "4.57.1", + "@rollup/rollup-win32-arm64-msvc": "4.57.1", + "@rollup/rollup-win32-ia32-msvc": "4.57.1", + "@rollup/rollup-win32-x64-gnu": "4.57.1", + "@rollup/rollup-win32-x64-msvc": "4.57.1", + "fsevents": "~2.3.2" + } + }, + "node_modules/siginfo": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz", + "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==", + "dev": true, + "license": "ISC" + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/stackback": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz", + "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==", + "dev": true, + "license": "MIT" + }, + "node_modules/std-env": { + "version": "3.10.0", + "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz", + "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==", + "dev": true, + "license": "MIT" + }, + "node_modules/strip-literal": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/strip-literal/-/strip-literal-3.1.0.tgz", + "integrity": "sha512-8r3mkIM/2+PpjHoOtiAW8Rg3jJLHaV7xPwG+YRGrv6FP0wwk/toTpATxWYOW0BKdWwl82VT2tFYi5DlROa0Mxg==", + "dev": true, + "license": "MIT", + "dependencies": { + "js-tokens": "^9.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/tinybench": { + "version": "2.9.0", + "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz", + "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==", + "dev": true, + "license": "MIT" + }, + "node_modules/tinyexec": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz", + "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==", + "dev": true, + "license": "MIT" + }, + "node_modules/tinyglobby": { + "version": "0.2.15", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz", + "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.3" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, + "node_modules/tinypool": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.1.1.tgz", + "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.0.0 || >=20.0.0" + } + }, + "node_modules/tinyrainbow": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-2.0.0.tgz", + "integrity": "sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/tinyspy": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-4.0.4.tgz", + "integrity": "sha512-azl+t0z7pw/z958Gy9svOTuzqIk6xq+NSheJzn5MMWtWTFywIacg2wUlzKFGtt3cthx0r2SxMK0yzJOR0IES7Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/tsx": { + "version": "4.21.0", + "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.21.0.tgz", + "integrity": "sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "~0.27.0", + "get-tsconfig": "^4.7.5" + }, + "bin": { + "tsx": "dist/cli.mjs" + }, + "engines": { + "node": ">=18.0.0" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + } + }, + "node_modules/typescript": { + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/vite": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.1.tgz", + "integrity": "sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "^0.27.0", + "fdir": "^6.5.0", + "picomatch": "^4.0.3", + "postcss": "^8.5.6", + "rollup": "^4.43.0", + "tinyglobby": "^0.2.15" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^20.19.0 || >=22.12.0", + "jiti": ">=1.21.0", + "less": "^4.0.0", + "lightningcss": "^1.21.0", + "sass": "^1.70.0", + "sass-embedded": "^1.70.0", + "stylus": ">=0.54.8", + "sugarss": "^5.0.0", + "terser": "^5.16.0", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "jiti": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + }, + "node_modules/vite-node": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-3.2.4.tgz", + "integrity": "sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg==", + "dev": true, + "license": "MIT", + "dependencies": { + "cac": "^6.7.14", + "debug": "^4.4.1", + "es-module-lexer": "^1.7.0", + "pathe": "^2.0.3", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0" + }, + "bin": { + "vite-node": "vite-node.mjs" + }, + "engines": { + "node": "^18.0.0 || ^20.0.0 || >=22.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/vitest": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/vitest/-/vitest-3.2.4.tgz", + "integrity": "sha512-LUCP5ev3GURDysTWiP47wRRUpLKMOfPh+yKTx3kVIEiu5KOMeqzpnYNsKyOoVrULivR8tLcks4+lga33Whn90A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/chai": "^5.2.2", + "@vitest/expect": "3.2.4", + "@vitest/mocker": "3.2.4", + "@vitest/pretty-format": "^3.2.4", + "@vitest/runner": "3.2.4", + "@vitest/snapshot": "3.2.4", + "@vitest/spy": "3.2.4", + "@vitest/utils": "3.2.4", + "chai": "^5.2.0", + "debug": "^4.4.1", + "expect-type": "^1.2.1", + "magic-string": "^0.30.17", + "pathe": "^2.0.3", + "picomatch": "^4.0.2", + "std-env": "^3.9.0", + "tinybench": "^2.9.0", + "tinyexec": "^0.3.2", + "tinyglobby": "^0.2.14", + "tinypool": "^1.1.1", + "tinyrainbow": "^2.0.0", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0", + "vite-node": "3.2.4", + "why-is-node-running": "^2.3.0" + }, + "bin": { + "vitest": "vitest.mjs" + }, + "engines": { + "node": "^18.0.0 || ^20.0.0 || >=22.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "@edge-runtime/vm": "*", + "@types/debug": "^4.1.12", + "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", + "@vitest/browser": "3.2.4", + "@vitest/ui": "3.2.4", + "happy-dom": "*", + "jsdom": "*" + }, + "peerDependenciesMeta": { + "@edge-runtime/vm": { + "optional": true + }, + "@types/debug": { + "optional": true + }, + "@types/node": { + "optional": true + }, + "@vitest/browser": { + "optional": true + }, + "@vitest/ui": { + "optional": true + }, + "happy-dom": { + "optional": true + }, + "jsdom": { + "optional": true + } + } + }, + "node_modules/why-is-node-running": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz", + "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==", + "dev": true, + "license": "MIT", + "dependencies": { + "siginfo": "^2.0.0", + "stackback": "0.0.2" + }, + "bin": { + "why-is-node-running": "cli.js" + }, + "engines": { + "node": ">=8" + } + } + } +} diff --git a/sdk/package.json b/sdk/package.json new file mode 100644 index 0000000..1c43786 --- /dev/null +++ b/sdk/package.json @@ -0,0 +1,31 @@ +{ + "name": "@lootsurvivor/beast-sdk", + "version": "0.1.0", + "description": "TypeScript SDK for Beast NFT data lookups and local SVG rendering", + "type": "module", + "main": "dist/index.js", + "types": "dist/index.d.ts", + "exports": { + ".": { + "types": "./dist/index.d.ts", + "import": "./dist/index.js" + } + }, + "files": [ + "dist" + ], + "scripts": { + "build": "tsc", + "test": "vitest run", + "test:watch": "vitest", + "extract-images": "node scripts/extract-beast-images.mjs" + }, + "publishConfig": { + "access": "public" + }, + "devDependencies": { + "tsx": "^4.0.0", + "typescript": "^5.6.0", + "vitest": "^3.0.0" + } +} diff --git a/sdk/scripts/compare-onchain-svg.mjs b/sdk/scripts/compare-onchain-svg.mjs new file mode 100644 index 0000000..95dd747 --- /dev/null +++ b/sdk/scripts/compare-onchain-svg.mjs @@ -0,0 +1,236 @@ +#!/usr/bin/env node +/** + * Compare on-chain token_uri SVGs with our SDK-generated SVGs. + * + * Calls the beast contract for 11 token IDs via sncast, decodes the + * on-chain SVG, generates the SDK SVG, and diffs them. + * + * Usage: node scripts/compare-onchain-svg.mjs + */ + +import { execSync } from "child_process"; + +const CONTRACT = "0x046da8955829adf2bda310099a0063451923f02e648cf25a1203aac6335cf0e4"; +const TOKEN_IDS = [100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110]; + +// Dynamically import the SDK (it's TypeScript, need tsx or compile) +// We'll use a simpler approach: just call sncast and decode the on-chain SVG, +// then generate SDK SVG via a small inline function. + +/** + * Call sncast and return the raw response string. + */ +function callTokenUri(tokenId) { + const cmd = `sncast call -d ${CONTRACT} -f token_uri -c ${tokenId} 0 --network mainnet 2>&1`; + const output = execSync(cmd, { encoding: "utf-8", timeout: 30000 }); + + // Extract the base64 JSON from the response line + const match = output.match(/Response:\s+"(data:application\/json;base64,[^"]+)"/); + if (!match) { + // Try alternate: the response might just be the raw string + const altMatch = output.match(/"(data:[^"]+)"/); + if (!altMatch) { + throw new Error(`Could not parse sncast output for token ${tokenId}:\n${output.slice(0, 500)}`); + } + return altMatch[1]; + } + return match[1]; +} + +/** + * Decode a data:application/json;base64,... URI to get the JSON metadata, + * then extract the SVG from the "image" field. + */ +function extractOnchainSvg(dataUri) { + // Strip prefix + const base64Json = dataUri.replace("data:application/json;base64,", ""); + // On-chain JSON has literal newlines/tabs in the description string — sanitize for JSON.parse + const raw = Buffer.from(base64Json, "base64").toString("utf-8"); + const sanitized = raw.replace(/[\x00-\x1f\x7f]/g, (c) => { + if (c === "\n") return "\\n"; + if (c === "\r") return "\\r"; + if (c === "\t") return "\\t"; + return ""; + }); + const json = JSON.parse(sanitized); + + // The image field is data:image/svg+xml;base64,... + const svgDataUri = json.image; + if (!svgDataUri) { + throw new Error("No 'image' field in token metadata"); + } + + const base64Svg = svgDataUri.replace("data:image/svg+xml;base64,", ""); + return Buffer.from(base64Svg, "base64").toString("utf-8"); +} + +/** + * Extract beast metadata from the on-chain JSON. + */ +function extractMetadata(dataUri) { + const base64Json = dataUri.replace("data:application/json;base64,", ""); + // On-chain JSON has literal newlines/tabs in the description string — sanitize for JSON.parse + const raw = Buffer.from(base64Json, "base64").toString("utf-8"); + const sanitized = raw.replace(/[\x00-\x1f\x7f]/g, (c) => { + if (c === "\n") return "\\n"; + if (c === "\r") return "\\r"; + if (c === "\t") return "\\t"; + return ""; + }); + const json = JSON.parse(sanitized); + return json; +} + +/** + * Normalize an SVG for comparison. + * The SDK now uses foreignObject matching on-chain output, so no + * transformation is needed. This function is kept as a no-op hook + * for any future normalization needs. + */ +function normalizeOnchainSvg(svg) { + return svg; +} + +async function main() { + // Dynamically load the SDK via tsx + // First, let's build the SDK SVG generator + const { generateBeastSvg } = await import("tsx/esm/api").then(tsx => { + return tsx.register(); + }).then(() => { + return import("../svg.ts"); + }).catch(() => { + return import("../svg.ts"); + }); + + const { getBeastImageDataUri } = await import("../image-data.ts").catch(() => { + return import("../image-data.ts"); + }); + + console.log("Comparing on-chain SVGs with SDK output for token IDs:", TOKEN_IDS.join(", ")); + console.log("=".repeat(70)); + + let passed = 0; + let failed = 0; + + for (const tokenId of TOKEN_IDS) { + process.stdout.write(`\nToken #${tokenId}: `); + + try { + // Fetch on-chain data + const dataUri = callTokenUri(tokenId); + const metadata = extractMetadata(dataUri); + const onchainSvg = extractOnchainSvg(dataUri); + + // Extract beast attributes from on-chain metadata + const attrs = {}; + for (const attr of metadata.attributes || []) { + attrs[attr.trait_type] = attr.value; + } + + // Build SDK input from on-chain metadata + const beastId = parseInt(attrs["Species ID"] || attrs["Beast ID"] || "1"); + const tier = parseInt(attrs["Tier"]?.replace("T", "") || "1"); + const level = parseInt(attrs["Level"] || "1"); + const health = parseInt(attrs["Health"] || "0"); + const power = parseInt(attrs["Power"] || "0"); + const shiny = attrs["Shiny"] === "Yes" || attrs["Shiny"] === "true" || attrs["Shiny"] === true || attrs["Shiny"] === "1"; + const animated = attrs["Animated"] === "1" || attrs["Animated"] === "Yes" || attrs["Animated"] === true; + const prefix = attrs["Prefix"] && attrs["Prefix"] !== "None" ? attrs["Prefix"] : null; + const suffix = attrs["Suffix"] && attrs["Suffix"] !== "None" ? attrs["Suffix"] : null; + + // Rank: look for rank attribute + let rank = null; + if (attrs["Rank"]) { + rank = parseInt(attrs["Rank"]); + if (isNaN(rank)) rank = null; + } + + // Use animated GIF image when beast is animated (matches on-chain behavior) + const imageUrl = getBeastImageDataUri(beastId, shiny, animated); + + const sdkSvg = generateBeastSvg({ + beastId, + prefix, + suffix, + tier, + level, + health, + power, + shiny, + rank, + imageUrl, + }); + + // Normalize the on-chain SVG (convert foreignObject to ) + const normalizedOnchain = normalizeOnchainSvg(onchainSvg); + + if (normalizedOnchain === sdkSvg) { + console.log(`PASS (${metadata.name})`); + passed++; + } else { + console.log(`DIFF (${metadata.name})`); + failed++; + + // Find first difference + const minLen = Math.min(normalizedOnchain.length, sdkSvg.length); + let diffPos = -1; + for (let i = 0; i < minLen; i++) { + if (normalizedOnchain[i] !== sdkSvg[i]) { + diffPos = i; + break; + } + } + if (diffPos === -1 && normalizedOnchain.length !== sdkSvg.length) { + diffPos = minLen; + } + + if (diffPos >= 0) { + const ctx = 60; + const start = Math.max(0, diffPos - ctx); + const end = Math.min(Math.max(normalizedOnchain.length, sdkSvg.length), diffPos + ctx); + console.log(` First diff at position ${diffPos} (lengths: on-chain=${normalizedOnchain.length}, sdk=${sdkSvg.length}):`); + console.log(` On-chain: ...${normalizedOnchain.slice(start, end)}...`); + console.log(` SDK: ...${sdkSvg.slice(start, end)}...`); + + // Strip font base64 from both and compare the rest + const fontMarker = "data:application/font-woff2"; + const stripFont = (s) => { + const start = s.indexOf(fontMarker); + if (start === -1) return s; + const end = s.indexOf(")", start); + return s.slice(0, start) + "FONT_STRIPPED" + s.slice(end); + }; + const onchainNoFont = stripFont(normalizedOnchain); + const sdkNoFont = stripFont(sdkSvg); + const match2 = onchainNoFont === sdkNoFont; + console.log(` Match excluding font: ${match2 ? "YES" : "NO"}`); + if (!match2) { + // Find first non-font diff + for (let i = 0; i < Math.min(onchainNoFont.length, sdkNoFont.length); i++) { + if (onchainNoFont[i] !== sdkNoFont[i]) { + const s = Math.max(0, i - 40); + const e = Math.min(Math.max(onchainNoFont.length, sdkNoFont.length), i + 40); + console.log(` Non-font diff at pos ${i}:`); + console.log(` On-chain: ...${onchainNoFont.slice(s, e)}...`); + console.log(` SDK: ...${sdkNoFont.slice(s, e)}...`); + break; + } + } + if (onchainNoFont.length !== sdkNoFont.length) { + console.log(` Length diff (no font): on-chain=${onchainNoFont.length}, sdk=${sdkNoFont.length}`); + } + } + } + } + } catch (err) { + console.log(`ERROR: ${err.message}`); + failed++; + } + } + + console.log("\n" + "=".repeat(70)); + console.log(`Results: ${passed} passed, ${failed} failed out of ${TOKEN_IDS.length}`); + process.exit(failed > 0 ? 1 : 0); +} + +main(); diff --git a/sdk/scripts/extract-beast-images.mjs b/sdk/scripts/extract-beast-images.mjs new file mode 100644 index 0000000..7ea3f47 --- /dev/null +++ b/sdk/scripts/extract-beast-images.mjs @@ -0,0 +1,167 @@ +#!/usr/bin/env node +/** + * Extract beast image data URIs from Cairo source files. + * + * Parses the 4 Cairo data files (png regular/shiny, gif regular/shiny), + * maps function names to beast IDs via beast_definitions.cairo, + * and outputs ../image-data.ts (inside sdk/) with 4 lookup maps. + * + * Usage: node scripts/extract-beast-images.mjs + */ + +import { readFileSync, writeFileSync } from "fs"; +import { resolve, dirname } from "path"; +import { fileURLToPath } from "url"; + +const __dirname = dirname(fileURLToPath(import.meta.url)); +const BEASTS_SRC = resolve(__dirname, "../../src"); +const OUTPUT = resolve(__dirname, "../image-data.ts"); + +// Beast name -> ID mapping from beast_definitions.cairo +const BEAST_NAME_TO_ID = { + warlock: 1, typhon: 2, jiangshi: 3, anansi: 4, basilisk: 5, + gorgon: 6, kitsune: 7, lich: 8, chimera: 9, wendigo: 10, + rakshasa: 11, werewolf: 12, banshee: 13, draugr: 14, vampire: 15, + goblin: 16, ghoul: 17, wraith: 18, sprite: 19, kappa: 20, + fairy: 21, leprechaun: 22, kelpie: 23, pixie: 24, gnome: 25, + griffin: 26, manticore: 27, phoenix: 28, dragon: 29, minotaur: 30, + qilin: 31, ammit: 32, nue: 33, skinwalker: 34, chupacabra: 35, + weretiger: 36, wyvern: 37, roc: 38, harpy: 39, pegasus: 40, + hippogriff: 41, fenrir: 42, jaguar: 43, satori: 44, direwolf: 45, + bear: 46, wolf: 47, mantis: 48, spider: 49, rat: 50, + kraken: 51, colossus: 52, balrog: 53, leviathan: 54, tarrasque: 55, + titan: 56, nephilim: 57, behemoth: 58, hydra: 59, juggernaut: 60, + oni: 61, jotunn: 62, ettin: 63, cyclops: 64, giant: 65, + nemeanlion: 66, berserker: 67, yeti: 68, golem: 69, ent: 70, + troll: 71, bigfoot: 72, ogre: 73, orc: 74, skeleton: 75, +}; + +/** + * Extract data URIs from a Cairo file. + * Each function contains a single .append(@"data:image/...;base64,...") call. + * + * @param {string} filePath - Path to the Cairo file + * @param {RegExp} fnPattern - Regex to extract beast name from function name + * @returns {Record} beastId -> data URI + */ +function extractDataUris(filePath, fnPattern) { + const content = readFileSync(filePath, "utf-8"); + const result = {}; + + // Match function definitions and their data URIs + // Pattern: fn get__..._svg() -> ByteArray { ... @"data:..." ... } + const fnRegex = new RegExp( + `fn (get_\\w+)\\(\\) -> ByteArray \\{[^}]*@"(data:image\\/[^"]+)"`, + "gs" + ); + + let match; + while ((match = fnRegex.exec(content)) !== null) { + const fnName = match[1]; + const dataUri = match[2]; + + // Extract beast name from function name using the provided pattern + const nameMatch = fnName.match(fnPattern); + if (!nameMatch) { + console.warn(`Could not parse beast name from: ${fnName}`); + continue; + } + + const beastName = nameMatch[1].toLowerCase(); + const beastId = BEAST_NAME_TO_ID[beastName]; + if (!beastId) { + console.warn(`Unknown beast name: ${beastName} (from ${fnName})`); + continue; + } + + result[beastId] = dataUri; + } + + return result; +} + +// Extract from all 4 files +const pngRegular = extractDataUris( + resolve(BEASTS_SRC, "beast_png_regular_data.cairo"), + /^get_(\w+)_svg$/ +); +const pngShiny = extractDataUris( + resolve(BEASTS_SRC, "beast_png_shiny_data.cairo"), + /^get_(\w+)_shiny_svg$/ +); +const gifRegular = extractDataUris( + resolve(BEASTS_SRC, "beast_gif_regular_data.cairo"), + /^get_(\w+)_regular_gif_svg$/ +); +const gifShiny = extractDataUris( + resolve(BEASTS_SRC, "beast_gif_shiny_data.cairo"), + /^get_(\w+)_shiny_gif_svg$/ +); + +// Verify counts +for (const [label, map] of [ + ["PNG regular", pngRegular], + ["PNG shiny", pngShiny], + ["GIF regular", gifRegular], + ["GIF shiny", gifShiny], +]) { + const count = Object.keys(map).length; + if (count !== 75) { + console.error(`${label}: expected 75 beasts, got ${count}`); + process.exit(1); + } + console.log(`${label}: ${count} beasts extracted`); +} + +// Generate TypeScript output +function generateMapLiteral(map) { + const entries = Object.entries(map) + .sort(([a], [b]) => Number(a) - Number(b)) + .map(([id, uri]) => ` ${id}: "${uri}",`) + .join("\n"); + return `{\n${entries}\n}`; +} + +const ts = `/** + * Beast image data URIs extracted from on-chain Cairo contracts. + * + * AUTO-GENERATED by scripts/extract-beast-images.mjs — DO NOT EDIT + * + * Contains inline base64 data URIs for all 75 beasts in 4 variants: + * - PNG regular, PNG shiny, GIF regular, GIF shiny + */ + +/** Beast ID (1-75) -> data:image/png;base64,... */ +export const BEAST_PNG_REGULAR: Record = ${generateMapLiteral(pngRegular)}; + +/** Beast ID (1-75) -> data:image/png;base64,... (shiny variant) */ +export const BEAST_PNG_SHINY: Record = ${generateMapLiteral(pngShiny)}; + +/** Beast ID (1-75) -> data:image/gif;base64,... */ +export const BEAST_GIF_REGULAR: Record = ${generateMapLiteral(gifRegular)}; + +/** Beast ID (1-75) -> data:image/gif;base64,... (shiny variant) */ +export const BEAST_GIF_SHINY: Record = ${generateMapLiteral(gifShiny)}; + +/** + * Get the on-chain data URI for a beast image. + * + * @param beastId - Beast type ID (1-75) + * @param shiny - Whether to use the shiny variant + * @param animated - Whether to use the animated GIF variant (default: false for PNG) + * @returns data:image/... base64 data URI, or empty string if not found + */ +export function getBeastImageDataUri( + beastId: number, + shiny: boolean, + animated: boolean = false, +): string { + if (animated) { + return (shiny ? BEAST_GIF_SHINY[beastId] : BEAST_GIF_REGULAR[beastId]) ?? ""; + } + return (shiny ? BEAST_PNG_SHINY[beastId] : BEAST_PNG_REGULAR[beastId]) ?? ""; +} +`; + +writeFileSync(OUTPUT, ts); +console.log(`\nWrote ${OUTPUT}`); diff --git a/sdk/svg-constants.ts b/sdk/svg-constants.ts new file mode 100644 index 0000000..18088f9 --- /dev/null +++ b/sdk/svg-constants.ts @@ -0,0 +1,131 @@ +/** + * Beast SVG Constants + * + * Static SVG fragments extracted from the Cairo beast_svg.cairo contract. + * These values must match the on-chain SVG renderer exactly. + */ + +/** + * VT323 font as base64-encoded woff2. + * Verbatim from Cairo beast_svg.cairo line 109. + */ +export const VT323_FONT_BASE64 = + "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"; + +/** + * Get the SVG tier color (matches Cairo get_tier_color exactly). + * NOTE: These differ from getTierColor() in index.ts (T3 is #0000ff not #0066ff, T4 is #00ff00 not #00cc00, T5 is #ffffff not #cccccc). + */ +export function getSvgTierColor(tier: number): string { + switch (tier) { + case 1: + return "#ff8800"; + case 2: + return "#8c00bf"; + case 3: + return "#0000ff"; + case 4: + return "#00ff00"; + case 5: + return "#ffffff"; + default: + return "#ffffff"; + } +} + +/** + * Get the SVG tier pastel color (matches Cairo get_tier_pastel_color exactly). + * Used in the rainbow gradient for shiny beasts. + */ +export function getSvgTierPastelColor(tier: number): string { + switch (tier) { + case 1: + return "#ffbe73"; + case 2: + return "#c073dc"; + case 3: + return "#7373ff"; + case 4: + return "#73ff73"; + case 5: + return "#ffffff"; + default: + return "#ffffff"; + } +} + +// --- SVG Fragment Constants --- + +export const SVG_GOLD_GRADIENT = + "" + + "" + + "" + + "" + + ""; + +export const SVG_PANEL_GRADIENT = + "" + + "" + + "" + + ""; + +export const SVG_SHINY_RIM_GRADIENT = + "" + + "" + + "" + + "" + + "" + + "" + + "" + + "" + + "" + + ""; + +export const SVG_SPARKLE_GRADIENT = + "" + + "" + + "" + + "" + + ""; + +export const SVG_LOGO_RAINBOW_GRADIENT = + "" + + "" + + "" + + "" + + "" + + "" + + "" + + ""; + +export const SVG_HEART_ICON = + ""; + +export const SVG_BOLT_ICON = + ""; + +export const SVG_CROWN_ICON = + "" + + "" + + "" + + "" + + "" + + "" + + ""; + +export const SVG_TROPHY_ICON = + "" + + "" + + "" + + "" + + "" + + ""; + +export const SVG_PIN_PATTERN = + "" + + "" + + "" + + ""; + +export const SVG_LOGO_PATH = + "M242.9 629.232H69.4V349.536H0V699.071H242.9V629.232ZM312.3 69.9071V0H34.7V69.9071H0V314.582H104.1V384.489H242.9V314.582H347V69.9071H312.3ZM277.6 244.675H208.2V314.582H138.8V244.675H69.4V139.814H138.8V244.675H208.2V139.814H277.6V244.675ZM104.1 594.279H277.6V734.093H0V804H312.3V734.093H347V524.372H173.5V489.418H347V419.511H104.1V594.279Z"; diff --git a/sdk/svg.ts b/sdk/svg.ts new file mode 100644 index 0000000..02ad27a --- /dev/null +++ b/sdk/svg.ts @@ -0,0 +1,306 @@ +/** + * Beast SVG Renderer + * + * TypeScript port of the Cairo beast_svg.cairo on-chain SVG renderer. + * Generates identical SVG card images for Beast NFTs locally. + */ + +import { getBeastName, getBeastTier, getBeastType } from "./lookups"; +import { getBeastImageDataUri } from "./image-data"; +import { calculatePower } from "./utils"; +import { + getSvgTierColor, + VT323_FONT_BASE64, + SVG_GOLD_GRADIENT, + SVG_PANEL_GRADIENT, + SVG_SHINY_RIM_GRADIENT, + SVG_SPARKLE_GRADIENT, + SVG_LOGO_RAINBOW_GRADIENT, + SVG_HEART_ICON, + SVG_BOLT_ICON, + SVG_CROWN_ICON, + SVG_TROPHY_ICON, + SVG_PIN_PATTERN, + SVG_LOGO_PATH, +} from "./svg-constants"; + +/** + * Input for generating a Beast SVG card. + */ +export interface BeastSvgInput { + beastId: number; // 1-75 + prefix: string | null; // Resolved prefix name, null for genesis + suffix: string | null; // Resolved suffix name, null for genesis + tier: number; // 1-5 + level: number; + health: number; + power: number; + shiny: boolean; + rank: number | null; // 1=crown, >1=trophy, 0/null=none + animated?: boolean; // Optional: use GIF data when true + imageUrl?: string; // Optional override, defaults to getBeastImageDataUri(beastId, shiny, animated) +} + +/** + * BeastNFT type matching the one in useUserBeasts.ts. + * Imported here as a local type alias to avoid circular dependency. + */ +interface BeastNFT { + tokenId: string; + beastId: number | null; + prefix: string | null; + suffix: string | null; + tier: number | null; + level: number | null; + health: number | null; + power: number | null; + rank: number | null; + shiny: boolean; + animated?: boolean | null; + type: string | null; + imageUrl: string | null; + [key: string]: unknown; +} + +/** Escape special characters for safe SVG text embedding. */ +function escapeXml(text: string): string { + return text + .replace(/&/g, "&") + .replace(//g, ">") + .replace(/'/g, "'") + .replace(/"/g, """); +} + +/** Build the block with gradients, icons, patterns, and font style. */ +function buildDefs(isShiny: boolean): string { + // The isShiny param is accepted for future use (e.g., conditional defs). + // Currently all defs are always included, matching the Cairo contract. + void isShiny; + + return ( + "" + + "" + + SVG_GOLD_GRADIENT + + SVG_PANEL_GRADIENT + + SVG_SHINY_RIM_GRADIENT + + SVG_SPARKLE_GRADIENT + + SVG_LOGO_RAINBOW_GRADIENT + + SVG_HEART_ICON + + SVG_BOLT_ICON + + SVG_CROWN_ICON + + SVG_TROPHY_ICON + + SVG_PIN_PATTERN + + "" + ); +} + +/** Build the background rect with pin pattern. */ +function buildBackground(): string { + return ""; +} + +/** Build the top-left logo with tier/rainbow fill + pulse animation. */ +function buildLogo(tier: number, isShiny: boolean): string { + const logoFill = isShiny + ? "url(#logo_pastel_rainbow)" + : getSvgTierColor(tier); + + return ( + "" + + "" + + `` + + "" + + "" + ); +} + +/** Build rank display: crown for rank 1, trophy for rank >1, or empty. */ +function buildRankDisplay(rank: number | null): string { + if (rank === 1) { + return ( + "" + + "1" + ); + } + if (rank != null && rank > 1) { + return ( + "" + + `${rank}` + ); + } + return ""; +} + +/** Build beast name layout: 2-line for standard beasts, 1-line for genesis. */ +function buildBeastName( + beastId: number, + prefix: string | null, + suffix: string | null +): string { + const beastName = escapeXml(getBeastName(beastId)); + + if (prefix || suffix) { + // Standard beast: prefix/suffix on line 1, beast name on line 2 + let quotedName = '"'; + if (prefix) { + quotedName += escapeXml(prefix); + if (suffix) { + quotedName += " "; + } + } + if (suffix) { + quotedName += escapeXml(suffix); + } + quotedName += '"'; + + return ( + `${quotedName}` + + `${beastName}` + ); + } + + // Genesis beast: single large line + return `${beastName}`; +} + +/** Build the beast image with clip path and foreignObject for crisp iOS Safari scaling. */ +function buildBeastImage(imageUrl: string): string { + return ( + "" + + "" + + "" + + "" + + "" + + `` + + `` + + `` + + "" + + "" + ); +} + +/** Build the TIER/LEVEL/TYPE stats panels. */ +function buildStatsPanel( + tier: number, + level: number, + beastType: string +): string { + return ( + "" + + "" + + "TIER" + + `${tier}` + + "" + + "" + + "LEVEL" + + `${level}` + + "" + + "" + + "" + + "TYPE" + + `${escapeXml(beastType)}` + + "" + + "" + ); +} + +/** Build the POWER and HEALTH panels with icons. */ +function buildPowerHealthPanel(power: number, health: number): string { + return ( + // Power panel + "" + + "" + + "POWER" + + `${power}` + + "" + + "" + + "" + + "" + + // Health panel + "" + + "" + + "HEALTH" + + `${health}` + + "" + + "" + + "" + + "" + ); +} + +/** Build the outer frame: rainbow animated for shiny, gold for non-shiny. */ +function buildFrame(isShiny: boolean): string { + const stroke = isShiny ? "url(#shinyRim)" : "url(#gold)"; + return ``; +} + +/** + * Generate a complete SVG card for a Beast NFT. + * Output matches the on-chain Cairo beast_svg.cairo renderer exactly. + */ +export function generateBeastSvg(input: BeastSvgInput): string { + const { + beastId, + prefix, + suffix, + tier, + level, + health, + power, + shiny, + rank, + } = input; + + const animated = input.animated ?? false; + const imageUrl = + input.imageUrl ?? getBeastImageDataUri(beastId, shiny, animated); + const beastType = getBeastType(beastId); + + return ( + "" + + "" + + buildDefs(shiny) + + buildBackground() + + buildLogo(tier, shiny) + + buildRankDisplay(rank) + + buildBeastName(beastId, prefix, suffix) + + buildBeastImage(imageUrl) + + buildStatsPanel(tier, level, beastType) + + buildPowerHealthPanel(power, health) + + buildFrame(shiny) + + "" + ); +} + +/** + * Convenience wrapper: generate SVG from a BeastNFT object. + * Handles null fields gracefully with sensible defaults. + */ +export function generateBeastSvgFromNFT(beast: BeastNFT): string { + const beastId = beast.beastId ?? 1; + const tier = beast.tier ?? getBeastTier(beastId); + const level = beast.level ?? 1; + const health = beast.health ?? 0; + const power = beast.power ?? calculatePower(tier, level); + + return generateBeastSvg({ + beastId, + prefix: beast.prefix, + suffix: beast.suffix, + tier, + level, + health, + power, + shiny: beast.shiny, + rank: beast.rank, + animated: beast.animated ?? false, + imageUrl: beast.imageUrl ?? undefined, + }); +} diff --git a/sdk/tsconfig.json b/sdk/tsconfig.json new file mode 100644 index 0000000..526dd3e --- /dev/null +++ b/sdk/tsconfig.json @@ -0,0 +1,27 @@ +{ + "compilerOptions": { + "target": "ES2022", + "module": "ESNext", + "moduleResolution": "bundler", + "declaration": true, + "declarationMap": true, + "sourceMap": true, + "outDir": "dist", + "rootDir": ".", + "strict": true, + "esModuleInterop": true, + "skipLibCheck": true, + "forceConsistentCasingInFileNames": true, + "resolveJsonModule": true, + "isolatedModules": true + }, + "include": [ + "*.ts" + ], + "exclude": [ + "node_modules", + "dist", + "__tests__", + "scripts" + ] +} diff --git a/sdk/types.ts b/sdk/types.ts new file mode 100644 index 0000000..eecb3d9 --- /dev/null +++ b/sdk/types.ts @@ -0,0 +1,219 @@ +/** + * Beast SDK Type Definitions + * + * Types for Beast NFT data and API responses. + */ + +/** + * Beast API response format (from Summit API) + * Uses snake_case as returned from the server + */ +export interface BeastApiResponse { + token_id: number; + id: number; // beast_id (1-75) + name: string; // Beast species name (e.g., "Dragon") + prefix: string; // Prefix name (resolved, e.g., "Apocalypse") + suffix: string; // Suffix name (resolved, e.g., "Bane") + tier: number; // 1-5 (1 = highest) + type: string; // "Magic", "Hunter", "Brute" + power: number; + level: number; + health: number; + shiny: number; // 0 or 1 + animated: number; // 0 or 1 + adventurers_killed: number; + last_killed_by: number; + last_dm_death_timestamp: number; +} + +/** + * Summit API /beasts/all row (numeric, lightweight payload). + */ +export interface SummitBeastRow { + token_id: number; + beast_id: number; + prefix: number; + suffix: number; + level: number; + health: number; + shiny: number; + animated: number; + [key: string]: unknown; +} + +/** + * Summit API /beasts/all response shape. + */ +export interface SummitBeastListResponse { + data: SummitBeastRow[]; + pagination: { + limit: number; + offset: number; + total: number; + has_more: boolean; + }; +} + +/** + * Canonical on-chain beast data (PackableBeast + token ID). + */ +export interface BeastOnchain { + tokenId: number; + beastId: number; + prefix: number; + suffix: number; + level: number; + health: number; + shiny: number; + animated: number; + rank?: number | null; +} + +/** + * Render-ready beast data for UI/SVG generation. + */ +export interface BeastRenderData { + tokenId: number; + beastId: number; + prefix: number; + suffix: number; + level: number; + health: number; + shiny: boolean; + animated: boolean; + rank: number | null; + name: string; + prefixName: string | null; + suffixName: string | null; + fullName: string; + tier: number; + type: BeastCombatType; + power: number; +} + +/** + * Data source identifier for fetch results. + */ +export type BeastDataSource = "summit-api" | "voyager" | "rpc"; + +/** + * Fetch result wrapper with source info. + */ +export interface BeastFetchResult { + beasts: BeastRenderData[]; + source: BeastDataSource; +} + +/** + * Core beast input attributes (matches on-chain PackableBeast fields). + */ +export interface BeastInput { + beastId: number; + prefix: number; + suffix: number; + level: number; + health: number; + shiny: number; + animated: number; +} + +/** + * Validation result for beast inputs. + */ +export interface ValidationResult { + ok: boolean; + error?: string; +} + +/** + * Token URI metadata attribute. + */ +export interface BeastMetadataAttribute { + trait_type: string; + value: string; +} + +/** + * Token URI metadata JSON shape. + */ +export interface BeastMetadataJson { + name: string; + description: string; + image: string; + attributes: BeastMetadataAttribute[]; + [key: string]: unknown; +} + +/** + * Parsed metadata attributes with typed fields. + */ +export interface BeastMetadataAttributesParsed { + tokenId: number | null; + beastId: number | null; + beast: string | null; + type: string | null; + tier: number | null; + prefix: string | null; + suffix: string | null; + level: number | null; + health: number | null; + power: number | null; + rank: number | null; + adventurersKilled: number | null; + lastKilledBy: number | null; + lastDeathTimestamp: number | null; + shiny: number | null; + animated: number | null; + genesis: number | null; +} + +/** + * Metadata validation issue. + */ +export interface MetadataValidationIssue { + path: string; + message: string; +} + +/** + * Metadata validation result. + */ +export interface MetadataValidationResult { + ok: boolean; + issues: MetadataValidationIssue[]; +} + +/** + * Parsed token URI with convenience projections. + */ +export interface ParsedTokenUri { + metadata: BeastMetadataJson; + attributeMap: Record; + attributes: BeastMetadataAttributesParsed; + imageSvg?: string; +} + +/** + * Safe token URI parse result. + */ +export interface TokenUriParseResult { + ok: boolean; + value?: ParsedTokenUri; + error?: string; + issues?: MetadataValidationIssue[]; +} + +/** + * Combat type categories for beasts + */ +export type BeastCombatType = "Magic" | "Hunter" | "Brute"; + +/** + * Tier levels (1 = strongest, 5 = weakest) + */ +export type BeastTier = 1 | 2 | 3 | 4 | 5; + +/** + * Beast ID range (1-75) + */ +export type BeastId = number; diff --git a/sdk/utils.ts b/sdk/utils.ts new file mode 100644 index 0000000..ad10eed --- /dev/null +++ b/sdk/utils.ts @@ -0,0 +1,42 @@ +/** + * Beast SDK Utility Functions + * + * Pure utility functions extracted to avoid circular dependencies. + */ + +/** + * Calculate a beast's power based on tier and level + * Power = (6 - tier) * level + */ +export function calculatePower(tier: number, level: number): number { + return (6 - tier) * level; +} + +/** + * Calculate a beast's power with on-chain u16 clamping. + * On-chain: if level > 65535 / multiplier, power = 65535. + */ +export function calculatePowerClamped(tier: number, level: number): number { + const multiplier = 6 - tier; + if (multiplier <= 0) { + return 0; + } + const maxLevel = Math.floor(65535 / multiplier); + if (level > maxLevel) { + return 65535; + } + return level * multiplier; +} + +/** + * Compare two beasts for ranking: power desc, then health desc. + * Returns true if A should rank above B. + */ +export function isHigherRank( + powerA: number, + healthA: number, + powerB: number, + healthB: number +): boolean { + return powerA > powerB || (powerA === powerB && healthA > healthB); +} diff --git a/sdk/validation.ts b/sdk/validation.ts new file mode 100644 index 0000000..cd6e396 --- /dev/null +++ b/sdk/validation.ts @@ -0,0 +1,73 @@ +/** + * Beast SDK Validation Helpers + * + * Mirrors on-chain validation and genesis defaults. + */ + +import type { BeastInput, ValidationResult } from "./types"; + +export const GENESIS_DEFAULTS = { + prefix: 0, + suffix: 0, + level: 1, + health: 100, + shiny: 1, + animated: 1, +} as const; + +/** Validate a beast ID is within valid range (1-75). */ +export function validateBeastId(beastId: number): ValidationResult { + if (beastId >= 1 && beastId <= 75) { + return { ok: true }; + } + return { ok: false, error: "Invalid beast ID" }; +} + +/** Validate beast attributes against on-chain constraints. */ +export function validateBeastAttributes( + prefix: number, + suffix: number, + shiny: number, + animated: number +): ValidationResult { + if (prefix < 0 || prefix > 69) { + return { ok: false, error: "Invalid prefix" }; + } + if (suffix < 0 || suffix > 18) { + return { ok: false, error: "Invalid suffix" }; + } + if (shiny < 0 || shiny > 1) { + return { ok: false, error: "Invalid shiny value" }; + } + if (animated < 0 || animated > 1) { + return { ok: false, error: "Invalid animated value" }; + } + return { ok: true }; +} + +/** Validate a full beast input payload. */ +export function validateBeastInput(beast: BeastInput): ValidationResult { + const idCheck = validateBeastId(beast.beastId); + if (!idCheck.ok) { + return idCheck; + } + return validateBeastAttributes( + beast.prefix, + beast.suffix, + beast.shiny, + beast.animated + ); +} + +/** Create a genesis beast input with on-chain default attributes. */ +export function createGenesisBeast(beastId: number): BeastInput { + return { + beastId, + prefix: GENESIS_DEFAULTS.prefix, + suffix: GENESIS_DEFAULTS.suffix, + level: GENESIS_DEFAULTS.level, + health: GENESIS_DEFAULTS.health, + shiny: GENESIS_DEFAULTS.shiny, + animated: GENESIS_DEFAULTS.animated, + }; +}