import timm
import torch
from PIL import Image
from timm.utils import ParseKwargs
from timm.data.constants import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, DEFAULT_CROP_PCT

# from transformers.utils import logging

# logging.set_verbosity_info()
# logger = logging.get_logger("transformers")
###

import os
import time
from contextlib import suppress
from functools import partial

import numpy as np
import pandas as pd
import torch

from timm.data import create_dataset, create_loader, resolve_data_config, ImageNetInfo, infer_imagenet_subset
from timm.layers import apply_test_time_pool
from timm.models import create_model
from timm.utils import AverageMeter, setup_default_logging, set_jit_fuser, ParseKwargs

try:
    from apex import amp
    has_apex = True
except ImportError:
    has_apex = False

has_native_amp = False
try:
    if getattr(torch.cuda.amp, 'autocast') is not None:
        has_native_amp = True
except AttributeError:
    pass

# try:
#     from functorch.compile import memory_efficient_fusion
#     has_functorch = True
# except ImportError as e:
#     has_functorch = False

has_compile = hasattr(torch, 'compile')

import PIL
import requests
import io
import base64



# ImageFile.LOAD_TRUNCATED_IMAGES = True
###


def transform_percentage(old_value):
    threshold = 0.7
    desired_range_end = 1
    desired_range_start = 0
    k = 20  # You can adjust this parameter
    
    new_value = (desired_range_end - desired_range_start) * (1 / (1 + np.exp(-k * (old_value - threshold)))) + desired_range_start
    return new_value

class EndpointHandler():
    def __init__(self, path=""):
        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
        
        if torch.cuda.is_available():
            torch.backends.cuda.matmul.allow_tf32 = True
            torch.backends.cudnn.benchmark = True

        # May sacrifice a bit of accuracy, depending on our needs
        assert has_native_amp, 'Please update PyTorch to a version with native AMP (or use APEX).'
        amp_dtype = torch.float16
        amp_autocast = partial(torch.autocast, device_type=self.device.type, dtype=amp_dtype)

        # data_config = resolve_data_config(vars(args), model=model)
        
        self.aiGeneratorModel = timm.create_model('eva02_base_patch14_448.mim_in22k_ft_in22k_in1k', num_classes=4, in_chans=3, checkpoint_path=path + '/model_best_v6.pth-52b1d7bb.pth')
        # self.aiArtModel = timm.create_model('eva02_base_patch14_448.mim_in22k_ft_in22k_in1k', num_classes=3, in_chans=3, checkpoint_path=path + '/AIArtDetector.pth-af59f7fa.pth')
        self.aiArtModel = timm.create_model('eva02_large_patch14_448.mim_m38m_ft_in22k_in1k', num_classes=2, in_chans=3, checkpoint_path=path + '/modelv3.pth')	
        self.aiGeneratorModel = self.aiGeneratorModel.to(self.device)
        self.aiArtModel = self.aiArtModel.to(self.device)
        self.aiGeneratorModel.eval()
        self.aiArtModel.eval()

        
        self.transform = timm.data.create_transform(input_size=(3, 448, 448),
        is_training=False,
        use_prefetcher=False,
        no_aug=False,
        scale=None,
        ratio=None,
        hflip=0,
        vflip=0.,
        color_jitter=0,
        auto_augment=None,
        interpolation='bicubic',
        # mean=(0.5, 0.5, 0.5),
        # std=(0.5, 0.5, 0.5),
        re_prob=0.,
        re_mode='const',
        re_count=1,
        re_num_splits=0,
        crop_pct=1.0,
        # crop_mode='center',
        crop_mode='squash',
        tf_preprocessing=False,
        separate=False)
        
        # assert has_compile, 'A version of torch w/ torch.compile() is required for --compile, possibly a nightly.'
        # torch._dynamo.reset()
        # model = torch.compile(model, backend=args.torchcompile)

        self.supported_formats = ["JPEG", "PNG", "BMP", "TIFF", "WEBP", "RAW"] #GIF requires its own special implementation to get its frames
        self.label_map = {0: 'Dall-E 2', 1: 'Dall-E 3', 2: 'Midjourney', 3: 'Stable Diffusion'}
        # self.ai_label_map = {0: "AI", 1: "Non-AI", 2: "Null"}
        self.ai_label_map = {0: "AI", 1: "Non-AI"}
        print("initialized handler.py successfully")

        
    def __call__(self, data): 
        """
       data args:
            inputs: Dict[str, Any]
      Return:
            A :obj:`list` | `dict`: will be serialized and returned
        """
        inputs = data.pop("inputs")

        if not isinstance(inputs, list):
            inputs = [inputs]

        if len(inputs) > 10:
            return {'error': 'Exceeds max limit of images (50)'}

        print(inputs)

        image_paths = inputs #['https://google_image.png', '']
        batch_size = 1  # Set your desired batch size, currently a small part of the code I wrote doesn't support batch_size > 1.
        
        results = {}
        for i in range(0, len(image_paths), batch_size): # For each batch
            batch_paths = image_paths[i:i+batch_size]
            validUrls = []
            batch_images = []

            # time1 = time.time()
            
            for j, src in enumerate(batch_paths): # Get all valid images open and inputted in batch_images
                try:
                    if isinstance(src, str):
                        # Image.open(batch_paths[j]).load() # Tests if image is okay to run inference on.
                        pos = src.find("base64")
                        if pos != -1:
                            # Assuming base64_str is the string value without 'data:image/jpeg;base64,'
                            new = Image.open(io.BytesIO(base64.decodebytes(bytes(src[pos+7:], "utf-8")))).convert("RGB")
                            new.load()
    
                            width, height = new.size
    
                            if (width < 250 or height < 250):
                                results[src] = {'error': 'Image quality not high enough'}
                                raise Exception('Image quality not high enough')
                            # new.load() Necessary? Does this catch any edge cases? Without this, we don't actually load the image pixels.
                            batch_images.append(new)
                            validUrls.append(src)
                        else: 
                            try:
                                # r = requests.get(src, stream=True)
                                # r.raw.decode_content = True
                                # new = Image.open(r.raw).convert("RGB")
                                # new = Image.open(urlopen(src))
                                headers = {
                                    'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36'
                                }
                                # t0 = time.time()
                                r = requests.get(src, headers=headers)
                                new = Image.open(io.BytesIO(r.content)).convert("RGB")
                                new.load()
                                width, height = new.size
                                if (width < 250 or height < 250):
                                    results[src] = {'error': 'Image quality not high enough'}
                                    raise Exception('Image quality not high enough')
                                # new.load()
                                # print('none base 64 image')
                                # print(t1 - t0)
                                batch_images.append(new)
                                validUrls.append(src)
                            except Exception as e: 
                                if e.args == ('Image quality not high enough',):
                                    results[src] = {'error': 'Image quality not high enough'}
                                else:
                                    results[src] = {'error': 'Failed to process image'}
                                print(e)
                                # invalid_indices.append(j)
                                continue
                        # batch_images.append(batch_paths[j])
                    elif isinstance(src, PIL.Image.Image):
                        # Handle PIL Image objects
                        new = src.convert("RGB")
                        new.load()
                        width, height = new.size
                        if width < 250 or height < 250:
                            print("OKERROR")
                            results[str(j)] = {'error': 'Image quality not high enough'}
                            print("ERROR AFTER")
                            raise Exception('Image quality not high enough')

                        batch_images.append(new)
                        validUrls.append(str(i)+str(j))
                        
                    
                except Exception as e:
                    if e.args == ('Image quality not high enough',):
                        results[src] = {'error': 'Image quality not high enough'}
                    else:
                        results[src] = {'error': 'Failed to process image w/ base64 in url'}
                    print(e)
                    continue
            # logger.INFO(str(time2-time1))
            # tensor = self.transform(img).to(torch.device('cuda' if torch.cuda.is_available() else 'cpu')) for img in batch_images unsqueeze 0

            print(batch_images)
            thing = [self.transform(img).to(torch.device('cuda' if torch.cuda.is_available() else 'cpu')) for img in batch_images]
            # time2 = time.time()
            if len(thing) > 0:
                batch_tensors = torch.stack(thing)
                is_AI = []

                with torch.no_grad():
                    aiOutput = self.aiArtModel(batch_tensors)
                    for k, tensor in enumerate(aiOutput):
                        output = tensor.softmax(-1)
                        # output, indice = output.topk(3)
                        output, indice = output.topk(2)
                        labels = [self.ai_label_map[x] for x in indice.cpu().numpy().tolist()] #numpy()[0]
                        probabilities = [round(i * 100, 2) for i in output.cpu().numpy().tolist()] # numpy()[0]
                        ai_prob = probabilities[labels.index("AI")]
                        ai_prob = round(transform_percentage(ai_prob/100) * 100, 2)
                        if ai_prob > 50:
                            is_AI.append(k)
                            #this arch only works for non-batching
                            output1 = self.aiGeneratorModel(batch_tensors)
                            for k, tensor in enumerate(output1):
                                output = tensor.softmax(-1)
                                output, indice = output.topk(4)
                                labels = [self.label_map[x] for x in indice.cpu().numpy().tolist()]
                                probabilities = [round(i * 100, 2) for i in output.cpu().numpy().tolist()]
                                # time3 = time.time()
                                single_res = {"ai_probability": ai_prob, 'probabilities': probabilities, 'indices': labels}
                                results[validUrls[k]] = single_res

                        else:
                            # time3 = time.time()
                            res = {"ai_probability": ai_prob}
                            results[validUrls[k]] = res
        return results
# handler = EndpointHandler()
# handler.__call__({'inputs': ['https://www.ef.edu/', 'foewfoewjf','data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAkGBxMTEhMTExMWFhUWGBcaGBcXFRcXFxoYGBgYFxcYGBgYHSggGBolGxYWITEhJSkrLi4uGB8zODMtNygtLisBCgoKDg0OGxAQGy0mICYtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLf/AABEIAOEA4QMBIgACEQEDEQH/xAAcAAACAgMBAQAAAAAAAAAAAAAEBQMGAAIHAQj/xABJEAACAQIEAgcEBgcFBwQDAAABAhEAAwQSITEFQQYTIlFhcYEykaGxI0JSYsHwBxQzcoKy0TRzkuHxFUODorPC0hZTY+IkRMP/xAAaAQADAQEBAQAAAAAAAAAAAAADBAUCAQYA/8QANBEAAQMCAwUHBAEFAQEAAAAAAQACEQMhBBIxQVFxgfATImGRscHRBTKh4fEUM0JSciMV/9oADAMBAAIRAxEAPwDmOFsA6mjxh1j2RQ+EpjT1NohQazzmSrE4TLqNvlUOgpriDoaVJamkcSAx1tqqYFzqrSHbFoDPhUyrUqYQ1OyQIoAcSnw0DRLnXWo2SiryU06O8DN8gn2B8f8A6/nvp2i1z3BoSOLqMosNR5gBBcH4K98iAQvf/T+tW1Vw2CWIDXPsjv8Avn8+lD8U40todVh9I0a4Nz4J3Dx91Vm9iSR61SGSkIbc71BIrYsy+Ws2DQnju9eCdY3pDdfXMFXkqGJ331kjSld3Gu3tMTGw5DyA0FaYDAXb2qL2Ru79m2P4jv6Uf+qYe37bG6w3g5LYjf7xj0rMvf3j+UUNo0TkYL7gPU7OZlBrdPIn3034dhWaOsFzqyQGy+0U5gSRO5HhLxqaTX+OD2US3bU+QYj07XxojCcdtZfpLl/N3W5yxyjMZrPaNbtW3Yes8WaB14aFdH4Picu2YqpgFxlJHKQefKdmiRzAsuF4h41xXE9IUA+hu3p/+RSRHpU/Dum1+3AJtOByPYYDwG5rfb03C6TbgcTRMsg+F/dd7w2P8aaYfF+Ncn4N03suQrnq2MaPsfI1dMFjwdjQn0QRIT1DHEHLUsfFNOkPRfC41Ct22CeRI1U96kag+IrhXTboDewJLCXs/b+so+/H1fve+K7/AIXE7UbdtJeQo4DAjnSriRZ2n5HW5UA3N3qdj+DxG/xHORZfIXV15cTlXSP0jdAjg3620JsMeX1Cf+35eW3P71mgVbJ3Dd8TGmo3FQ4Yw2803sXGPKgbVpcwjTvp9h7cLPeSKQqMJvCr0oByz5JPxDNG49N6VEU34hb5b5dz5mlpWmaVHuApWo4l61sydBW9q3NSYK3Lij7GG5+NfOgWXQ0oP9WNZTfqxWVhbyhKrF2DRn62O+hLVqfD0mvHskGDT+dzRZea7FrrlEPdDQJ350VhMKM0AyORpciUwwrajwpCrmJlyq4cMa3K1PlwQyzFL8Th9YFG/r5IigcRd99DabpgNsoMLws3rgUbc/wA8T8gTyp5xrHC0nUWtAOy5Gmv/tr+PuojC2+otCI615gnl9u55AaegPfVU4jiQScuw0Wd/Fz4nf1r0NJnYUr6nX4Xka1U4zEyPsbp4nf8cPC4924ubWSOYBj3GDHuNMsPwy3bHW4jQbrbJ93WRv8Au/6DTheGW0n6xd/4aePIxzJ5D18lHFMa1xi9w+SToB4n8+mlcMMGZ2uwe5RwHVndmww0anaTuHueiwxvHGuA5dEBCIuwLny2AkTHeNTSjG3+wYMy8E94En0EjbuAFD27s5T9lwfIaa/A1vhzOa2wJU9qRqVInWCQCNWBEiZHOl31HPuU9SoMpWaIA+f4PihUDHwHl+HqKOs8PQ73wP4V/wDKrJwTo0zW2A6tiSBLK0qIIEgrowzSNRqBMxVn6NdBM7kZ1ULEM1sliSTAAYgGMpmO6hNANkxULmifj+Vzi9wtQJXEIR4gfgTQF5GXSQwiZG0THprXYePdABlz9ZbJzBXyoSULc8q6sJI0ABA1gxVW410cXq1FtURgSc5LnMgAInLIfUn2RtAlor58N1XKZc+4CqOGvyig8jl8dhl/FfKOUg2Po/0su4UjMS9oEArzE6h7Z5KQD2Dp5cqreXIQgnsnWRBLSJ05DQR/np692Ax7yo9AB+A+NaZULdEGthmVbOEj9r6L4DxtLyK9twynn+BHI+FWnB4ivmborx9sLcDoZtmM6Ty7x5fDnpv3zgHE1uoro0qwBB/Ox8KYdFVuYapKnnw1Ts3GQdD7Hx9Va8Thkv22t3AGVgQQfGuAdNeihwl5l1KHVSfs93mK71hL1Jun/AxisK2UfSIM1s+I5ev40g+mXDL5cf2rVGuKTu02beG/iNR4SNq+dLNqT4in1kZbctz2pUSAdoNW7hPCUxFmWeI2FKuGYgKnnDQXKm49czsBHfqY2oMYWQTPl5+NWO9wy0WuB72Ur7Om9KUWm6bhlywjMwhJFQuEO03jipcNwxh1bZlObkN6NbDFB2hQXUZCGE/hNGXMbngHU0F7Zkpr6lTcyo3I2BF7zzQ9ZRHUHurKCkkBg7MHkJka7Hy8axcNNF4a4dRHqRr6VlpDJPdTlGoJMqHjMK7IMut0IcLFequWaaBABJ2pbiTrWKjmmwXcPRewS5edbRfBLJu3gOQ1H73L+vpStmqwcAXJYu3OZ0Hqcv8AnRMLSDqgnZdC+p4k08O4NNzYc/0tuM4rsu45xat/uDUn10/xUh4bhOtua+yurfgPX5A0d0huQLad1vMfN9flHurW2vVYYcjdknyI1/5YHrVR1330Gqh0f/OiAzV1h8+QniUv47xHM2mw0QfN/X870gugk95+X9TRF26TNw+Sj4/LX/WmHBxbtqblxS6ujDKYALH2ShVpLAiIjn4UlUfmdJVuhSFJgDRp114r3D8Bc2Ll5AGQBWYycyg6hiIhkGgJGozgnSmfArY6kug7aZpAtszSUKlmYbbmJMAyQN6u/DbtvDYWw57OazbULBJYtEJlAJIJzaDWVXeq1xLhqC51mH+jcHObbqwUhjlLhHGVhuDEjWCASKBVe37Zjq/un8PTJ70T1ZR8Fx2FW2wvCLyzlMLngk+y0Z1OXLl6s+0DMAzTjA9Nr+G6sBVuAhSysSvI6hl5wSsGRptpQ/C+iGKvqLihUXMASo2aBICsx0Hh3jnVy4T+jNU7TXGuE6nMAdTuRqPAa9wrlJ7ZJ3rFeg9oy28781WMR0xvX0a2Ut24Kns6lgAQczHUiQk8o8BSG/jkazEEXp7Uqxc3MwOrzEQDpE676a9H43+j5HSFdkdSCGXsnTUCdyJHnVLxPAMXZFxzldEaCxCoYOUTmy+0JOxnXloazXeCbE7+MbCt4Wg+IMbv4ukPGgHtKCEzAtBA7esZhBGoXqzz25HmsfgLmx1pAC5WYbybanRwDqBtEgE5u4TVpw+CsNcV7tkXWmVEwPa7M5m7c5gNT2iYynSnHELy31vaQ/Vj6MEEQpdlgjQglx8ORBrVF7T3J664LGKplsujQ9dXXJbIM6aN3fnn4V0X9FvSDI/UMew57I+zcjYfdYbeI8arPF+GIUa7af2YMHbbXYaHn2iAQQRmml+AxBDLcUw0g+TAyD/i199FpPyuskcXQ7WnfXUcR16r6jwV6YpzYadDzqk9F+Ji9Zt3B9ZQfI8x6GR6VbMPc2rdZixg62Zt1wj9IfBv1fG3VAhWOdf4tfn86h4RigLca+hq9/powYixejeVPlA/yrm/BbyBx1nsTrSFYHNI23+fzKtYRzTTynZI8tPxCg4gdSZ/rS/r4Bp/0pbDs4NgQI1qtvbMwBRaTcwTTamUAos8VuNaFiRkHaAgTPn61NhGlkAA1IFKIKmaLwd+GB5A/OjPYQ0yjuxRruElXGfKsqp/7SNe0h2RXO1Yp7F+TrUtk79w1pRavaijLd6PSgUiQsVwHBH37pIgSRvFKr92tziDqQYmhWExTtJkqZiamWTsWoarRgP7OF7in/TWf+arL0Z6L27dpbjqHuMubtCQsiQIOnrVW4O+Zbo/+Rvl/lTP07EMrPeGaCBO+Z08uajfWcO+kym55uZMbojXxvyQfHUzXwvI5B6ACfhNQdK7kAJ9xR79/wA+FNeIWvplb9z4wPlNJulJ+knug+5DT9WwcfFIYVwc+kNwnnZIyMz5RHZhYmNd3O0b6eUb014bwVXcQDGmsHQEwYJOp5DxI2kUHg8LcVM9wZUMmbkBCW8H30n2QTtRYx1xkIsqY9nOunoikzOVt9TBIAUGknd0S5W6XfdkYZA3J7x7pCDfRVICWfrDVc6keMlFjLqBOU/ara1j1uvbNvtMs7Zt2KySzMxYnq0Ak6ZY8QuwDC8VRkCqpQajKAV7IIBG8lpnXlyq4cM4e1lXOHUMzRlYt7XaWe0pOWRmAYfamp1R86i++/DZb4VylQDe8HTF4gTb0EgdBXPoZYIkspQzOXNPIDMQNAdxzPyF3R6qfR4XRbHW+1p4nYbkkned2O+9PUuVtgDRAQKzzVdmKOuQRrVM6Y8ILoSnfsfZOh35giTHjVp6yguKqxttlXM0aLMT61otzCFim80zmC4dicY1m6AwyMuwzC2NCrKwcQAwYAc/FWzHKNheMTfOJLTvnjtDKzZmYsOeftnSWMwAAJu+LwfXWyb1kW2BBKlpgQJBbx1MCQM0cqqPFmFi59DDhpL22UoozAOoJgZlhlMDTtqe4gLXEPgDTbeP5hMuose3M4wXf42neQPCbwkXGOGKrN2QyTKuCFKq0QmkiByJnSANjSP2CI2J+B0Meka+FNOuuosOpKgZZGrKCAWR1B9n7rbR4ULiVN6SsMTqYaTptIOu3nTzbi2qkPOQ5XG29dV/RVxCbL2z9S4Y8mAb+bPXVMJdkCuE/owvkPc8UQ+oLj8a7Rw69IFOOGamD1ZRaNTs8S+n4+olLP0tW82BB+yxPuUt81FcPQ6V3D9Kdz/8HL3h/hauVxq3hXyyF0pOoLDn6q3hn99w4en6QF1zXiGa2urBqMvvFdYIMqhnMLS81D220b0+de3XqNWiT4j50ZxzWKCX5LhF9Wa9rTr68o/Y09yT/qa3ghlfWnHC2TODcEpOtV9X+dOsOCF25fHeo1EZXh25U6ze1YWTE7teSI4/dtF5tCFy66QM3OBSoP8AKp7rgGWWRrQQenCczi78BSXMNNnZXMCJJ164Bdm6M8ctYiwgzgXAoVkJgyBEgcwaoHBTlu3EPeD66j/vqs235imqYhQFKtL5Bn30YzHwFYwOHGHe5zTYxbdr8/yh/UsQcVTa1wuJE+R5aeatOPt6I3cU+BK/jSLj+HLshGoMA+U6/CrJw+8MRaJHtR215g7THcdIPfpVd4gSHtoftn35DVeoA5vFedwuZlSNCJ8oSG5hlIdncyuUAGSSDvJPd3VPheItaQkMVnRTEgqpk25+yTmkA7ON66F0g6LW/wDZiYixaJvm0GeDygE3MpnY5RKwSCJEGRzziluyotjD3MxYidSQVABDtmJCtmnaNtQJ1nVIML1FEkAnh1yhMMFiry3EYXFQjI4z9tScgQllgmSQ85jMjvGnQeA8ZwdtEVr6swkknsjMTmJCjQCToOVcz4ZxJbUlhnPIMSQByUTrAn517iuJJdBARF/4iJ8GNB7PuQVTkTmGunjG7d5LvGD45Yb2biHyYGmSY5Tsa+ZLVwqwglTy1+RBg10noPxe5cIQsWigO7q+aMy6kcaBzoXEcftJ7TgeZqodLsZcsrI0muWcVxb3G1ZmJ5A180yV85kLtXEOk2CdSrXVM6aVyzjuHWw4uWbjXElYzXCTbAIIXtGAnZA8IXupTgbgtEEi0x7utQt7ppriulAu2zbZR7oPvpplMEarLQ3ffr1SbFYp8lpWEKvYBAK5gCuadImQdO9j30sOFTK0EGIgwZOk6CNI5+RpnhVtNcudar3VMnsuvWSxBLMxjN2YGpIDbjWK6J0D6IW7mH/Wb9tiTAth4E217KPqdZAGoncRprXaYGh/XJJVyfuYeU3tv2BIOg+HyNcblonrJf5EV1ngVzNArlPRtyHK/ag+o0/EV0gcSXCWczn6QjReYqjA7OBqvK5iMUXu0tPW87kv/StxAELbB9m25PqAg/maqnh8Xb6sEMNtRQPSbiZupcdpzOVjuADISP5R76q3X0lXAaQPBWcCX1WuebS72CKx+IBZhy5Ut6/WtLt7WaiuHUEc640CE+arhYKQvyrfkfMVHbEmpuenfr6a0QAIDqjtF5nHfXlbyv5FZWs6xJ8ULhQuftTl8N/KmiXRupMagTv60ot6UZhbmrDw+O9Tqbdq9O2Gti03Pjp6LfFqd4Md8aTUWGZdc3dpUl3FMVyTpMxQkUUkAiFGqMc8HNa+zcprQJOgqW0CrEHmPiNflPvrMC+UzRxs9Y3cxQ9WO+4vbCfxAOvnFFYJE7VOr1OzJnTr01XuC4k9kl0JDAAgjfcAjuIgmQasyY+zioa8hs30IBKgkMfFeYIk6agSe1sKfaAYhZ0fsz4OIn4zRmEZQYXrC+RutDzpdQ58pMRqq3RHOt9oQ4DeuGgHU31JALYNzqDYxw8wulYbD4/GYPD2sMQlpGYNcdsoYLcIyjflptE+tcw4pwe69+8JUEX+r6sOJhhmBEe0CABMRoJiup9BePOcP1S3EDWXYqLjQGV5bXSSTLbbVzPpK5bG3WukfSZGYhQuTdQBMxOhkcjO5ihuNo2BO0WA5TtMe3lCC4vwG4MzW1YoJ3UqwjkVOoqDAYBSo+kCtz7xuNAR3HfcEA113omLd5CcxuDRZZi5MCD2jqRRX/ofDhy3VgzSzaxB0VOvhRMT5eyoFvorbvG3+quGIA60P1iqx+sQ2U5TyB8PGrj0K6Ofq+IOuZSPl/rVoTh6WkhVCjuFR8IebunKsOdmMldYwMbAU3TbhC3rap8a5bjOhwtXh17qLPMAnMw7to07p1rtXGBoppfcwSXVyuoYeImuzBssC7YK4HieD2xob1sqJgqoDHSBMCTsDqTGtL8Hwa4TI/ZzGaDERP4V23E9BsMTPVAfKhukmAXD4cPbUDqWV4Hcp15HlrNENbRZo4QTAPmuQ43hJ6xFMBGZEDuyrqxEmDrkAJ120767XbtYi3hrjXktTattDWjoyqpOigSMoExtLNGm/IeL3etxWa0xKvPWEDQCJc9oaQs6+A8KtuP4qiYc21eC8IVVgQQ/YJj6kKB55tzFHaTqg4lgYXtds3ITDcUFhforc3Mure02Yn2VgdgGI0Emee1AW+JXLqkuTq+06AjeJEjfnUKYS7cVripcKC4qM1uMw0JUDX6xVdp2Na25AWSSSuYncnNqCT+6Vo7HvNXLFonnNhyHkoT6NMYcPnvF0AWsALnwvadt9y04y/0Md7j8f/CklpZIBMCdTVnxKWupPWAlmDdXGwKm2snw/aUmGGUQGMT+RWawl4XcHUim6JtPxbmgOJWkVuwZEUJbMiKIxqgMQDIHOocMnarM95Ossy5lFWLRn0rdU+NGrZ09K8FuAI2jU0WISvayo/1dO817XvVjxrK+gLOY/wCxS/GYfI0f4ayxp76eXOKLfVcKbYSG3YdoQZpbxfBdQ+UNmkT/AK0jhmPNHORZet+pYjD08Z2NN02mL2uRH49lHdTUjunatOoophLDlIB89KKtWp0IrFV0G6WYzMLKPh1tVMuJFEDCLcJIbq47ak8nGoOnjUnU7RUmGsHupihUBZBUbH4Z4qFzJkpJ1ZJI3ju1HjHhVrxGIY27dwE5LkdavLrkdSzaCFJdlcnmuKfklIHZLV3KzCDIj645jTmP60dhuMWoeyR9Hd3Zj7LgEK22iQzo3PLcbmBRZETKTqAusWmOHXXglGPvOrdh8v1SdPZjQENpBGXQ91BPcuOSWLOXgOVcGYIy5kInTlRF94JDalSRqNZ1Hv3PpWnEcXbuODbQooUBoljpMtqBBJK6Dms7mKC8mVTowGcFdugnE+r7HKdK6pgsYGArgvDb5Uqw5gH4V1HozxHMopao2HKtTeHshWviTxbY9wJ9wqo8K6U4WywXPLHVidsx8as+LGa0696ke8RXA8fwa9bukHNI0zCYIHhXGiVwmAu54/pvhCoVm32o3huJBHZMjkfA6iuBYXh168VyFpBiAY/PrXcui/C2s4ZFcy+57teQ8BtXXAysiITa9iIFUzpdxIG26d4I99O+K38oNc445iS7EVgCUQHIJVBxdghpXlA/i7gOdE8OtsH1MztEz3REaHUHxitLt4C6xhjlYiMpI31IIM8vCp8NiMzF4AJPZA7IBJO32QJMd3ZpxmoUnEHumFbuEXDkNsuepEkqDGgAV2GxEgrlO4a+hGhoDE3C7O5iSZ02k8gOQrBiYthR9bKTy7InIscvaZyORcL9QUPh8WpvBCToGbQbsugQnkNZmnGkC5UaoC4w0TH560TPjITKgQnKqKq5hBPNjHKWLGPKq1j2OY1Y+IPmI+NV/iVqCNRrrpSOcvGcqgyi2i7sgf3tKVsKN4ZYLHQcqhfDsIkETtT3glqDp5UakLoeKqhrJapLuHgHTlUb28qgnaP6ind3D6Gl3E7E9nbTem3CFHpV8xgpP+sCsqLqqyg5nqjlYhcdiDdfrDE6ajTah2k66k+81tZug6MNPDvHhWKvw2pFrcrYGi9VVIqVC95km5PjtTPDCVSSPZO/hy86YWQQPl5UuwI7C6/WI99NrMxB22HhQcTNis4WLozC2w3nr2YpkmBIAkRQ3B0h58Ke4vGqyBY10oVGC0mVzEE5wIVE6X8OlVuruvZb39k/Meoqr9bIrpWMUEMrCVOhHga57xjh7WnI5EyDTFMlpylKVQ18OavFuFmWd2i2fHkp90D31c+kQW0mS6EDkIDtq69qAeYk1QsHiCjq0TBB7xoZGnnTTid27iA11pcLlGbTsgjNoN48Y5HeDTLKmUFTa2E7Sow7B86DyCauiksU9nM0fuT2fhFWfozi8h1NUPgeL7OU8vyPz4VYMNiYrFTvXVDDTTGU7F0TE9IrVtCXcAAVS8R06TrCVsIybdsnMQeYgwvxoXF8Iw91c7XGFwcsxg/0obB4PAAZbtps0iWDNtJ21/MUJrQqFIZ93MplgOmtu28rh0CTsCc3nO3wro3COluGvr2Hg/YbRh/WuZNhOGQQlpiTtLGR6iKPwPRfB5c+Z1aZUC4Tl9a64eK1Up5RJjkVbuPY0EGKqDYfUsay7iypykyBzNKuOcYy2zBgnQeZ/pv6V9TbCSqvsoVVraXBl7N5Ha2246wq3YnxjTxB7xVZVgCBuAPhzHqIFS3MFCqSYY5uzEZQqnKCdiSdRzOp05wYoksZkmTM7/xTrPfPOmDULgBuU5uHDHOdMk+3XRlF2uLXwCBeugGeyHIHa308aadHMPobh8vXXT039R3Ul4fhDccIOepbuA3Me74VdbNoAKqaKNvz31wuL+7v9FsNZRBqwABfTU7FMmGLKSBtVZxdvtGrVhmGaGOnwpZxjCor9gzNFNAls7BZTv6xrakAGSJnYlZzXMoOsVYOGYXKBQXD7YBprZNGpsi51U7F1i4ZWiAiDtSPjN8SRTHF4mAAN6R8Uk5jlJk+1rpX1V8CyxgqIL5cY1SvrzWVv1NZQLqvLNySIaaYcAyecT/WKTimWHByz90/A0s0iF6F0mwKNwTaGOTSasiYcEAzp4cqrVgzn8Y2qz8OudjLv40NxzC4WA0tdAJTO1ZUHST416h+cVmLv21VQkzHanmfCgLN/v8AOkqDHvzugtEiE3VqspZG5sxgzfXrejcQsSKW4/CJcGV1nfnHlFN2uBl2HnzjuqHGBQqwO1zM1apjMwB2q8vXd2dYvZ9pPIefjaVV16P2RrDN4FtPhFVuy1wTaPZBmSRqoAIcjwgMDG8RV5O1VHpTbAu6RJXMRA3OkzufZ25eprlRgDA4ImGqu7ZzHEmdPCOvwiOFthlW6rXIlhlJBmANCI03LeYrfBYpWJXMDBjz8R4VX7aqZmV8dx61qVKN3HkR8xQibCydYwNeTJvsOzguiYbhJuxlbemVr9Gz3NTdC+hql8G6QPbI1/p/lVyw3T1gNV91BInROtI2phY/RWF16/MfKPxoq50Y6kRmpV/6/bkppLx7p3cYELufzvWcpWyQBZadIMTbtTrJqpYviYcCUOYHfNsNRAEUP9Jfub5j8BXt9baCB22+19UeX2vPbzo4mEm6HH8/ytGuNoFJOUgKw0PhsfaiB6Ryq5YbhNs20zIA+Vc24JMCZ9ZpB0T/ALQD9ZQWXwYQJ90x3Grj4AGgvDyQQDG/YuZ6YlpIndt8lvgcDbtg5FCyNTz05TRXDLAZ8ojwocDTWRWti7lIIO1U6BEAwvM4wPlzcxTfjXCAqG5m1HLvqrrbmTNO+JY9riAFh5QZNK0sc6K8NLpCXw1So2iGPOht4IjBqukzE6xvHOK3dtGjYSfGK9yxbHZjtHt666Ds92kfGh8YhAX2TIkQQSNSIYD2TpsazK+y5ihGuywrS5i2ysmkE+tSDQDv76GuNBmsSUy1oJ0Q0V7XvXV7XExdVcJrA1P50p3w2zKfwuKh4zgOrutlEq4zDT3/AJ8abdHLMoP3mHvAqW92UL1OGdngpPgTqeVWTh7Hu10pHgLMSW1AYrE6zrBqx8Fw8zM6Fdj4ismqAjigXBPsRw1YWbgHZliwIhvsxzpLhhqfKrDxLCgqxcnNrHnpFLlNwOA6QcoAERIOxotPFOf3TfyGl7b/AGsp1f6fTpHO2R5nW2+3vdYHCrqfxPuGtLMbxRfqq7eSx/PFLuLW71u4z9aFtkzm7Zy+BCKSPP5VA3SO4P8A9q0f+Dd/EU0anelqnDDBzMrpPDoLMXx0rp1ZHiT+AFKuMqzAPmVwdVZBAjnuZmpcZ0iuHTPbbxFth/MaVfr7TOkcxEA8vf41l1QkQ5Gp4YMIcwX5385UFmJ15/CjEt6FTqu571+8vh3ihrigNK7Nqv8AT36UVaZhDgxBmTEA7EGflzrVPd11ojPUJtlGyt5g8iDsR4RTLDJUeOCMgy6EaoJnLrL255rrmXybvr3ht2RQalPKY669kajUzNv116ypr6RSu8CWCjcmBTTGPAoLhtou8CQz6AjcL9Yjx2A8TXGMkrVR8BE27ACFR7A0Zh9dvsg/ZB958AIE4jhchUN7Takdy8hVncWrSZ5VktjshWVwW5CVJG8e/wAaqF7EG5ca5cMkmT59w8P6UZ4HXWm5dJaGAN4k7yjOEC6GJtwNpdoAB7pO/MQO+ujcD4Xevicv8SgkT+Hxrm1ni95TFuF5QEUn3sCTR6Y/EPHWC+R920p+GUfOusqQIbJU3EYdtQzUjzI9F1J+iV6PaX1EfMUGeBXLaN1ltmbkUIYe4a/CqEUJGlrFz949WPnROF4cxMsrIBsHuC43qSAFrbKj82nokcRhcOWEh4HAun8i6d52BZQTqMrDwBBjXbUD3VsEgbV7gDkMxRFzWTRyLSpLnmY2IBsSwgbqDoDtPlULsTB2HfWYjQ1l++0hYOX2gpGmo3FDDjCYY0Ejr+VBfaBS/EEzRzJMVDfsxz1NcMlHpkBBx41la5D3VlZTXNM8Wma0D9a2f+U/5fKjejdgZDE6Pz7iKkw1kFTpvofL8miOA2oDL4/ETSFRhksOmo5qphK4ytqDWIPL9JBfwRS5cPc+g89fxqydHsMMrHuK17xDCyzabx8qY9GbH7RfBT8aDjGhrgBtCo/SK7qrXF2xxH4TPjOH+jDD186q9gNnkk7cz7qvuMt5rJB5VULlkKdQYPlPxpalWbSfLzATWLw761IimL/tK8Zv86XPh0IjIsz7Ua0x4nfLQESPM925iNKrHG1uqQhPaPaK/d5A+Y18vOmRimuLQ0qf/wDOqjMXjX42R8oTimJtLKqiMw+6Mo8+80mfedNdYAj4RW9jDM5AXWdvH31OE6q4qusiRI2kHQju2nWKcIc65SrGMp2bqoL9oQGXY8u78/0pwqh7fWagEjOV3tXl0Dx9lxr5zqNKDvWAoca6kgGNzCk/MUHZuMpJUwfAkSNzrO2m3jX1F0SDpp11+VuvTzEEWOvW7w9xZS4hhIAafHT36bbmswN8LMmhnuHw9NKmw0DU+Q9aJ95hcHdEqfG4oEaGiMBeW20tOV7ZUEfezK0HvEz6Cg7wmY3FQJdYCAdO4ifXXyrsZCuO74ujMZiECi3bJKglix3ZjA25AQNNdqh4dZUtL+yN/wDTnUD7d+22gHeIjU/nWj7IGXnOcGdIhl0/5gKBUki3DgjUyA66HxROctDINCI3EaDY94p9wjj0gLd8Icc/3hyOh18KU4y7195u4ABfBVAVfMwBqdTzobEYfLHI0am17BmZolsQynXtUF9fHkuhWyGAIIIrbJMVV+D8VuQB1QMEAnNlEeIO3fIIrptjgHZBK9qBu2bunZRPP/OitxIdqFJq/Snt+14jxBHpKrBXWDR9kg7c6sNzoYHEpeI81n4iI91DHolibfshXE8nj4NFbbXZvSlb6diA2cs8L+iqnEEg14+Pe/7USgyiBFNuK8OuJJe2VHeVMe/akuGAVCe+smBebIbGEwC3v6CbG6gv3cp+FA4q/wBqKlxO/rQOJWXNTaeJc97jvXpP6NjGMGpH53rfr/E+6sqDJXtGg7z5rmdv+jfJWvAvy5GmGCtEMcoJ56a7Uj4Zcns1dOH8Ws5UVbnVsu/ZzBjEHX+vftQMdi+zYHBsn04xJ4W8l99NwDjUe0ugevD3Wq4JiQWUxy5TrsCfdRGHxtiyOyjFtiEQnUbguZnXxoe5xbDKAOuLAfUTNccA76IOxy0AGh3oK3xoC4xChFzBYuFbbAAEQiP9bUEzAhfGvPVcRVrGTNuQ3cV6ihRpUhDU3HFus2UooIzMy6BdZkzM7QBBoTiuMCJCI3bYL1hQAgtsQCZ+A0ppgW66Lh1Qfs101++R4/Kg+lWBdrZNswwyss7dYhzLPgdvWky4FwBEdbeHkINk8wDYqvexBksts6DsyQQBqFBEaT4661UMPxM3etzqpusrgseSspBYADWNPIa7AxZHxblYGHyttBKaMIUAkPJggaZdYHnVDxEq8gkMp3GhBFXMFSY7MCN239/ykvqD3NALT8X90dhMStl1uaSpXSZIZMshrciZgrO0E84o7pJxO1fuJcRFGUCFQkqAObMwHanltAHiKVpxBG/a2iT9pGCHlyKnu2EDwqTE8Qs5Qtu04A17TggttmIVQTp96PCq/aH7YsVByNs7aPBR3r/Yk+MGTLMdSY5QSSfQV5hOFXLiF0AYbkTBHLyHr3ih7INx1B1LELtsCY7IGmncKtWG+iGW4hkFQrJC3GkjWDKXTtusjaZmNT/rsWHW+5VW9g3XU23A74kehiDUdpW2AP57+6ug8UwYBh71ye3lAZkLqoUEr2mAhiO6YaFjWqocFJeRCqxUCNNDEx50aixz3QFh7mtbmO+OaVuGH1Y8hXi2p2DH+Gnf+zcqFxy3EbgeB591N+oVVS2DcF5l7Jj6MkSdXzh9QrbD30WpRc10O5IDsQ3IXt2GD6+xVXxHD3VMzws7AtLEd4jl4+evKoMPeOUqDBIg8pWZj3wfQd1N8YJLhBmYe0Wyg7TKWwTlUiO2Z3Hsk0iuLG+/x7t+6gPGXxRaTi+ZsicHiurcPAJ8dtdDI5it8djDcdmAyBoACkkaaQeZ2qPBYpVYF7eePGJ85BB91OuF2f1gxh8KFywS7NmURz0UEnwmsGrAjYjCnmggd7rlv2eqZ9H8AEt4m46lEKmA5E6Anu5Aj491Xa/jcQt5esIVu0FAJFthzlVOrDTUypzEwDvXuj3DuH3sNd6+4BeXNrcgsTGigtqDuNDpA0EzTbo3x3Otq3iMO10W2izfDAH+LONCNpBlt4mSfqZguO0oFdmcN3Cd15EC5062wrdwPGSLh6trYEntFSGg6MuVjAO3jI7opouLBjxqvcZVwoCMiwSzWkIYmBOpgbToIAk7bGteCcVV58IrFV3eTWFYDTgbOvzqrfa+FJ+LdE8Lek5Orb7Vvs6+K+yfdRlrFCiEvisGCIK25s6rlXSTolew0uPpLQ+so1Andl5eYkeVU+6dWNfQtxwa5Z0+6PJbm/ZWAx7aDYffA5DvG3PvobKbWOttWaslsjYqVlrKIy1lMypyibE5V01LTp4Db4z/AIa3w+KeMwUx3iSPL4UDxLHl4zFTAAAUZRCjKOW3ZgacuQIFA2r7ToYA0BbWNdht+FAeyWwqlN0OEK1/7VuBRkuEaiVBgN2lYwQey5yxvBzGYJkrcJi20tBmh2IM5gxEnNm7UE5dCCCQSPQaxxV1JVitwHQhtQwiCCDMH7w18Y2j4quQpdtMSp1XN7SkQGRu8gRB5qRSjKIacsa6Hx2bPL9CG3VP8t2vDbtXcuAYUpaUsO1Gg7h41Nj10Kn61Vn9G/GuttlSSeepk/H3elNOkuJKx4kD315ipTcKpYdZVimZM7NVTGxNuXz3bdtw8EG4Awy9kyDqJAnug99JOOcGRyXtnU9xkHTUgjerLg1Av4klVaXJg+Nq0dNNNZoixhwbjabTp+fOqDMQaRzN3dBEqUxUZDtFSujnRJsQ5UnKB7zVo4/0Is2cG/VibuZIc7+0AR4CDUnBruTFrl5n8atnSpx+rue4r8CDWq2LrGuy9pFuaVGGptaWgbDxXIbfR51OW6hEhsvKWynLBH3stG2sXjLdtzbvZkRnHaJVwFXMpzCJBSDvzrsF7hq3LZVhuPUeI7jXKrlk2rt2y437BGgGZRlAA2Aa0QB+6vNq9E0yoNRsXCa46LgRgO3kOQRGYkKxGbNAVmAOqyO0J7lGDi45ZULBzJUFcwY+0QpOxM6DVSDOhBqPhGNGuHumGQ6MdivyHeDtJI5yZLmCulwXU2yXCBkXM7sRJOWQCAoJn2jAUGmqFV1N2Zuu1O4/B4KrgBUpyL3AuQ47Du4GAbEE3DiMbagHrAbSDfPlLHuCqpMnw3O0RJEtkC5ldjkYFmjKhgFiQmZlOWASsqQTJoDE8LdnLK1y4EYr9IrIVMB82V2Jtg5m5/VJnWKzF8QFlOrQ5naABuCRsQPsjXXmRA2JG6mJdUqZn8Ah/T/p2EZgXVKoJafEtJIkAWNtoiTcyTGiXiOMvM1xVjq1uFRsAQHypIGrEaa8ooLFYWWJ1MwZOp1Uc/OnaYGTbsiS3ZLbzoxyiYlSzmBt7A766DheiSC2oIkgCT40Co7eptBkBUr9HPB0udc1xcwBVQCOe/4irni8MMAQHt5Euxl0+t2iQe7Yn0buoXgbph0OT2+udgBuwBKctuzz2BgmdqeYwHHKiXF6i0pzZFuF3J7RnOR2RNx5GsyNQBFKEAkkqgM7QA0bNVzVsPZvXM4AMoxMaz7ML6kn3V0HhWHujDW0Fm43YUNA6o67t241Ekx4RTFL+EwSkoiW5O4WXdjyEAs7HuEmsbieLuDMtsWUOzX2IJ8RaTWP3mU6bUw1+4JV9LY4/KB47eu28OXNtQxMfahz9YS0CTuBzjxkHhVhCevsuGVhDrMlXXQ/jNTcbuXervWbzK75QwKoUBiCvZZmPtKw3qvdIOjmLwB/WrJDAftMsww551O37wkDmRNdqsJM7I8l9hnNaCAbz5jrZ5K628QRUicRiqA/TURbhSzPsqiT7u+iOMcWJsm4jRAVxHMaNHkRy8aXghOjKVfDxYRqarXEuNLca4oGaBGmo+9m5Acte41RrfHLzN1TXMgJLBjvkmQFc6ARPa5Qdoo3D49FtFEGWJBHjzMnUz31osMSVmnUZmhuqG6kfYH+M/0rKH/WvGsrUoX9PR/1HkPhVm5c1922ndR5tgrklhBXNABGWBlPeDq3h5c9sKti7o82zGjLqk67zqNY3Md7AV5i8CbeVlIgwdCSDtoTtHqfWuvE6IdJ2XVeYvCBUR8hUNqhzZgecMPqkiaiVicyToST6hSJ9fwFaM7lQpzFBsNIHP2qmRiZYtJ5nxzSQO8dqhw4N73vy1Rm5XP7vtz0gfgbk7/R3xI2sRknQ7fn8710rpPqqt3FT8a4tgb2S+jDkw+cV2XGXBcwk9y/LWon1OnFdlQbVVwL5p5dxPlqFWrWKdcVfCpcYZLc9WLZImVPt947u6jsBij1rhgykxo+XNsInLp7qRcOxR/XX7eQPZAJ05ZW5g9xoriF/JfDZ8+dAZ0klZkdmBMZffQ30QTG3KN+wDbomGVCCZ0ko3AJkxIuMDlAkHvJ21p3x0lsHdJ5qSPcaql3FNoyz7TEtplZSTlAIbUQVAWOzHKKsOPvk4RgfsNQ6lMh7XdWXwqZgbK9YQyinvA+VVfpz0Y69ettD6RQJXYuo1AB5ON1P+osHBbk2bX7ifyijnr0qglfPmMQXBDa3V0DoQLkZoIuISNROw7o0gxDb4niMOGtsge20rlupKyrEaCdCCp020GhgGmiMS2JnmmIPkRiAZ9M000x/V5b3WWTfFu6zZJZSc0ktoJ0LidOc+NG8UnvHLrYqvd4zfup1du3btossVtroORZgSe/u599b4e4tiWIJvH610gAbjMO1mYdncD3GKdJeRsNcNvDdQuR+ZOYza1k68o/1rOI2zkfY/Rj0h8Vr8T7uVabcysOMDLFhs6srh0H6MlFF67qzQw23I9qBoNDAA0A9IsvG8V1NlmEZohZ+0Rp6DUnwBqbgf8AZ7E79Vb/AJFqn/pCx827sHRewPOR1h89Mvp40BxTdNs2VM4j0kthGs2CwAWDcgy3KZkEDnpM+tH9EcdcS/ct9cLlkqWEMTEGJgk5SRrE8+cGK/jOMLdsW7K2QGAy9ld+0G0gauYAzSdJgAkmmHDMN1FrL/vLrANHKTED90SfQ11wEZRqVxjnFxqO0Fz8LofABbLtfuHNdZSySDlS1MdkxAmNeZMzICwl4/06uu5tYRQSujXWiARz7p+WuhGtb9JuJmzg2RcwZoXXNI21AIGxZDpOhoFuowWDK5VZ1gOQwJ60g5kYRIGoOhG420NMAAAAadfCE1hLzmOlyRfkN97DnwSe9i8QHf8AWLvWMVgifZIk5d9JzExptQWC4hisG2a3dNxPrW2kgg7ggzy/JEild3HXXgxltyVAHZUHKdAogbeB86GweK1XPJQESBvHPLOxidNqICw+yBleNfJMeNWUUpiLA+hc5lB3SfatnWYDSB6+BPtni4a0bRG05Z5Trv5k/DuoTG3MvW21/Zs2YDcgnaDGvs7igW7PLtR6jz7uenjr3Us9kJplQgKZLLMoJMKukzqOcDl5d9MkxGHtp2S1xtyNQBO+vf5j1oDBMLjKrMABJJJCllg5gGOzEaAaDaawP1TuLbmCYDKdeyZUhgBzG4+RrRErAJGiL/2ov/sL7v8AOvKXwO8++sr6F9mKjwftDzPyprwv9k/94f5DWVlDOqIPtHE+gSJ9zTSx7A8h/wBtZWUOpoi0PuKCu+1XZcJ/ZG/dPyrKypP1XRnH4VLA6u5e6pnB/wC32PI/9G5R3TL9thPNvnarKyhP/vs/49nJj/E/9D1alOG5/wB4v4Vccd/Zm/dasrK7if7jea7S0Vz4D+xtf3afyimT17WVbUUriL74j9zH/wDVSjk/br/e/wD8Lde1lF2JN2h5+636Rf77+6X+ehOK+xc/cb+bF17WVpiENF1vhX7Gz/dp/KK5f0y/Zn9+5/Oa8rKA/UKjR0PD3VT6JftfQ/I0yw/+4/vW/luVlZXW/wBzy91l/wDYPA+yY9Jf2WC/v/xatv0ifsv+K38qV5WU837DwSlf+4f+z7qoj9lh/O9QOF/FPnWVlBp7Oa3V+48B6Jtwz9rb8h8jSe19b886ysrlRcpo3Afsrvkn8woM8vMVlZXXaDh7lc3qesrKyuL5f//Z','https://images.nightcafe.studio//assets/tdraw-girl.jpg?tr=w-1200,c-at_max','https://www.searchenginejournal.com/wp-content/uploads/2022/06/image-search-1600-x-840-px-62c6dc4ff1eee-sej.png', 'https://www.searchenginejournal.com/wp-content/uploads/2022/06/image-search-1600-x-840-px-62c6dc4ff1eee-sej.png', 'https://www.searchenginejournal.com/wp-content/uploads/2022/06/image-search-1600-x-840-px-62c6dc4ff1eee-sej.png', 'https://www.searchenginejournal.com/wp-content/uploads/2022/06/image-search-1600-x-840-px-62c6dc4ff1eee-sej.png']})