content stringlengths 1 1.04M | input_ids listlengths 1 774k | ratio_char_token float64 0.38 22.9 | token_count int64 1 774k |
|---|---|---|---|
# Bite 38. Using ElementTree to parse XML
import xml.etree.ElementTree as ET
# from OMDB
xmlstring = '''<?xml version="1.0" encoding="UTF-8"?>
<root response="True">
<movie title="The Prestige" year="2006" rated="PG-13" released="20 Oct 2006" runtime="130 min" genre="Drama, Mystery, Sci-Fi" director="Christopher Nolan" />
<movie title="The Dark Knight" year="2008" rated="PG-13" released="18 Jul 2008" runtime="152 min" genre="Action, Crime, Drama" director="Christopher Nolan" />
<movie title="The Dark Knight Rises" year="2012" rated="PG-13" released="20 Jul 2012" runtime="164 min" genre="Action, Thriller" director="Christopher Nolan" />
<movie title="Dunkirk" year="2017" rated="PG-13" released="21 Jul 2017" runtime="106 min" genre="Action, Drama, History" director="Christopher Nolan" />
<movie title="Interstellar" year="2014" rated="PG-13" released="07 Nov 2014" runtime="169 min" genre="Adventure, Drama, Sci-Fi" director="Christopher Nolan"/>
</root>''' # noqa E501
def get_tree():
"""You probably want to use ET.fromstring"""
root = ET.fromstring(xmlstring)
return ET.ElementTree(root)
def get_movies():
"""Call get_tree and retrieve all movie titles, return a list or generator"""
tree = get_tree()
movie_list = [movie.get("title") for movie in tree.getroot().findall("movie")]
return movie_list
def get_movie_longest_runtime():
"""Call get_tree again and return the movie with the longest runtime in minutes,
for latter consider adding a _get_runtime helper"""
tree = get_tree()
movie_runtimes = [(movie.get("title"), movie.get("runtime")) for movie in tree.getroot().findall("movie")]
# one way
result = sorted(movie_runtimes, key=lambda movie_runtimes: movie_runtimes[1], reverse = True)[0][0]
return result
# another way
# result = max(movie_runtimes, key=lambda movie_runtimes: movie_runtimes[1])[0]
# return result
# tests
# import xml.etree.ElementTree as ET
# from nolan import get_tree, get_movies, get_movie_longest_runtime
| [
2,
44540,
4353,
13,
8554,
11703,
27660,
284,
21136,
23735,
198,
198,
11748,
35555,
13,
316,
631,
13,
20180,
27660,
355,
12152,
198,
198,
2,
422,
32468,
11012,
198,
19875,
8841,
796,
705,
7061,
47934,
19875,
2196,
2625,
16,
13,
15,
1,
... | 3.068862 | 668 |
"""
Simple Flask web site
"""
# import flask
# from flask import render_template
# from flask import request
# from flask import url_for
# from flask import jsonify # For AJAX transactions
import json
import logging
import sys
# Our own modules
from letterbag import LetterBag
import find
###
# Globals
###
# app = flask.Flask(__name__)
import CONFIG
####
# Word list is global data, read once at
# beginning of execution
####
wordsfile = open(CONFIG.DICT)
WORDS = [ line.strip() for line in wordsfile ]
###
# Pages
###
# @app.route("/")
# @app.route("/index")
# def index():
# return flask.render_template('scrabble.html')
# ###############
# # AJAX request handlers
# # These return JSON, rather than rendering pages.
# ###############
# @app.route("/_check")
# def _check():
# tray = request.args.get("tray", "", type=str)
# pattern = request.args.get("pattern", "XXX", type=str)
# matches = find.search(WORDS, pattern, tray)
# ### Matches returns a list of words
# return jsonify(result={ "words": " ".join(matches) })
#############
# We want to profile just the 'find' functionality on a
# number of test cases. I'll generate seven trays and
# patterns from an actual scrabble bag, excluding blanks.
# I get 14 by reading columns as well as rows.
#
trays = ["yetosuk", "ieenaar", "pnosoii", "zrjrbut",
"dlhdoai", "mawytac", "cerauis", "myipzdc",
"aeenrle", "wteojhr", "yonsrda", "tsaobou",
"auaiuai", "ckritis" ]
# I have a couple pictures of scrabble boards from actual
# games, from which I'll make some patterns
#
boardwords = [ "wham", "air", "vipers", "tie", "pica", "eel",
"sensors", "equal", "pram", "spade", "ide",
"of", "flit", "tin", "keg", "yo", "radio",
"bough", "jilt", "sub", "toucan", "candor",
"fie", "zee", "go", "vixen", "giant", "town",
"be", "ere", "ye", "town" ]
# Now for each word on the board, we look for ways to prefix it,
# ways to suffix it, and ways to cross it, with each hand. That should
# take a while!
#
# Takes *too* long. I'll limit number of trays and words to speed it
# up to about 15 seconds, which should be sufficient for profiling
TRAYLIMIT = 5
WORDLIMIT = 10
for tray in trays[:TRAYLIMIT]:
print("\nTray: {}".format(tray))
for word in boardwords[:WORDLIMIT]:
prefixed = find.search(WORDS, "_"+word, tray)
if len(prefixed) > 0:
print("_{} => {}".format(word, prefixed))
suffixed = find.search(WORDS, word+"_", tray)
if len(suffixed) > 0:
print("{}_ => {}".format(word, suffixed))
| [
37811,
198,
26437,
46947,
3992,
2524,
220,
198,
37811,
198,
198,
2,
1330,
42903,
198,
2,
422,
42903,
1330,
8543,
62,
28243,
198,
2,
422,
42903,
1330,
2581,
198,
2,
422,
42903,
1330,
19016,
62,
1640,
198,
2,
422,
42903,
1330,
33918,
... | 2.595214 | 1,003 |
#####################################################################
# Task 3 : run an improved live invisibility cloak demo using:
# (a) a convex hull operation around the foreground
# (b) feathered blenidng for compositing
#####################################################################
import cv2
import numpy as np
#####################################################################
# define the range of hues to detect - set automatically using mouse
lower_green = np.uint8(np.array([255, 0, 0]))
upper_green = np.uint8(np.array([255, 255, 255]))
#####################################################################
# mouse callback function - activated on any mouse event (click, movement)
# displays and sets Hue range based on right click location
#####################################################################
# define video capture with access to camera 0
camera = cv2.VideoCapture(0)
# define display window
window_name = "Live Camera Input with Invisibility Cloaking"
cv2.namedWindow(window_name, cv2.WINDOW_AUTOSIZE)
# set the mouse call back function that will be called every time
# the mouse is clicked inside the display window
cv2.setMouseCallback(window_name, mouse_callback)
#####################################################################
# first, take an image of the background image
_, background = camera.read()
height, width, _ = background.shape
cv2.imshow("Current Background", background)
#####################################################################
keep_processing = True
while (keep_processing):
# read an image from the camera
_, image = camera.read()
# convert the RGB images to HSV
image_hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
# create a foreground mask that identifies the pixels in the range of hues
foreground_mask = cv2.inRange(image_hsv, lower_green, upper_green)
# perform morphological opening and dilation on the foreground mask
foreground_mask_morphed = cv2.morphologyEx(foreground_mask,
cv2.MORPH_OPEN,
np.ones((3, 3), np.uint8),
iterations=5)
foreground_mask_morphed = cv2.morphologyEx(foreground_mask_morphed,
cv2.MORPH_DILATE,
np.ones((3, 3), np.uint8),
iterations=5)
# extract the set of contours around the foreground mask and then the
# convex hull around that set of contours. Update the foreground mask with
# the convex hull of all the pixels in the region
contours, _ = cv2.findContours(foreground_mask_morphed,
cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
if (len(contours) > 0):
hull = cv2.convexHull(np.vstack(list(contours[i]
for i in range(len(contours)))))
cv2.fillPoly(foreground_mask_morphed, [hull], (255, 255, 255))
# logically invert the foreground mask to get the background mask via NOT
background_mask = cv2.bitwise_not(foreground_mask_morphed)
# cut out the sub-part of the stored background we need using logical AND
cloaking_fill = cv2.bitwise_and(background, background,
mask=foreground_mask_morphed)
# construct 3-channel RGB feathered background mask for blending
foreground_mask_feathered = cv2.blur(foreground_mask_morphed,
(15, 15)) / 255.0
background_mask_feathered = cv2.blur(background_mask, (15, 15)) / 255.0
background_mask_feathered = cv2.merge([background_mask_feathered,
background_mask_feathered,
background_mask_feathered])
foreground_mask_feathered = cv2.merge([foreground_mask_feathered,
foreground_mask_feathered,
foreground_mask_feathered])
# combine current camera image with cloaked region via feathered blending
cloaked_image = ((background_mask_feathered * image) +
(foreground_mask_feathered * background)).astype('uint8')
# display image with cloaking present
cv2.imshow(window_name, cloaked_image)
# start the event loop - if user presses "x" then exit
# wait 40ms for a key press from the user (i.e. 1000ms / 25 fps = 40 ms)
key = cv2.waitKey(40) & 0xFF
if (key == ord('x')):
keep_processing = False
# - if user presses space then reset background
elif (key == ord(' ')):
print("\n -- reset of background image.")
_, background = camera.read()
cv2.imshow("Current Background", background)
#####################################################################
# Author : Toby Breckon
# Copyright (c) 2022 Dept Computer Science, Durham University, UK
#####################################################################
| [
29113,
29113,
4242,
2,
198,
198,
2,
15941,
513,
1058,
1057,
281,
6596,
2107,
44837,
2247,
24117,
13605,
1262,
25,
198,
2,
220,
220,
220,
220,
220,
220,
220,
220,
220,
357,
64,
8,
257,
24748,
87,
23644,
4905,
1088,
262,
36282,
198,
... | 2.589782 | 1,977 |
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import copy
import uuid
from glanceclient import exc as glance_exceptions
import mock
import mox
from neutronclient.v2_0 import client as neutronclient
import six
from heat.common import exception
from heat.common import template_format
from heat.engine.clients.os import cinder
from heat.engine.clients.os import glance
from heat.engine.clients.os import neutron
from heat.engine.clients.os import nova
from heat.engine import environment
from heat.engine import resource
from heat.engine.resources.aws.ec2 import instance as instances
from heat.engine import scheduler
from heat.engine import stack as parser
from heat.engine import template
from heat.tests import common
from heat.tests.nova import fakes as fakes_nova
from heat.tests import utils
wp_template = '''
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "WordPress",
"Parameters" : {
"KeyName" : {
"Description" : "KeyName",
"Type" : "String",
"Default" : "test"
}
},
"Resources" : {
"WebServer": {
"Type": "AWS::EC2::Instance",
"Properties": {
"ImageId" : "F17-x86_64-gold",
"InstanceType" : "m1.large",
"KeyName" : "test",
"NovaSchedulerHints" : [{"Key": "foo", "Value": "spam"},
{"Key": "bar", "Value": "eggs"},
{"Key": "foo", "Value": "ham"},
{"Key": "foo", "Value": "baz"}],
"UserData" : "wordpress",
"BlockDeviceMappings": [
{
"DeviceName": "vdb",
"Ebs": {"SnapshotId": "9ef5496e-7426-446a-bbc8-01f84d9c9972",
"DeleteOnTermination": "True"}
}]
}
}
}
}
'''
| [
2,
198,
2,
220,
220,
220,
49962,
739,
262,
24843,
13789,
11,
10628,
362,
13,
15,
357,
1169,
366,
34156,
15341,
345,
743,
198,
2,
220,
220,
220,
407,
779,
428,
2393,
2845,
287,
11846,
351,
262,
13789,
13,
921,
743,
7330,
198,
2,
... | 2.469149 | 940 |
import heapq
INF = 10**10
V, E, r = map(int,input().split())
adj = [[] for i in range(V)]
for e in range(E):
s, t, d = map(int,input().split())
adj[s].append((t,d))
dists = [INF for i in range(V)]
dists[r] = 0
pq = [(0, r)]
while(pq):
d, node = heapq.heappop(pq)
if (d > dists[node]):#探索の対象にする必要があるか確認
continue
for next, cost in adj[node]:
if d + cost < dists[next]:
dists[next] = d + cost
heapq.heappush(pq, (dists[next],next))
for d in dists:
if d == INF:
print ('INF')
else:
print (d) | [
11748,
24575,
80,
198,
1268,
37,
796,
838,
1174,
940,
198,
198,
53,
11,
412,
11,
374,
796,
3975,
7,
600,
11,
15414,
22446,
35312,
28955,
198,
41255,
796,
16410,
60,
329,
1312,
287,
2837,
7,
53,
15437,
198,
198,
1640,
304,
287,
283... | 1.81388 | 317 |
from canoser import Struct, BytesT
from libra.account_address import Address
from libra.crypto.x25519 import X25519_PUBLIC_KEY_LENGTH
Multiaddr = BytesT()
class DiscoveryInfo(Struct):
"""
# A validator's discovery information, which describes how to dial the
# validator's node and full nodes.
#
# Other validators will use the `validator_network_address` to dial the this
# validator and only accept inbound connections from this validator if it's
# authenticated to `validator_network_identity_pubkey`.
#
# In contrast, other full nodes and clients will use the
# `fullnodes_network_identity_pubkey` and `fullnodes_network_address` fields
# respectively to contact this validator.
"""
_fields = [
# The validator's account address.
("account_address", Address),
# This static pubkey is used in the connection handshake to authenticate
# this particular validator.
("validator_network_identity_pubkey", BytesT(X25519_PUBLIC_KEY_LENGTH)),
# Other validators can dial this validator at this multiaddress.
("validator_network_address", Multiaddr),
# This static pubkey is used in the connection handshake to authenticate
# this validator's full nodes.
("fullnodes_network_identity_pubkey", BytesT(X25519_PUBLIC_KEY_LENGTH)),
# Other full nodes and clients can dial this validator's full nodes at this
# multiaddress.
("fullnodes_network_address", Multiaddr)
]
| [
6738,
460,
13416,
1330,
32112,
11,
2750,
4879,
51,
201,
198,
6738,
9195,
430,
13,
23317,
62,
21975,
1330,
17917,
201,
198,
6738,
9195,
430,
13,
29609,
78,
13,
87,
13381,
1129,
1330,
1395,
13381,
1129,
62,
5105,
32936,
62,
20373,
62,
... | 2.808664 | 554 |
# Generated by Django 2.2.24 on 2021-07-19 08:03
from django.db import migrations, models
| [
2,
2980,
515,
416,
37770,
362,
13,
17,
13,
1731,
319,
33448,
12,
2998,
12,
1129,
8487,
25,
3070,
198,
198,
6738,
42625,
14208,
13,
9945,
1330,
15720,
602,
11,
4981,
628
] | 2.875 | 32 |
# Copyright (C) 2019 The Raphielscape Company LLC.
#
# Licensed under the Raphielscape Public License, Version 1.c (the "License");
# you may not use this file except in compliance with the License.
#
# You can find misc modules, which dont fit in anything xD
""" Userbot module for other small commands. """
from random import randint
from time import sleep
from os import execl
import sys
import io
import sys
import json
from base64 import b64decode
import io
from userbot import BOTLOG, BOTLOG_CHATID, CMD_HELP, bot
from userbot.events import register
from userbot.utils import time_formatter
###################################################################################
# Blobs (mp3 files from the Internet Archive, Windows XP shutdown/startup sounds) #
###################################################################################
SHUTDOWN = io.BytesIO(b64decode(b"SUQzBAAAAAAAFlRFTkMAAAAMAAADTGF2ZjUyLjE2LjD/+5BkAA/wAABpAAAACAAADSAAAAEAAAGkAAAAIAAANIAAAARMQU1FMy45OC4yVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVMQU1FMy45OC4yVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVX/+5Jkvo/wAABpAAAACAAADSAAAAEAAAGkAAAAIAAANIAAAARVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWFfH/lQ8qCsLAW9MNEeEuRKdAmCjogMUYG27sR2enKSA5HSUnMoxjDFmflF6Vz9Shirvxydjc++kMwe476TtvDdacp7FWX1Ij+FNHhyRX8DTw30KFjNxNK/dMMD1CIdpvVXxmRqdHOtsESA2uzTfHIsMcZ43quHbUNXzqxfVw/z8//uSZP+P8AAAaQAAAAgAAA0gAAABAAABpAAAACAAADSAAAAEcWeEciwn1XeA8y/fx4cijuxxlZEwwPFwqIbY6T7uJdscTTaVZFc046ZH7Y4Yo8MNBFjL4ws+9J9dKh5DkrHYHCHPaJekseBVnhv5Il5NP9zqCurJCJszLw6BIaiWuJjJPechVnDJmrDgoE/aXgJCkS0xqIjpXLZw6S1QkFuBarJBYbXHg4DpU7fhP/x9OT32xQNaYQBcIMJWTP4afZ0WtoYvnW5og6IKgXa2XxGJ9zL4nRMEij4Dezpw7zyEzXTjZ5NHRDQThlZ2xkXajXDgyayn3yseN7mr4U14EVXtjiqGOE4X98apeBVjc2BxnncE++VmpJn8TWHkqvn8NtOt8yN7s5HU8dSKjWb0b1HBc8q9zgabFQ8Y3I/EIljRY91///WuCYbWQICA6GACBgPgmKwuCYKGZPMAJCx7JJ5oaGkvJZf1bDRA5J9xoS3GjT9vTSPwxiFXscsnbKe9C4mGMprkKlkvt73732/jueOfYx8UnbJcf4ILFBOKgwJwQP/7kmT/j/AAAGkAAAAIAAANIAAAARotsNwH4e3LObZbQMY9uMai4EJ3nJci5ihviIaUb9PKFN06fCDjgCgZhBcYAAEAQCHPECdqZGIRXJO9FO6i7qJnU5Fd6nSQi+ujM9rvYjTkY6FFHLIBZmpI0LDF1g+FgTB8c4gGFvmCjoffy+mLAnQXA8QOdlC6ggACAABQIBAGHRYE0AIIWSaQJ5vVsmXjyZtGQKB4GA5mhAHHTSbDZBrBkorl0wCXjTCOPDus7PQzDYFeI11gjvUGOW+42NKZzOnO5AE28nDDyPMkKwwCIjEI3n6/3jRYtEIJCA0EAgySBAsDTAIIApHt97uuacLQBGoQUwEDyzhiwKggIEgBR+bjbl///oTCAJGFgkHAhFN+3LdlkinqCTa5+//+QMX8UsV+1iQPfKp6UQ5QW/5/I33LDTsRi9eoW0mrNutav9vz/P//3v////90lqtnzf/l+H2TZlf//pcAAAAADAgECwWGYdYAl9tCk1mxEYwY+F/FDNREy4mAAuaPBW9GZCAVBTEoMyMudx/DAgcFH5r/+5Jk7oADgTvErSVgBFcmSGChlAAb6S8nuc4AAs8l5bc3sADLGfQMRTsoMuBAxfDAM2pEBwSWesWOeIQNDNMgWBDLQxH5T4VAbH/h6GhhgUqx1ZIghdx/X6puYYc/1YVcgoXWo7z00kxEpV3f9///3WXG4EVSQu0uOeVefpu3qfWX5fjy9e58znOc/Lv6/W//8/7///7/cUzqU/P/nMcK9hUBFuXCG2ulu2yCaFwiMS6VpMFLYM2A6kUkuniTOUSGiHwgWAQBjkA0YAAsRDRw9sgIzBGDiMjpqcIE5ux84WzpoHoCDhgHysTpMlVGTrvN0L6lKMg90gpFTY+mko2Lyka1aq1pF8bJnT9JlLUgyK60a0JsXnehPpLN1OykV1KVWymdKhp2PUETiCIPttPiYKBak2wvh6iM1gJcXiIMFgRwsvEq5MjOjeAwDQEREXCRVNZSOOrRrW6bLRYXANoio9KMjA7SLLpqWkr6y+VS6mkbLWgtKip7NW2cItvql5Dn0i7wgeOB0+4FyjlXOvRNf+OAgSl9bcw4cMbmXNAfKAmA//uSZIAMRHxN0R9ioAZgxjpz5lAAk2kjNm1xC8F6IapcmS13AAhcuGC3dLlA4OhYQAUwoGVKSQBGAQQNBwmAxigaG+S6fcGY0RhobsZa8u6BY/CHJgR3ovSRSOXKWI1HiAoQV04rWoGg6JYz01SzsUa/Ff2IIenZLNAyj5+3lS75FBUE5odf7MOMnyOHaltQmphml4+Y2PdEq0b+L56IeJAUJg6B4OpCpMwebT9GnrwAsbUAdWvQQEq5iIWTJ5jNR46Xi4cATAKgVnTPJt6T7oLWxwV42ADG4ljcLh5PqD+QpwkpH2MOH6VKg4HT6LtTuH1/LPm4YkODvUV//HX8f8/3+2LWfMaz22aM3slYAAbUAHhU0c6MWCTFjI9QNEIMYSVAEWFhdc4GAUXQcDUGAPEADgqAsGAHGAYAMYDAABgBARmAkCOYNac5i8A8mBKBoYFwFawDSTAAALYC687DT1q02Kdf1exNtmsw2nDL1hOojViqJ5JTwTtyWyW8QikcM0mY2DdI765mzLBZX5bADZerNwj82dKVtnqvJ1U2b31R2f/7kmRKDATdQEubfkriYgaKQz6LXNJQ6SgueSuBNBSqnGm9Ns6pvQq/QlvQSV1oD5OH8zElRhxQFCrnStHdRcpGpoS4jEDCuwFIpPEFMta9mrdzjnpmUzc2PVT9vUP/77vYIwKDwm84sbG5YarW9YpINU2aaHXAfDV5KNtGPbEsTNfHlRcygheKm29o7ygYYVC5lIWGAhoY2VRx4NgIFA0HOQYHGAhDIQZQCOzAWAUDgAy5oCAeBIAYCAWUiYBwABgTAhmOsqaZWoXJgbAQGAmAeEAYF35aWohyISZpCesMZIkYRd/4XflBAB0p8yagQDDIkHHQ4wB6JJevJG81JXPRSKJTOntQj1MlHpBnLa/p//YqndL/936P1mA3N4dgFA+0tKkwD0DzBsSKiyZTPJuiT9ZwlQabFlmCatWkYJ3418/iKRSgMNNsTmoloetVouR5G///6+f5aONPRIM07FNaD3363p6k/Zkp1Kq0KgAbAwQdMABQKZg2IOyCCghLAAXHJjRDBQQlBTBQEUt5YqmRAEw8FA8YHAaYciIa0VINnmD/+5JkGgwD4DnLk31C4lNlysoZ6U2OhQs0bfTLiSwTqEz9HSgh9izqu/D7twHMP7RQZH7a1qlrO92ozqUiwWgSEq4PGyKEOrC1reYsi78QsS1f1UxMfIn5Nrx4+OZFri/ir5JW+KUtOtNgd2kMrgGq7HAGrCgCKZlGTQ1nLJDZr+kYhIq5t///2q839/+vgGgiMAGISO0JMgRn8qP///iIQnuvQEwm24o19YhGGbnjN/FVXLF3pbRvLB88kwEBsmAg3KASAwcCgANFUA5YBVClSwsiFFJKbM9QUehxnz2869kOIBCwwTuIwXFAkAdFCTwBOQqa1yZq/ae3drOjt5tIh+ydMGP0W53k0z0+/ptwczsZLmxmf5LNt4R6XdGv1oF/zXpf5WNnK9f9xro98P7oYUz3AiL28BRC8XRZKtTM6sY1NWykGN3F8qaalK7gRwCHUZpOZf3/ZB27V6gtFiiPLmTxUhzFbW9xwEkLkhuOEqlVCDiKXKXPJ6qfavnxagECVACYuNJBTBqAyiiBZypBIFayJjgxtVAMBrwtDZy/zYXE//uSZBGMA7BBzJt8QuBQRir6GahNzVkRPG1xC4kyIGtolpV2UkYUEBtuTHeAUGCdlir2uRCEPzdnZT2kuNnsYQPKbmiQEQeD9CccHwNR4DR7iMaQSl1EVDVMu930UncInHUzD8U/7xL/3/bW/wvfBCj+VvGvjRVS+hI5LZAC1k9Wx5w7mRUeQd6egD0HAn/SPFqaScpkUwFCKeZZFziHQ5jXeLqPxYKiELiodl5TnLO6u1WtyKDvTQfT2HXbN/HhE7ps7Sd//oBKS8AcImMLAJuZK4RWIETcyWETywaQ5kOV4RlMt6voCBcxzHTRgJVNajH3YnZysU3b2Est6+notM+sINHnIrgqM2GOa0LcTw5mrvzV1oQ8d3MaXww2uWlTNB918rUfO9wQNQdy6aT+MomLFxoJOONwBhJTg3ARmm8nJNJS0k88I2Kz7U+fVmCdBMwl8eFSi5B7CgfeZqKclIiIDBBYUw13jxhWVe3/drNVLXfvQzLRjyHca4dtYPoAAlQAzIONgJzBo8R9RmQSGFCvFWAoJBgGpgCBJUSAprbOGf/7kmQRgAPRPkybfULiR2TquTIoS4v5E1bnwQu5JJlrqJUNd6PUoYFgAEIbmOkfmU4ilwHea5ZtRx54k/CnrEj+bjecunI5SJKLgBwpCaHHiHYnGiyVUzdMUwqMZRztO46be52v+jeJT4orfanr9n/VHsbDiB9LcsKs/YDUA7f+CZSftjdVeE6YRKBcNUL0VLCNHapffPCjFkjLjSbodz9V36iWbel6uBw+1WoiM/UTfupWx4RWXYFGxMGpAFHXPGLWkiBUbbgCeKcbgMpC15m8e12wnzM7ZVEng2wHzJ60NA+bKMUHN3PuxWG8AMDwQjQCiKOAKSlY+6TgcQNuCqe5WuaG36xDTxMcOvkChGmp8p26x6CjnRVyOs9HGVrBb45qwKOAKkkkAOm0aMXQPVCDvQKWPYw/UB0Lbf9OlSPJyWBzMQHw6WkHMjQqeCcGgMmUuT1p5ftkuZTxBhRAcGyDE/EL+RyM2J9rfNUDDGJbM3LQ1qGjFVSNlisdDJlMCgYUkQ7JAiIxmDRMPE8jcwx4mSjQLlABAgETA4VDCqxjGkT/+5JkGwwEPjrLi51K5koDuscxq0vOTRM6bezLiSYhauTHlXdC3KIQiAtayswYD89DEOzL9NMn3TpJNyGalscA9jqwosgAzw8NCzBYPsP6y9Pa+PpqGJrf5PLZ8M2OeqfF+36ge8ptb51WQ//WflD/wm2Yy86YDJUbbYCyAqCeN5j00sgcErND8sRSuGwLZnstk8X10jVnJaLXLq5IMmIIkIaMNkvh728QzSlP8H9G/wm+2HR7//Lk9r9v9+u262gAG5gE7zJDslYR18G1cwMJMNDZ+24jKQgOFi6Itil8Vqshd5MQzeoA3o27THifSM2n7j1iOY24xBncc6bPBmNS1QBJ7glGfytxyszyUr7kcnnYg6OtFbTZm7mw/jc/OiGUx2b/9ftjb/0w6iNai039coQAGQrXbgdD6ghaN2msNcOm1q+mxrjUy3BTIRDxf/6zr/WYOKzv97YY677KKnMJhm485WZiSZ7PbiDixUd9y0IjJ8v//qtzXyYiqgACpQDBQqM0ioxILDA50ODhEFAUlC4sHiIWw4FAIiGNDzgK1p7k//uSZBMMA8hAThubMuBFJTrJMWZNjJUJSkzoy7kpoWtoxpV3wEy9qpeJZJp+2cQEquYiyuYijyUlNft7lV2dpbFNS534jFk/uEtOFB6wQD9eT31rfazWe/zn39LL1s1uzu9t1/lDqhfbEOj8+f0v300E02deMBkITgav7Arg3FYXlYanmHdlEjnGJjI3+iGC18Tcu6vhFzM2U8Dpx53M+/TzveFvvrbZbYcW/5zs5XKxpUeZQTghv9O5rs0CswNFFmACEjIR/uGwRP53brpOiv+jpJuels5G4HCk1w6Sfwys38NSfV3nJ/8+29c5Lrh3S/0djE4nlU27Lrmn9NSfPmMMx0VxONJIvHWcPr+3lr3Xto/+9nX0PpZ1kMKwqxICzAAUIlttwBzDAL1Hq6R5sKS3MTlSjEKMlVM82NHsjZvTzByIUjx7gzZ2LMtle5Tq92VxzLS6JWiJ2nM9t23V0zOimFeOMuguIVNL1QAfAqh0yeVzCaTMJh8PPw0ZgQNhETjHIBRCHhMAAKEERIAukSACQ7CkyEEKhBojSA0Nfiq1aP/7kmQbDCPmQk2Tm0LgTuha2jFjXY31ATpt7QuJPiMraMQVdmnVfiW1XakVJdismnsqbGpWYw/gVg8SlCkhyJjBpDjSCNUYQBSaZriOqpbZHzzWRKm+3voQtCFyEcjllRNOY9/iWqrU+s+gAyRSk3HAGiaCw4kTz+E+W5CoVHDj5bKYFQmxzZu/q7//ORRVXMxuXhAidoi/7hQxmcN8izM1wsRBI+xNkXNnE5fK+3oZowOu420SUdGNQAASoAOHRkJkaMFGWsZ0oEYMDCQMWuDKMRAYgEZIWleBpAVDh4Ph5BE5ZfAxikNNAmuMVWTBcPu5V3bp5qgxklNveVnCAsAgaXKgqFtKh4ttIe85qZjlmWpc7a+kIWpXTjniX7fhWiL9/j0llmBfpMAVQm4AUzsF1obKUa8096IXkkSFI+wKASWoi36i3740H1jDUqrTFHOUax8ilZ5HUpGR0Kz5m00Yiq7XQ6KU5HdGuzc5lScEV7FchHnRrqPZAJdvALJpKjLIKQTPho6YsOFgokKaSigjMhW77mR5WuGoavs2CtIWISv/+5JkFIwDHELRG1oa4EHDKpk+DTmM1QtATWRrmRqgK+jEDXZm28sL9T7fKXX5fz8dbu0gxUnM4OUbastm9MMHPMFPBTcADpDPCIrsRxyYqZF0/PKXScnFzuZ7gXICAAADBllBkcR6TmCcT6FctJmJQK5cTOGutQTgIMXy+P7VLe1Ci6bmNaRYkyLGxQE2b+tBZy4AWkdCqXuZlXvRceRmwBrAGGRAWHYYI8hzhR8eLjqN0oKCxZJwOOir1wMUBZTUIqG6eP4tPdSYo5ZDt3VrGvlKI9jr6l2lidmmpAgsdGtIl0/8dgE9WKGZSjjwE+L0NH45YPz6Vz/pMhlwXgnIYVw8EY1VtgBCEUm44AhMiYmNVNqPytOwu0QF7m0A4Tfq42bpu6+YZ8tIXndj9sjIp+Z2u36Hy91d+GCHkUlOB/Q/Xy59Xz2KFe0TxFFVBmYEdEgS/IjONoZCua3LYDjziCiLLxgo+UTQmQjEipYJ102SzYwqUYrdSbzOOpUyIT4ohRRC28VNJYaEq/QjIzPbiJh7vDNnOFhvOLqa/s5gMcGT//uSZCoMAslEVJMTGu5JhvrZMWNdy5kHUmw8a5ktFavolY03eofUbW2AAsM3fgS2S2SF6dQ0N6chiM8sx+s+uQQAYcuL3frLWidd139QSF1O/13TzIs79/7ou5HHRKDIt968kSm73uQLzOvG05G3/OCoyCU5KAwcrqWINQG+LzlbsQ2/DusoEZT7wlByKFYcUPCpIfRy1PSW/gKCJ//akGms3fMOHem6vBuGRKdru5CoyJ24SsqKbi8D+DX16VP/RDc/hZmUWDoJCUKJADzS4AIEFJuOAHi4OtB1QkXH2GKjSbrkgdhMiHi8NYcr/7Gm5/6ZK7ZIT0OfTrlL5enekyROFM+FiD/51Y7I/xbWpyuEZTJZn5QlFQxPggAhJJuAIkDIaZcAVqycrOtL5PbMe0UaYJ9ZYdc/Gav+sV3+X9Ztr61SXFoLNwsg5d1cNcxrtrOH1/KRXMfs7Wl2dMKqT+Ii10l3mJzHV0MVjstEGwl4xD640g4AwRg3LdwEzaF4ztsLDzkkTUlAOwGxivCxAmfwehr5yu/672ksqu5BY3xXn//7kmRDiALYRde570LsS4V7CjFoTMrQ+2NHvKuxJJ7saJaddh/UzMDtekRFv1gYttj89v3fvBFbv1/C24NKKePm/2pwKKbccAOwhI3SZFbY4GNy04zrV5GMLyviaXSAnpX7dXgQyUw7UzXPltrEFbEC3FDlNO12QdMhlVDNGnU7p3MLoQaQSVlIXKIUvXpRCWnNqYw4ep5NlRoAQFkm43ACMhRLhNRtPGW9NnZQDAWGTIkwtZd0kczC+DcaJqupDqJ3MAu9CyHzH65iHsVcgrD7m9d77f9FrdPvzj9kNIDlZPtIVQgkptuARcesshVKUxB3HhtU0AX1IxjAFaThgV5uWnqQWbIUhXC266LzN3QOVUFGa/bHK7SVa+XrIuYVqNRN+ed5L6nb5vp2t2ePqC3jtX9/f+/KlARq+1axcvyRADBRTcAUgPLoWmy07O65bnlLlEF/bU86YjeNmubYzAO6nxne/n7zYzMJAjZE+t/0X+tJ3VTMlnXrGlI86qiO9zqxOMVQg+ogPQqaVk4AABxLbkgB6gqEOHYZauZauqxqP/X/+5JkXwAC4UJXuxEy7k0IGucx5V3LPQVjR7zLuTSgbGiWjXddAc4/n6+s1nkzR7jeFdj/VN7xmmK718ulvfKb1KU151lfbrY1v4/rXLlm/zy707qfCXMc6DMnzhoP93n4W/Si7P72ICAAlDiG5HADkCQPmx4VTku2oT03JMBxG6bTgtUjRSLGjURJz3/+OYuyLdS+WdNVBi3RiMfBJAXD2IgjS7z+lc/sk9Sq/lKa/4MOCbkfbqoAgCi25HADMG6QMzhrqxtw9fNcE2mxXAludzJs/s0l/Zx2uWu48zD07VC3LQcqo1Bn+P49+h6XOZAxT6oubXSYGcj/3nW+f+t+P5e2/Zn/b5/eu0m65kuowCAGpgNMA5OwkLSskuexKG5cEXRMg4kDgAtKLSz5aU/WrwCHjcU//erVJZanb+mW/Vsy05eMnJfhzWICNECmnHAZGKfQt8itlYwnetrSQAAEzVD4152IeSaiVNPwu7EaeB9sIPGam/Im7zSW1A9dsMLFIsWb/OM0qE96e4mUXjv5YfzX9b/0YTYTj3Ze5qa/nLmo//uSZHWBAsVBWVHsMuxNxNqmPmZLinz/YSw9C7lSIivo94132ipq3TvqhlcvbH5hexL1AAAGKTccAYR1olrdssHur4qzZwiAgsSm8Z1r6vHtbeDsnv8xK9730Wlk6cyiE6oZHaTErcIyx8zeXYchUKCZaIht38/MvY/PfBmFDg3wQBCSkuKwmgABOSbckALqAiE+qbbAxZS1IEZZpk+CjhefcKFCgseO/+aPKUgVdX83rmNMaaVRqxFWj9z6BYpdx081cv3jjUEzkoMj6qcVEphmOSDeNR1TcXvXmWQ0jtczy5sBIDW23JAEgMBBcfmO07qxRsZBTvespMgcu+ZiXDYZqLxi6jNMxMDYUQZLHW+WevzqJCnMrf0yJDzhcnaZgw9Lz/P1SMmRoeM6fYY3Ei0ACI+k3D0GCb8WNGjwXK8kg/+8Grf08tXPNYw5B2rpjWHHb5ZLpvrqGPSeppep5FwJOLTJg0XZt6quRrxM8J42u7KSt7T+5ST+L6d+EGjpAYMNyIACEpX2DkMEniJItSTNjjuH7YkKwHT9ajhxtOZBz//7kmSNAQLYQ9lR70LsTmhLKiWjXYpY/2lHrQuxKZqrpPWNd5Ec7fX7v9q2dhHOE6+timQce1Q4lAVeVmKnDp5feeluYb5bf/seYYWDcv1aSgBALlr8IHD3QbPT2D9xOkqxOMqre12PyDD1pcxprMUN7G3qaDj3hQdZz92n9r/nSIgtWvZLHBtYl65r75HOyjBikbx9N0Nc6ujH5TZyB//snDjafTGmd4kCACywMpGzI6oESi0TjcFQDQ16F3K5EQXKTBcSSJ89TUiov8nTdOgkggipSjdlALvlZrAzdljOMGOc6HUynVv7U/maW/XvfXcaiPdIKt0oAMlJNwBkIOwolJLdJD1ei7BMyadeADOV/1iqt9jcRb1F1ecYzc2ca0vDBkfITnqXtRbOKMrDMyS/GpV0IsvpuRouTBsW5XXf55qJzagg1HzBFdEIAJZIhScckAgBgPodoJWP2nmCaQZxuQQIb6u1Q1Lnqez2Aktr2+bmNGekmbcjsexcTbNfS1bXoC+zgJ/EeXzQWyQQH43RsELBPgexQ7v9AEAVNuASpBD/+5JkqIACwkLXyw9C7E6oOqZiYl2KeQtg7DBrsTmQ7PTFmS9DMWLBwBEcGgQMWaytydTxe9dr7Xn2FxyiS3n8SkuUUstWqKD5vPl3eOPh2pZJChEYnrE5UxrnShJ3D91KeNdqh5+CIsQdbRqAKsfS70gF1dE57v0ACDKSbjYEYu5AChala5fd4GTJ1Jg0+25Al7jlN3/uTY61X+3zvvtnkRNuN66ESI5mxoaJvjg5bmxboUI0+vGIQCJOCnS4/bSNq/9BKclAX+c0cFhKxlEX0W/FFOJ5LSdGu19rIxarhKX5NagzSZi1xuBmHfNMTfW5KxEY/dzJhtbX3KdiaD7mNTNs9vlXJ6Zq/Wu3qUz+3Zsfvfi/7+PqQ1HC1kG7Hlb+JAABJFFtQA3QYxbxZTUMpRYtJuh2sgQGFr2wvF2gdSnOGL6c5t3e2WIpCBWKQl/X9AoVQIwQ8/ac5Ls9XqlnetEOVlyr/QTgR1cORSZxYMNqAWikmoAvEDgCICNKfWTBOmzXKSWvJI8gvXW9eVx8CFA8beLHnEhuebakz4dMGXZ6//uSZMMIAuEwU7tYGmJLJssaPWNdy9EFVG08y5k+Ievo9Yl3xTN1TWPSW22JlJvtu7Xsh32y0fPSHTir6fe7/ivm7mw5MqbE4bEcux07cubCwIAVWBNwn4CHozlLErZPO5x2I3PuW4ADi2LlrVCCSISMNrgkQT0uCq2yemRhHKu0ruFf548e8pd6lP71/Xv0+HmcMAv3+tem8G1nd8IApNwAqqjJ1QczLekycFKlQF1iYTddxSANVdrZIgrz1gVWiBucBvXDx2qMW0nb+fEaP7fWqtTOKHy6HhahjnGXDCH1UQsqnv35BEj893Ib+P3rYyRz9rx/KrXBPJz2pWUwPOAnhaD9D5ICguZvQVHpqfU7cDXnzvLxarnMlpsXw8tF1SP90/r4iCBju7HlqZ/ZkZSZpCf0SKZGV+HJ9NPTEmSmR3h/9+gRexoOqcK1ABUmABImeKxCBlAQmUFwGQQYCBYSTpSOkBZgEGeDtmAeqsEddA5EUyrCiQyAXukJrtfFsP7VxfUrCHEMrAjo0FaMOa1yNo1eoROTXRhGebtEjln3yP/7kmTXCGLrRVe7L0LuTKM6pmMIOcv9AU5tPQuZOiDqyYeNdosJ9TT/enBEcQdIPcaLOeoAFXcARQm3obLRnJE8rsqDvO3kZWGdDJ/3YUbGTbkcohwlBSTtTO1Yh/K39N3L8bFbvf+9grOOGI979PZrJddtNQTMgN2MvTzhrIQjzsZlvV8I4xzXDTe9oAATdAMEDk4wRjGyCMGgEeA4KFbXhwEBgjVVUDmBpzM2SOwB64Og28SIcI4Tj7QwwByGO59tqUWMqJ2MpNY3X5KdmExQSCaFYqjrRQWZ4wzDLshjq05pEjnPV8xUR5WW576sdOy8VKonmGwhHLADc2AERA6g8Urlg0CkoXBBgaSMdeZa1iLxiExgPbDlaVYryVou2a89SR7f0MlRmEcI63GIGV01QbIdFpXPP7jopR9pKune/aXUnH2yZ3ijv7vdZVVWagIVGnYOslbF6jW4aXHco59abFhqKd9GnkO5A79myv+HBD2Wbv4EuJH+6vEymA73b13T5RYiOx2bv+7ru+74btTJRCu7oX+9LQ7IwNaL/3Ol5t3/+5Jk6YzDKEFSG28a4FjHilNnAlxNmPlGbmCrgU8PqY2sDSnNdUkLuMs0khtzAQoH7CCF1oWoKs65yMzE6XZWFQI9kKeXDMcXVLpqz0QO/4nv2z0+qLOPIrGGEddR53bnrRkpT/1e+SsvR1bEREBSYun4a1r4UwABgYjLp72TGR6KSl0wyEDFiBMYgYwOTzG4WHQmCQaYfDsKTaYikaZZLDjooUpaZ2kcXEbgskAAiSQTqt+xNYjs3XIclhUXkEEVYPfqSCclkOAuWEcrGgnkY7O58rQhZS5dle/m5MtJzNlPZ11zPzvr7mqj4n4++WvW/zRfvU+kYXVAO0HAC6OwiynQvOKQOqoH7De/TxBRNdlqTetD37+Y7TwjpY8tx0UHo6uNUDqiohQSUDXnsksKDmVzgLLpjvLqAAAZJNuQB4R7DOIHp4flFDAkMSyuT0Om9dkU/CehS0ZEAuhSy6kREvPN2pKIZTv83e+e9/mnt/F8uh7LZ7vf+z9++/4astVWnpZ+52cvriZQcveUZvLfcN7IS4CSCckuAUUAVUEbyrPY//uSZOkMgtk81hMPMuxMB+qzYWVcz/UDPE5ha4EGkOvY9h0uLTR19GRFoGuj4Byx0RTWyzpuRtK4596kM/qtnVMMEu4gBwNZpHhGQo9Yn4cRWm6maGGwdSNx/8R/P8cTe9zxFd5R+2YWM55f/8TggGuwRcNMQLBcsNpatQjqhMoYnIQQjU8UKr9QNgdbF0tPD0yGilnLccsuYG2IcE0NY1X4aY9MyOqu4SjGag5CpQ672e0uhtGDnkZXJ3JvxEfS+bmnKEht2MRsX+ygIAATwAkjn1kJlz+ZObmDgRlZqRCKDyLAgEDG9YmGFwhAC7XGCSXEhiawZaRNxtp0Sduq48MSLSRTUZVawgiLfq5Kp6lcuOik9GY0XBihqIYbq9OZ7KzMtDKsl/XPvU46l71WesqYsujkY4j5UsgBZgUrOlQx3QQK+bakzkOERL1jC6lpDJ9tSuePnByBCKrdl3PBas4S5uJaaa9o9JqRpJ1d41NsU9XxkUgdinrdiyr9OBxqJDis2gd+UY75CT7BVzVp+KwwEKEsFQHBDkBgABagBiCubv/7kmTziALdRFnTCzLuWEcq52EoXMuxDVzMLQu5tqCoTbydcJRGVSxkpeGCosQGWDTCkmWDGC7xrQITDaIyxUQiz7ls6e9PpEBPqdbxnjS17VqktdSDVPY0ctB5HJH4RHDx90I1Q1HF1KUk46Wpeze47+h9qnx4zHuNET0GhBmdLROJFPHNtkAAXLgAsNgtdMoKzExtixjYCJPJCHBwaxcCFYYJDxWRMrksOvnLXdb4RqHiQrOxDUXgOl+VKpZdsWJRTfcy+/RjjvH6uc7Lspq0Il6oZSOR2ceVkCyOlLUu9EYYs7squWfeRomg2i2QfQZAATfACj441M0pAzw8aqmJEr8LyF62IAVgPwCRFsLXYYScOZjbiVKh5DfsMSd3EglG4Rp7apSBXLFc7iAg6TnUcjf8Iij6c5SNKqpq8nvuj29y/8WHCqGTFmVnzC4AKS8AKJDewypcFQaPpnFhlBA4ODActABMFLiTj3NdHM7inY8wI2CtfNjPVRRsaeEGSlaVs49/mW0ZjGNIUgIWK1DOzZGgDlDfxWrnm/4rV/hSKhb/+5Bk8wzDBUBVky8a7GslyhNvaEwNMQlMbeCrgXIgKQ2niXHk0M0oPBefwbhcChPMUs/L8gCUXABImEzh2SgWTYQMQL4rmIhd4w7UO6hgXR+Sj4qYOzQAAfGIDwq4kZfkuv0m1Om9LuXFiBipV4wHFmvI5iUIn1ZzMx3/837GYglpLSo9takGjCo8XLHEeqIPBJbcARPO1oSfAQLaMHTMaYVmw0vAaCB7yLy4PqOsQ2UHC/w/ewY7yv1AWYf9cXkxnTm5qAt29tmN2ZP/+ekcfDzrEZSTz7rd6bKtsyWis+ZnqJ//f/40OVlyVLUybKUYlQAzdQAofOUoATQBBhaoMgUaC3aWUACmcaMmPGaYqJgK2c8RvICyfjsbki9X3EjwbVt9R71d7oRnTJAASwR00sj/e2kE5XhvIs8IYgYqKUr9Iz8xbqAzb90AFNwAUEgvaYyKAQ5QBMGqLqr5Ej0OiIg3wIpWJVCgW6IgOSoRolquTuJZU/0M2JfVmyfMTFJnewCsnSN1FklTV4o450EnXizndVQoEU6mF7xzi1FM79T/+5Jk6IzDKD9Tm08a4lwIqmNphVyMIQVUbLzLkV6ZKY2niXGs1kOQSKFlR8I74OSIIAk1gkoOnEZFoMRVuTIazLo0SPZOGw5GYWfhQyazR++wgHu8Seo4kQXbZq9zzo4zGuh3uZylczZJmgnLkoztdBJkJEs1djl9mDOHYQqfiN3RwBKTgAWmPfU4tgwMMYCOEKEbWkNUIBBYmXK3WGRhgofi1SQCjl1WZNGaPsj7c44dqdx1Xrffr5Z4PYaUoO+lJFPsUWk7/7m9io8YRmse+2Z8Qd+9dsXvwpXrN8Yr5v+sgoiHILIl7pbvpA2ACndgDChTwpDTuTBFhIWDmjABpYPCIGKpsI3jEEWJYjQ0HFdKxCyMofGeu0Mq834zFqrhm0LWoXiuQVUARZNWJEhyXMh/mvAZl2Zgc7RvVeBz5QIJQrBwf2Efv85DpkxBT0J6AEDUwNudyBVCsDFS3yI7ip4Vz1HjovtF2UkB/Pgnx4U1HxuJTF3sfVs5uIM7zkCiE78KQCLYuOY+0vogRx/pE8AGsn3qtZkG1PZ48SJH4Xow//uSZOqMQx481BtPKuZRp9rWYQJdzWUHTmzgy5mNoClNp41xNPQ992Rw2yBpm3FwApdgAQXDZhkD4CBBFIIHCqkMCkQ2uKiBa2FyMkmiKP9rcGFBnQXuedWJCl9Ww8mvNiHeJTWv1wQJv9COUQyrL4kIgUzIPBfdBUJqV3MwSrbAiuzD7nhgZ+JP/3kRG0qPsqACpuASGxu4MVyyAsNMkeM2lWUHGb5IRDgIgAZyFHMDdXaEoexneOmFthu4KuPrEF9SeHu2J9Ua4CIznmVDjmspVPJo1KkixfGlnLuVqulKFRXIriUSGMkqSscCPllFG4yMrwEtM4JuFnxw0DkS1Khk8je3NKZcSAXG6qoG6ngmH25b+6c663KY78LTmwy0i6rbOOCMRIiD8u4j7+IrjuI+4G3VNre9Wlddd/P8r7f+KXBRZEqhhqj4JwrTVQCFJgDCoOuk/gzTUpBl85UTHMCB5eIGXFTwUYaxAStTwNrI3fHSxughiISqC6SzdsR59qTKGKfOrj/OYYRIFrO59of92rEv8dAQ53fGl/v5Csy4xf/7kmTniILkLdazDzJuYec6Y2njXExlAU5tPKuJYqFrWYYhd0Ia1z8z3v1NuzWz79j/IXp+ISCUD7SQALcoAGbN+wOvAjo/MRMjxxplPzAZYyZ0lw4ionNUEtw3UfVYeMZ14Jt03KsuHnnBoYy/L7TzpjY2O0m/tlzvjHI7nLljuUSSQFnpQTZIgZO0+psvYflqQA1LgA4MbVgO1hEUASMDMgE6GiRRLa6QkVNj6MuIglMxF+hOhJTHeG+xKiNDfQHBMbZJstca3hySzbAgxoRQGCEKJaBvJbAS3B5oTL71dIob/NIvOsOJP/Yf7T+sV6PMyBGCZ6GIABJUABAc5w8wiMVTg4MPMzIoEjl/w6QHkKE+XstxyCEsL1RPwQqOhtmGVnUutuU7e1R3De6wZ95mKyIRFR4pKorK1qGNd1l1Sif9v1e/p+/gnD1HDsCMCQFvqCQElOUAUaN8MKygpG45DMoCAYkbFASpISwFnx8juXIQNihBqVplnpaqfOLttVfvPz623NA1+rgxHcrekdsf4wTLP2rc2+9jo+99+w7PfaD/+5Jk6QzDVTzTGzgy4FekylNnJkoMuQtObTxrgXAhKY2niXPWqfzz08QX8XEvd/6+HDy8zNhfXtegAA5BTTcASA6z8PdoVCqcXe4TQXHSCDKFwmF4YBrsY8k6/ddTjzKOHK9aSDuhjBgm8hv0f7u90Zr1+92Yveruh91VyvQpiwQH2jyIgQU5AAYIusztwEODvjRnLlhQsOAmy7BMeC/Mg6HApW+zGSQTqM1suqRo2feK6ln23wu3VvPXcL66800F523De/20xlO+slmM3MEM/lz3nV9m5bFycabvKv5R/zlPJ2/9pQIfn8vO3SWAUnKAxcwKSGLYlKRGMRlWY0JlhClPlyc4jKdEjrdBdFrce7ZFUGb61Jv01jW9Zv7cMxfcdw+jMRwq1Ed7ed/zYxZmnel/2qhXlBMbH6o1azerQYMZFmFx4xJzIlWVAADeAMmKN+WM58MCXAWdTAy1ULhxNoQhDCQggeAlEpiYDfCz3fau7zPUJbQevzG4DTWnddvvvOxeRS2Oy35t/c6fUB8JQqH1PoWHYtS7np8QNPS47x69//uSZOYIgxxE1RsMMuZLKCs6POJdzRETUuy8y5F0oipNh6FzT23fEDhm7vFwbXojf39fx1drfWVbpY6za4yg0SE3KA3UGDERYqUZSmJCv/KJ4qNiYMA4KNC7dbdoFixtOow313H8jo/eu5XGpSxPqo0edXMC3ZBpmejKDskk5kYiymdOrTTxro2hG3TdxShCD1EBTVMTG2wASrQBXcwKjvsNSVIg7NQnUyxAn1FYw/gcqEgC43aayz6ILsgpyECLWY5HozQSWaoKuctrQ7U3SSC9B9+mi1GKFjAcHlsXwHDP/rPEZpiQ1yeOi/6r+LKH20dVJSU6V/aXfG48fLz7d9RlI/IpMSG5sApBjIw/k0lW9PtDxIpYOPdS6nvEsWuxyWezIczGp/on7ptm3Sjet/LLNoZ3+z2FCBjtoLHqxbC5MMw8zD6EzaoAAGUAwwqDswwmdCw6aYDGuhprAgYelAQBQsMbAAxoAbowKx57SJl2VLL5f8qip9yaPtibxlq/Z+YtMTZ+/zyU0/RUMZgygs6yRAAWV7LcM2MGWhRN6VA4Vv/7kmTqjIOVQtIbWELiWCgKs2GFXM2pB0ps4QuBDJ8sXPOJcnioGpxHzJnXcktfHfavy5bVW0Rv40suLnx0C9MMEMt0QJQAABKVfhOQxcKRnTaubk07kRzmqcYzZxI5sNKnfeEr2aZvvb9YsLCrrnNW1WtiJGvYTN9RMUKo2jXpOpDnOig8c+Ye5DbibNrU5o9DLiYACm4ABMDTxIgeCF6TaoBegXaDh3/AKoQAaYRiIhiZP4y4SQC0J6C4IuAmCni7lgNZ4x6y/LjEgajP2BY/iSCE92+m78ZV3/CclbTf44S23TO2/5hWQtQilfM9nNs/9mj9Dq/jn0k+ICIBEt4CqZvaQFe8N2hQBTDhE1WmiKxeobbYXE9h6YqclQhIpaJGtEk8P1vWJN82zTEmtkQpWLeIb7H8iBXOxQ4R8i6haQQNHuxAhaUFEZtUcydUtmoHeWbUZgClbwBgkAsGbAWBijgMBNwNTIWnaSIha4iQNNQow6l2o4yfNKbpVxb4Scas3ix4TlL80q9l/R1dLLMH5UWBQ9lnd/UQumxUQVYcg3r/+5Jk64yD2UHRm3lC4E3IGyk8xV2NIQdObLzLgWOf6g2HiXAo0h0VzndW5ET28skVH71Wz2CU3KA/BKBNRMsbUou6bWIHf8cRCCnfQdjPhXiQWyeaaseJjWdUxjW668vzX+gGbFLuU+q1vFgoywjhg8BLmcc/PPt7D8CdYWXVhrf3xvCgnrKaLMvEmADQGHFAHHTH1MLJBiQ2a7LGXGYcjg66TIfgSB0Aw+Et2vRr4oSBVxpKQJGHai7pr7aa8c9JqdYKVurajVFGqCy1/9zEkzaCBY0YeACLx/QWe+6+Hr+v8bfP+Upql7rN7Tp8NFSxZef3JqM/aHpazPdAXPFAMzoOy0QcmTyULEQ27KIwIo8maBobC8bxQVIM6O5KMvKGuNVOEfW+IffX36Ykz6uLtsZ90XZkkZjLdjCO7Hep2nU1pVSmOkacgYVc0ETBhMpVABbcAC4Bq8EiNSXZ6dKwMtA68x5100a6FxRnuaNckqYcS6rVq+34ziMs6f0a81xeFb7jhF5aYDqrbeuviACxanmDahHxhdS610q3F+itHrF1//uSZOUM0utAVJsvKuJWSKrDYeNcjnjfRk3gy5lDIOrJhYlz8yRcX/fjVc3zBy3JkEAFR3gMJDWwYeVfxZomRMgEOaHgn+ESQwKakDT0kShpIzTxuMUWNNL4ZryTvMJ2DyBZWK0z1vsCz/Syqr/6jOfG1C+17ZWHRACuoA6IrJujDrZ/KopIzRFAAALgAqpF2Rr0QhYBII5J4zrA0a0vyWgKy5VIBEEpYWSBEnQG+LTkHxw8LjrJ3S6z3OMXnGnc5C8kAYSm1FX6ysYhMggCUQxLETQK5HzMBqqKqDCZvVf5b6EG9/xQ++/2a4izx//q6xX/yNW3Pyd0ykApuUCGTEhCgR5XY19DBTeBoIcVTQF4y9uMuPLGgv3tlRXWX8u9a9bt9/85+9vjQ566Wwuv8KM4mCXio6UipmoeYf6dePlouarl2r+1bavrjEFES2qeh0dSr6UAArcAvgECAmMEhBLQo0Y8RbEilASJdARqB5EtbLXpQUla6ofiywDQsAoBcOnmu2q1vKzAUVvwmeymsP/MaouQAR7LILGfaOt1F6pIUf/7kmTnjML1P9UbD0LkWATag2cGSg4U90htYQuJaSFrDYehc22uTTQYLN3zUExo8nsJUds8iCAqNGkGMJuP80HAiAmnIA1FS1DTMSAfD2M4IwqgnkZ7i1Pk5V4/kJ6LbOoX0+UsgSvolijx7HjbiPl7lLjiP2lY5umief+jDcaVB9aOGEQTjoGj78QDbDk2Mb2dp0HoACl4CgwFLBIpohm+GHOGfQKKA71VUQpFXo9YU7KFeAQS1xYR91QoZQ5YIQmwXY0/9DL68ZlMQoohB2dXODs86iTRAHVKFuK/8SP58iD4haxzIvmrWvCWPWadUhkhnefR8kfE/d28PQ5SdRsa/FdmrACA0Uo44Bs6kmdpSavAewmJuCf627Sz7RsfKT+PbXBdGlTpYkhBDzgqHfFUQrVFzXMZBQ15xxjujGRKdbvV5WrWp38fOpxENWoY1sqqAAKdAVVDjsy02FTc4E8NDAjCQ4x4YMEJy3ZedM49kEBoKtVnyEbO100qMiQrZqcsCKmURXMpR83SQDTRKTv3OV9zc3nUlZTBgOwbmQHJ4qT/+5Jk5YwDSkDUGzoq4lRoSzc9SF3OCRdObOULiTEe7aj1lXZLM0i4r1wxw9daQfCTplR8u13H8j3u+T3bJYfAyOOuuNyqqno8JgDUaAAMF5/wgtChTJWO6zuLsPyQimhY0ZPx7+0d7zNiBIDCAwU50edZWVb/8Gr3BmQELoiEdN8Nr6yj7jxUZ5vN85q39/EABO8AYFAsGZ8aYy+asGMGDDBzNCjKgwFLL0jKk48C8l/wAjRRKTsLCrrlMWQYfeQu3H4YhXymtdnndv5b+tYllgqGchcAgFFVzRln+OkJwOJpeH52LQoU7v0tnRW7s7y3fcKJq4xIqD0E1D2xLUkNUFM3FmTilHXYisEXG/pZkXimrrdsd82a7JvW4Pvjd69JN8eJEvHVU3ZD/1GC/tf+AIeVhcc3QoPLCzil/ykrHr66dan2n/dVFV1gYBUElOUBrQPKwMGfL0O28k0XqQih5bJHhasqkkfmLlts8M28oN1GPl3bONbu9x+Kd7dva+/vglaEbEGRt/tP/djnQ2SuY8404Y+7fZvvxnu31AVFftaT//uSZOcMg8ZA0ht7QuBDRatZPQJNzdULTG1ga4E4HyvJh412FJPGR8aPQTCyoLd7hLmPRNgACsmnJIBKeSnWC0bWpefbbIAqnKVWY46xfsa3qQ5bhIG7PHqxn+Xejxarf+OuamwiWBdUppD2hiTUo3wSsv3PIvKQiKe0lGdi6Cl5se0yPbSbZPzYABToCMBwwJmQ5utovdMScMIDMdFMysMAAC4ULojmGzFiXZYEuZnSOTSQUYpl/4lqnxUyp2Sy6E3YxhLJyJt5T7pHnlFHLFWhCOF9yKABzEcDByaIfGkuMZ5WqpKZUvh+OG0SpVSFnGdTcrzzpQ9VtOHab+KFssAQNVAkxwl4HYEpPNQMJxMkV6KZfnz1KXzFFzBI2OFG19Zlei7+8pfPp+cHfsKGa09jT/rNe9acy5kM0iFM8cPkwC9SkE2PoqUAJKQAYAAY6vIxwMDrQSAcOLYExVaBaoJ2umRzdyCG8xaW0bk4ymhxmLc9X5nzCzK71/HLmWV/HeaspqHTIu5CIaNsmIvakssc9oiLff33z7ubJGLEhbtHRf/7kmTpjIMtQ9YbGDLkVQfbWj0IXY7ZEUhtaQuBIJksZPaNdsQ0K5ZovciEGTzHyfvfFBTllAbKGHZkm1IYcU4fJgzFAFA8DQpb07WWojagjp/9V//5fGlmf3Z2Kqd/W+v04Ia7MiXZSLTj1nauBF1yVyejM+oLMqUl0wU2JWB3j0JFwAVLwEHgc7MCgNoIK/gsILNGJDhQKkKgkWOdYylznr7QvizethV1DUHSFu1aq6cNRypRVqak6+85lXl9m9Pf0wYKCsqJMz0VabsjRMj7k9JndiF/pbitooVVmn3grUp/SpqGDdOiBroGr3RAAVHwCrCjUONgV444RQAHgtjlg06JNJtgOhu0xjGoG5YeRVSXTs1lbsS6ta/WV/dBR7/PtTPo0WYKFSsRRMCHbRbIxkJsRWs3RHdnJLV9ktYm2+/+iy2mVQVkcgkeKAASnAFUxYCPJzcFDyDS/oUGF/V1IxOwoCAMKxdD5N5Uk4UoiCLUkAlNVSdKxJmZ7C2wL8SaW+M43s0g56wza8VIjnsV0eld3u2cdZVNTNdWcq5pi5T/+5Jk64zDPkRVG1hC5lCGGvNhJkyNaRFQbWRriXmiKc2clXB0Q1H1ZXQaDRx5hDq5zWeaBTcoCipfFKEFCDrFuG0bisVlcNKOAqo8KopkIsrjqNWMlH00EiykWzcrmC3e3lXkpfQGj6YYpOhVY0IY1hSwjSMv9p+voy2ufT56b/rQiBkUKHrI4+OFqewqq7gstQTYYorA3SIRqmpB4tbrbjBe1hy2tayw+f4f6j7o2ImLTM+misMk1AtnJ0x6397EBK/PM9NP/uI/qofDISuCWq+lYWR8dVZ+3Kl8x/8rl/M6pZb/q9TuLAAlOgJvkJ4MMEjyfdGxd6pAoCNLqkIDDyepFM8o+2uMMdfipSzM99nLvaW3zKcta+n7/fY2Wq9FLK7Oc12mus/P/1Zf/7HLV0zTDG5y9jxqNDaEUDbMetSdR5oEpyUBfaqYxAwYImtqER60x7M3AqYA3XE0uj4lDf58ds2GCt7ZP05mG/MWcp4wpXx3NIWeaekDte9v36tRmcz36zVC5zRGKZ/ZW+NTX8//2L+7EX/CVo+aZfA+R2sg//uSZOmIwyU+1JtPOuZWh7rTYkNcy9kNYsw8y7lroypNnB1yAG7QBmeVgxcCppdBcxfYXEcJhwQJKocN7J9qQcNbTZWvyJYVmcZvt3ifb0Xi9MhxMCoFFGUPFzm+0IExo9OULv9176pXk0lZHRYwco/wH/GBJW+NBPf2w1aF/8boBJTdALAqMQjIMqKEDpRgCroV+s1hPBcLhcPCW5NTiQkVvoomMH2qRjerUs9FLFfcXHoKEhcbBuCkoR9TyE/mafmReRGY/mCYalIgh+lf+LL5JpwW4YXXsH1XBEExCJKAOXnACaVYNnAMi9AuOsgWeDoF9iloAYJAXfhcThCMVtON2ZVkwqlwlsHZRuZtWbtWaIBZZm333rE5W7En/XeJr72Pmsd2d8v01Pu2vwyRQyUhMSBJIdcqUHCPpATFVQSm5AEpQAlpog4W+LOM6EYBK7HGsu+QiCMRKlNCQeyax2aIwtWY6Xu9gWmt1Hhqk1nXy6D7HbtgRUHsYOOa9RK5R8SejNJ2chm43X/L3P/bDa7oTHd6u5z+l5k5quRJfziqoP/7kmTuDOLsQVabDDLmXYTaY2dISkvBFVhssGuRfJcpjZyZMALdwAjfN5UoEMSc4ARppUq+AM+gBQTs5E6iKEPMcfxkDXIZjC+onGWV0MmtP/hJm2HWuF0TrbTnPt72Wip83us/9tivcrSqyEmI44JKOy7qWa9UOyCTy0snpnhx2tdCGvtSAA3eAMrgtYzljLoG/id4IuBpoZuGOQ4nEPssiwVzx5ujnTjbz0Cy27lL5a7lNbwisYqyiI2+arXLv4G/XmmpB8+ASl9C7kgQWR63E8M88lcj/sCEVCBEIEcy/j9xQYx9lDhERjh2R1IAAjgBDNNGJS3OMVOUiMmECCJUEo/jyNZA7AAGXwm25FYFMrDKYLbBAEOu5XpK0OWIxrKihipNogRZqB5mNdn21tzC6/5h33Hz/7rf///5kJvTMx6OES4JMGMS9GUsbKUqAELV4CCmSGwSoJ8sQzihP1oVhhETpVwk1bd2mHiCxbnxf49/9Oo0H47/e4WA8H9zjRHGx8k/VCQWckYeLkdJA0cv3rfyN+vdCZHUEiFLAWzBF/n/+5Jk8IzDEz5WGw8y5mKEWmNnTEpNAQNQbOBriYIXaU2smTA40pbVJzZccH8x5kqPBisEnSZsOpIoatas1YcebUeBHldi8RdM3WcLx5nYtO83Z0E3PXUt02VWAoCRIccxDkIVQ5Vv/T9bOmpVzXh84IwHJymhtTQgMroJTg9Hmd8kACwGAumLMDxMoLnzGGb4kapAOfZKHuhwwKVh3JVSHmfgH+TtTqIRnBitrJ40D+zUFJVvzWlkVUsfqarNOldLA9zcE080rPgeUJeeSRD0d7xE7ZWLH3EtSWlvMw43W+vm2Pi2KePBt9UpfFvT2kx//H/+r2tv4tPrxvhY2DNt0oRZICHenCGAUS5JayMVWF2MaSvW7x8OL2B5vEia3X51isPUXyViz0VIDboUilRIgcxZndGbae/3v6tmVZmVRgser0dkZTu6wZ6CziogQQ24dgACpQBlibl2YIyAiZp0Jj2reoMGgEjdYDJhwkEz4ktxw3MSlTgayWVaQrdUEg0Py9nkBRB/4NtRiaqLnsxjB/cZDP1zxsgpJcwbgrGpJGfG//uSZOiIkwBDWLHvQuxQ59ryYgJdz+j9RE1h65lCoGwY95V2k2i6dsRZkYzjjiqi6SOIpiOor2tvNfmia+aomJSpMdFSFofAAGZf/wE1SXDAfTpVKxBOmQgW1EzwJAjLmD0kc912fo1Tf95jlApUWpyMyKcUHbGKZUdVsdBJkfIf3onkMd0ftbFmvPEo0qGhiz2Ap4nx2dAmiYq6NIikOPUGs1TaeyuOGmE9rNWekW8aW/zqLuJTVoW5juBSF+lC9NGK3VXVxr3T/x+PH0MD3ekKmkraqlkobxxFRr7r80n8mw/8OKbFlSEJJcTAC05KRCAKWCOmLy5UsAKZwJmMlpKk6P+6ZvHUVfkRKsyU9/L+HzlFTirqYq2kMYWAEzziRkM7oaujr/pLtQciROKFPRUAAqYAUtmAsiSMiWDSQ0xcpaCMSbN8g6XVMNDOEqKoOnZKkNEHXnkcrsY2lUz2RNdRbjcblbuX7FeBZ+X8iVqbt5FHSEQ3kaHpzWujGRdLR+PmiD3XfiCa/tXZhWja4OD/EJuD/iJvHeslGFOyaEoQdP/7kmTnCIOaQFKbWkLgSEcrWTEFXYsREWTHvQu5IZ7tKMQVdtxUjupwAGpgCHs9G1sG/cGEF/Q8poQJcHxGYqqHLIuM8soX+zNBWZdV6JBMw7OSm/blMZQMSYiagDvhBpy5Xh0qTrzajn/ajO+9SWB4SxX7/ve7t3pOlu1+2rmfpLx2qfzd/QApLwBWE6UDKFRUOw8CEFOCJoFWAxgOtVgDVKxWQQzAEEOxJX4mqKUKYwTuVQJXhGMix/rQsbNNjdj28ZiSR3VLIU6vUlGXKNsyh70XDmFjfvk6PW1oit8pV2W/vn640uauX3G2ZadA1oFRxwAjarjDiQ9KJaZmKV6Z4I0fQWgs+pmT/qVuynO9Kn/xOtr0ckfRlEicM6R41nZ9Mpshuz1hFdRrY3itQRQe2Jbetvf4n/f9Yctd0+II2vZmAAblAGbZhzppFBgjxpEhkFwlBe0cHGcFKlHUQhqxhEl50kXacGwiSo3Bs4gs6c5I2n1pLSUM9qkY5y5rnv5hkYYyGIQ0TWfYe66ghlQSKV1WYSm1D5WIqpZbqPvsajv/+5Jk94zDrEPSG1pC4l6EWmNnS0pNKP1QbOkLiUsgLMz2mXeu+PU98lBinx7f2YAGO4AU3CfTHFOto2wDEVWc9qX5a1dpYSnIPMVo2zwLBycUSf+nZBQNcqTte5hTsQx4kCCpYdETHaiS4eWPuYeiL6qkPzi8k+S6h7Fhd7+hKkQ615dkqfALw85y5IApTYAk5LaGgoZDRsKjMxctHV9AUoBk0AQuzWU6bKpc/6XcaGgdqNXl07nMYGtyeYiVaz2G8ampX/OcCghhSuR5CvVcAJspldcczPyyOSzSA59Kiea1D1gwsRj9Ei930gawQf0oJqwFQKXojKXaFtPHjHYdeaB3gDRYxR3KeYmsZVuZ1D+HeWOc1DfmA71OWYqpf+dXd0m+eSi0QNqqkwZFkuGjehb8sYe40pDZDEwfFUHMs1QAAqUALvZ0JuagEFRSNqLDBTQ00JkxbkDFpbYwE3OyUQPXMohAVCDhS80A0arxEv03WQVY9OvJNRuap7ti3uzS17XL5wGKGChbsLtnibGswnJOaKPZVqlBASZVZf4qjmse//uSZO6Mw1I/0xtYKuJdBLpzZ0hKDJTpTmzoa4lAEGtJjKUuYqsdeIaTZImzQ67JAAp2gFWU5gzd9M9AH5Dg4YLiNIBhzlgXQ55WzL8ZyzmAkSYS2sykNH4Mo5+XymbiXxyJZ3n0t0mqfGg70emM5cKnlqJf14qx9XJn7IJOwFD/X9YZY+pnXmWKGfGYl++v7rgATlwAz7Bkg5UYG0hJLChrElcYACgHMQKIDp7GNJX5L04ZAkxAJEY1SpcQhzbybmZimyilLexjHzf59peYhSMCKFCKlsy/xBNYXA9Tbt47e6w+xr/nv6uTkwzf+OXn8CAgEtqNABTlwA4zMMLNLBLegsMCn7BC1wcYRELMIPC9ZcctX+zRy3VuP1eVzVbykp5mSX31V9EEHDqezOwMVWLCk2dgp27WrEYQPAkKTwkNbnKsQYkAXMOyQ8jWStTVABctABncwKk5E4wvo4xsoXlnlElShyIaimADHUIpcuyxpcuaZsFK2vNN2ggVbd2q92p/G1lnel+8Mse3e5VFBFb3eGf/0h831HbNNzYb03Pfyv/7kmTvjMNpP9IbeirgYcZaU2cjXEyQ/UxtZGuBYxJpja0NKDX+u2Peu0a8tN4r4bDoVOmYpJhFeSAQIp7/wPUWkR8yS9zw5KrD4+QNMaFgqv/6BrxmtrNS1ON6uTTxbG5pU4Z/5w++LTKI5GhhhiMobNNarpmpflNmGSjf7tsw2IKJbT8/6P0AA3aACXM0NENYGjJZ40UaMGAkrCASARMYSPAQBGRA4IlG535oaDPuuG0RD1K29etIWhfaRvZLa3xmvr69+Y3W5NdwLNoLmdcurYxSevqa05FZeYJh4X2GP9l9fbMnwW7zV9fyBBd1/kn36AA3IASpzEWTkuztMRsGYE6kGQMjVgzJBwVDMQRAdiKtSYKLApO0+NvnA69M4Bm3zkGduOWHKjiwEh7y9mJK8m83+61VSl9wMNcUYo9h2JWA6WJrLN7UB5kkgJ1830IgpOQAhvmTKHGIGrsHJRxIw4NhYYqMMCW8m+eRNs7EfZ5KFxQa1ySyewujKM3LPIZn5XhjqW38vu43u+dCYQjrP5Uyu8K3/vPnKMW7f7vyi2v/+5Jk6AwDPDfSm1oy4E6mWyk9I13NUNFIbekLiXgTKM2tISi67Pvat5EYQVyNfqaiJef9R41y8/KX/ysH0NMBJt2gId0VQVc4JTXduG2diw2q2mQAKqxh+nJEvndG+y415cfPvn+bwvXEebE6skLzAbl9VHWrqN/3Jru4hP/n+f/5qSaZ1Wb3JD6tfdSUX1Hf1xAApOUAlihQgaA0ZdsdEczoMjpkkRooCP8u0NAoYdnmswBD19rtJL7jf45WsvgLuGPcKb/5vlbu4ej1O3g4NjZFBndffOz/nNUZjZF58vOzb+d2QSPV9rfTRr+/53GPh2FpNv1ozlkYdhgAKTgAijOiE6STy/VcIDbI6yUNjyY8KOgAMOAVOIg3sMRy1GLq+LijuNNrD8fqd1Vnubxw/fPU7BXqixVTVPZHuxV2syJy5LlmTfYjTWrr/LWwtE4KGEmE1QCk5wBFHm8ogCMTQ0oXejAiMBVwFBQgJQQAwNEQofR7JVY4ITDdq91WJn0FSudtT1X5LCr1y1h2U85r+TueWooIU0eCTpsGKKxZQpQ5//uSZOeMw2NA05tYMuRTp3qzYehczR0PUG1ky5lhICmNnIly+RWr+qa8OXW+t5r6/Cy5P3gzHy82f4zo4FJuUBbYEeBnGrY9BPVTCXpiCRmxrTDrRaZvQ/Wnd0vJvOCtb+7/UNe6yu4OpFEgAqS3fQ3M7VLQQPPBS8ps6zKHVnV8RCtTQ6gJTYAJboAx5m+PhqBScyOH/hRpbmamPCMnN0ETNygGkphJsdEqpWDgylqmS/4YhluDYNwChlyPySXS5YtFnOVqV/7dPemcbV60VfsNBEr/HQLWlvKq3nqfDWrzv19xnuK2X+UzPLvjZf//bPvdmn6yfXbZDLp7hfQu/2AfY5wwgG0GoX1CHMWhRHkkRGKvrvvE7u+N1+/Tef8X243caIZmSlebTjmfOytUg1TsGKcx2K9X2UTl9lV0ujP7t82plgxXjhfk+6UAAqUACPEwAgDFAmM+iM6OIjFZnMXA4wwADMwDAzOMbiYrBpwoQ0MFBCZJeiH1q3G6pppIXTBAOJxSWxSmgm2/MzVuPFTzXca0Zx2B7SNLaZkqKNizb//7kGTljIMsPdIbeRriS6Sqo2MCSo61B0Jt6MuJNx+r2PeJd0tquqrS1z747r3vb9Oq6tWpW0+vuZZf+S3sf55frOewARaDTckAKETFCiYhMQ1nSEQXyIAyymHZOyaMtMhuTStnP92bsXaxp7LT/5Kxd88qPr4OSZfoPuVcKdReWzjyuOv1IRg/4tMwYkYtcVOurmBKTkAIbIBJDpkzLEbzmRQhjEQCkUBqeAQShoAMZjrWmdh9GxFsezic3OKy2brQbUsyTQ3iucYUWzPoBGUMGMqBmBFWVWhfK59kOBhmJq8OxP7A1zEXemxVWUUp/UaqR67AHPOcK0AEGpgJQyA0hMUVK4J5C1MpsTVjEKIGniMw3zTLCwM0qgpW9Pe9b41Iq2ZdTV90InBX0ZClhQJ2LZ22ka9g7PSy947i9SyjGpa9q2DFBKNfYFjoUgIBhWpGtY66Ykspf0hdABrtsXUIkww2043bZW8tXh+Pnf6JmugrtOy2sqdpspHb3sCwUjyAXZE73m336Ttr5fz9rZ9yv3vWyf5avnLaeiU/Xvv9Xf/7kmTpjAOsPtAbm0LiUAg7Gj1jXcy9CUxtPGuZMJcqmZeJNjzswAE5QCBbNYFTMVhYcXJDHxo04JAIcCthsAMEVRAcSVzwERb55KbyViTWgsYwatUqaPPI4P/I7qw0xEBkTigSDS70JLD1kRMrSES1TFvsLNmF7zxxS1iKwKM2rAAKcABlfNGDACAQyfXwdwx07lpiQOGJzcZaCQQIkgkcWMv+PGKKimsATb6oLBQCRyjAWHY1Tuo/slYZi7EpgjGQRAMRjZ5EXSKIpKHp1K5Xrvluhmyk1GtitVbG9pO8///gz4nZZA4xy+VxJ8zN1grxPc/svkEGagLBzIli67g/JVQUQdlM9RCLREQB6yxLxEd3C021n3Yps2p5tX3u+6/G970IWx4N15FDlmub+hlZeTTvSptJ5/FevCLNUBP+LpurY3ald/v9CgAE5QABITET4MpjURS0QgUZQphwfEoeMshg2gCwggCofOeeX0zlcA8TuxOJK8QnCwV4CUc1qQMufvGDaR0r0VvO5yzS005GbXgIEYBERJ56l2f0XHgIQ7v/+5Jk7ICC6kNWMwwy7lqCihNvLzgOtLk6bm0piUwc6lmHjXeW9KlGREgnOlJxaboz8kJqfEStePhY+FiizT1gCotuNgNVXa7S7iIqdkhlE3MyOWARs9aGQhY18WhiXuYKLFrES2Xtv1E43H29Jb2eD159axl1JvxnR356h4J52PjYimt4l684/Shm97U2J1wG+t3X/oI3fgSfImCE5B9IBI0apigujSvSCwYonZZBmob2pBXnod1dt7XWjV0qx89bS/8F+jYMrPkMqX94nrvtbu3+uPbbuOm/Y6qsxvTzrbBtzexL0dm72M0HJmjmugpy3AEpxoIXAFRE0RApGuC24wO9MomBpxgoEholSDgNeYZ36Ou/Q6CLk1Vs7G8+sTBty81P6/o/42nEI9vJS1IGSZaNdGo0PjKqd1n+rQAAHABBjTVUeMZkMA3k6URjIhJOhAUAEMxScwEpjGgpCwCCYoEBBBYu0kqrYZQFHQcqJBZfmCUo4fVAp5R2/D1M2FxLUGRXG5Xhm/SVMxFihFHIaIuEVxmkLU938R7JD1/fX8/3//uSZOsIg5xBTxuaGuJVxsrXYQZdyzUBVswsy7k3HqqNg41zNTzzSj0jhn593vSpl70e5e7405MmfsAJK0ALLZzxSPWZgcgBr0y40DxskCUJqdQdUvcNVvMMYcw9h6YMcImtwYNoAk1AkPxO9SHDEc0lL0fDJOlJ1N4eXZvlui4lCS5gEIid5DqHPrYBVJWbSePKJlMhUCm5KAIlYtIMWFBicpOpKAZywMvyEGk32vFzZJ5FtjJrVApFa6sf/blvNMT5/+NXrnOgTY4T2KhlCpuJQO5CnzfDEsW2dLGZWirqa6HhTb+H/u3Czin9ISYEeNA/VskGLUckAPVSkrCFIx2Ik3VeTsQLxgQ50iPAvBMiqFxD+/6wJGlmYVP1+SIbzYlqkLhJkQfkb0+tnvUX7mWBmnG9/CbklWuVHhF5KOIdDEIAFO0AAp01MXjK6lMeDs58KAuPDCwJLTCx9BxGLVGDQWG1I9x5pbSkX047DJ6F235fx5ZZDr8cprEr3SfAE5S2av65mpnEqq6b02NVf9/j+ms6Zqq+98+t9S31vrcY3v/7kmTxjIPaRE2bmkLiXGP5828GSgvFC0xtPGuZN6BrqPQNdsZ/BoZcZmA9s+Rk8j/6xACcuABq2TchkJkKzBhIsKnpn4kBhIwgJZoDipOcnjU3kTYZUnYhVTplVHgqy63JLfaSm+zT4Us92vzv75bK8Vds3q5GuuaIxqRI1faFJaeUY/tP7lyfXhFfRTpWBPs/Md6hCJTbcAQ4qWoC1iDdYCiz0T2LsQWEGpExkh/zKY2i29zpBq60HZ9d/M5xzKpSjXojHZcSSJrERx0fScxBJ61K6oro4wYfqZUZ7urp8oGGqHxFIHGZzjhewDZtwBAtDYptwpjLgKvmlFltKAvuX7TCC0wdp8ZiZU4WwpZIV+wW8duHKXshtdp/pL/O0EzXTVDmWfkCVlQHFIcjb7WPTXQnU8s4gYvsJod2Wiyr6/9G+n5Al/YAJO4AwMHzhBSM5kMz8oDfADLZIdgYAjL4CAwcMHAweAh/gyoHAWFZMwgOFQ06CXzevUIQUrgx97EUjE9Hpr7k7Y+7q7nn1iBx3Iw7Cl4aMzzY9TYGWf9iuf7/+5Jk7ojDbjPPG5ky4mHISfNvI1wK+RFXTBiruW4XKE2sDTGd35TgZWdPpSgJxltn8sFlwqJ19BZ75AAU3QAqYmDJ5k7KYZKHcjRh46BoAsFRkoaNF7XDBik4IERgh1YRhqX4scwY466Ubr6StiUv9J86GKiw2HQUVSLXidcUd5smU67irblYGOx167Hs9wGSfvtmdPG0bx/5KmcS75R7K3dg0YwRNcTtgia8DLV4oDmIQ2noEZYHHSopNVnvNpvpW3+Zn0TGJ/PXWa74mpIpf7AL99McRz46V73PLQN2e2Oz1cv8y2buzeJbN/zM3e2y+/8s1SXOzlpgqUc5O8OjMW5LIAkS2HwdgXaqiP2lypAAy61l1T55hhMm2yYu7j9Wpkwcluj0mj21zg+v61vv3sie/vXm4f5TS0tmpVkdu70ZVz6/L0smgZfLzIBMd6DVADc/AMMUP8mM27PVqR3GSwqBCwcIQAYgW/JSwLHonN9xReG4FkcQSnzrdn60T1hh2h3umpN2d6v/2qqqGKlSXU6ZDWObGcpGJLP+kxZZyHk///uSZOwMg4hDzpuaGuJlZHnDb2hKS+EPTkw8y7FFG2uo9Zl3kJCiy2rGJBCsoKGGp5DURgt4Iyzp5JIJy7cBDicQKYc4YgEdMGJCAcOCxstchE/4hUBrvpEGhtY672EPvRartBsZ2fxw5T471Y0dhgHQLoIRa7CGZLSVyMjB6zAH8j7wrkzpjFeJi3SIL6Ri90ExowMUgFS7gGK0H6YhUkfh4PcguMDt69zcEYfKATVQGprbcKZTJsd+HHJazPx1Z9u9MV/3fu5c7esa5rPXdKqiTurUv4hcJ7e4xDmfKdpGbDHDPdy2h34pbL56kUPIfJLtAPjC9VZIJk3JJALE0Q9hB5Gi5J1QPo0gyu6uZpq9JaKbZE11tq7vdH9uYi2sYwFXKGZTpUNj18ySpaLQGpJaRtOdlzs5oKYbgM2e0sizQ6eycVEUekPJpQA1LgDE745JpEk88YgCNMw0LB5cngYYUmBgIwHhcBFoMhStcKBW1f2Go+3Re1sMRBkompqzMYQRvH4B1zOz9fXlqQzPQaHyGIcyKuJGI5GEk1YrnU7IUf/7kmTnjINAQM+bWhrgWyYqE2sDTAxVCz5tYGuBSCErKPYNdhqgojX+92Z0tVXV0nbFgradBjknkGC9AAoMU5I4ApR0RBXxE1CsQx0OuuQMRzBPA/q3sromparvqsbIyr4h85v7be756bzFY0okXeBiaslL7G33fdde/oIw7dFvta3zv9+f+fl/ntifmWJoYQBkt4AM7GSLEzAB+RtcFTJ0QYyCFlZESDDKm4vQ0BGzMN0uEdjJsG0jT+DjZmOBPZnzWJHgqTEL01S+gJiBmaU3h1EUoShoDQOgYGJhGqeIsyTiCZFLV+ezn7f1c0wbKV7/C8sQ2GC49uAxIX0mThGRVmXUGAFh0VuhFBKCLHJoni7NA+rbRJ/Ov+2GWV2t18OY40vc8s90La1CuFEUIo0d2FmZmE6UZzP/PP/7pn8DHCRUgEnCy0Kcui9dkCtNKglbvwCq8HTGJiBoa4GqDgUnZOg2xJTZBx+0QdxpJQm52BoJ08kORkEl1p4LP3m8akzPAznd63tTIFKT9BhGIgowTzVL49F+c/dIR3ej8I9zH7r/+5Jk6owDcUTOG3gq4lUIWro9Bl3MyO08bTxriWMW6A2sDTCenP714eWmgtj8UKwvMGgC25gCUAELT4jwDbXOalEJhRCoCxMaapUGHIHfqgD8O2gbAKy5LDURYnbBSI1Zp616Q4QBTXuwBlr6lnP/kMEBoxKDsVyudWI1GqVgBu6apasm7M3RNFMtrpe/qSc1SNHhugAnLQAr5CSmDGw5I1UwMWT1kCgSY0CFQOFQBroLwl6HMWHYlBYMHgHMYy9cbVpmpFMTWe6t3Orun7hur3X/CIJm+kiETwIf5OZ+HACNCyuR0p2MWS0wQ+ziQoXQAGl5stFsvimncU0AXLuAyQ44rMLLzOzEoTAoeBwaIhoxkZWaWyTXAexEHBtA78GoHQbDjIFjSIu3TavQdnP3u16md69/5/zPFygdoUzp8Raf8Eq2WBgzf7UpqfMdQktMs7pqyxlzYmLrHgAH/0gdMoX/dQlLrwAbsCPJiHxugZpCJlGpZhhg8kS5bZEwTTebrWxjJEJ6l8wDTfVvz9DQ429bvcxw/8cM8N9CyuI+0GNT//uSZOgMwwZC0BtvGuBiSEnDawJcTOTPOG3ga4mdIKdNvI1xnlPX89WBQlssV2S4mmGCwvcR0oUyKSn/+Ni+ZDdEnG/IQAAAJvtwlAuRG5BeTF2mtxxHNt5HKQjEWNLGulMZbtXYMPZ731SBSBdfm1aDEvG4yBQPQvY60uWiY4vjhh908uNdm5iqe8zyR10NU5+vjmv/jmf34VudJHDLFeuL/geEJWTcAglDKhgwRgBx6FAYwINGjRW1PVLlfoWCjqeRLijqbDwdmx4VNA9M/f1qCpfpe673dqxrWV2vyo0oISVmCsJ1ECfCDRs53qnTzwf981N75k4Uy2ss1sxP84GUjPuZCKl0hBy3gAkAd7iC2YNGkrcLKDWkRCRGr4ZLhYoYOAFQG1mQpCNVVxckUvsXGCy7szFK/bPe9wiVmp38eczYsCa/kMlMnk/pFlhGZu+guEd0wbews59p/K8LL2P/MEyDIaiMfRbqAAAdr+wHVJJofS1l7FVuxB377+1QcyzzpygtAwVPTc3c4g6CVSj2uhWXuh/THnVL+TJWNCGrt//7kmTeCIL+QE+bWBriXmjaaWHoXYyBBzzt4GuBih6nTa0Ncbl5ln0l5Ij6nDykpkWXPz6ThjPCdUSXVMAAAkU42mAnA1ADePWeROSmRZzIdFN4Mt9F2s6fyxIde+8+L61lqyIy83f2sONCV3Lc1vaYpr3KzFZncpKid4Pj7SfsqDR7GcPK/7/vbC6hIkA+DumBTl2AHMhp9wxIMqDNOmnxrKHApGYcEBDZIFNSnUZa5iDDosFlEMwBAtyDas/LaCkz7T5b/G9Z3hlave29C1jg3kYeZuRh+0Ia7m7CalDGTlxuytlinSYZYyCZi6V9tmiaXECWcxYAuW4AwsoOKcTExIx0pDEdPELBgNDzACgxIKVhQlgN9UceIIVvQqKVPK1l0ptUFixyB7tP9yxr5v93/7rvwGgFTPrBZHiuRlAR7eKhFmhoBLDIyKG0YfdFEmvnQi/zUypevTzGG0lv180FS7cAK0jThxC+MaNEp5KaSIEActIDiyHddwPRapFossV/Eg5PXh+Wz8er2dWd6+z3X1rH/+9YbRGDTXOHfdCLh6P/+5Jk2oiCfUHUyw0a7FSkuoo95kvMuQE6bWBrgaOf5w29DXED1NLTMsim8P4ZbK4UguV6ft6n584eYLPn1vYmZAAUtSWyQBCH0Awn0GxYOTwfKJQEHKGkf3fnqflXXNTBblPFkUY+dHv/9l6eiJWtU+MK2pEoQU2GK1//+7o3Xxq1GU89w/dmhv7zJk/FH04kIdklALs3AJXA5lCMdHDD0UyIMQ+KAIwYYMIEk3kRjBQo6ngOLwElkyBCZL2/aPjHWX09W3hnvXbH/N3sPrfj+zegIu/5nb7T90DUygCapGfh//UcsjtpY4Xi/EyiEX7CMpUcV4APieDogRdu4BCQM7FOO1GW5jFhacZAgQABiIcVVMsUnCLhYI/bDbTL47KI9KK8QxppyrurhjrerH71l36+TMhkS9mRGjM9qBWIriCMCanSfGsyEutbEOpKtGci/xnDbd5cVeh3FQAACG6sEPhMppxc9SDDmLuU9SrIKd8EcTZOF0iRSIrMlrYkJkbGKCb10VI2UpSVCFCB35Dqxj8jqISnRhhlVblf9Km3RViZ//uSZOAMgvY+T5tZGuBTR4raMQZdzM0LOm3ga4l/nqeNrQlx12MtSI7zrIqFjEGip3oJi4gOGCB4NmAN7ugUeG8sjCo06XaQHuksmFypugEUJl8j3YqpZOcQHa698FOr+s896RYxFYoTF8M0ZmDIXUr3pMvsV8iehj8SbOD2OECZY10bUIFOIBiQpBo68VAAbdAMDFY4CNjGqCMGkc4MHwcSTFIFd8WL5mYFjoYBgzO6RXSuWVpEQYEBUsnbo1d2Eg6aMxqdn5dR2Z7eLv41csNVd7tZw3LZP1Ij7wMFYyZpcnR9iResS8e0jIis9As+myNvIWNsF37Qw/ruApNOACqR+7m/IZqZ1BAVEOnctAGPTFATwEZ+S35SsSbdmIRGDbWTp19WKLHfM9Z7y5hz/5jkRQoARdGKfdVZLAyuUwUGWHzvbd79NbXOuk6LlSu2yvoVEW9lcfQqAQJpyWRwCHiZzXqicEdi0ai8VrWQtNuD7a2so1hxzW8xlzIcNizWycJ1q62li+XM0E+aTZBGnuJcqfqOYX6adf+MYuGiPuxsM//7kmTiiILrQ9LLMCruVCbqVmGDXY20+zJuZGuJcCJnzZyJc859vbbW3Jx2v/4+Jpa94ovyXQ9qpgEQCyILWm+sQIG6Uja81N/1FRclerHExauW0trFWy+d69IjjnFYeaYreHnDIGDv7ojcP+/xM4WKLzXfzOvUr/3nDNj/yl51PPoHT5DlMeQwqrUwJbh+wsGSFAalrrSE50/WvwE5AtrYqJjqa6wstjJdbznGPnFIn3ea33qusvVwT2ZjFnI3UYPJHlnZ1W93c7qQynMyVIcjHbd7vO7XtiTK5A4gi1VeQegF6wMRnDZXkzGZM5OThncCEJpBsYGOmLDAsEGDEpgwCGiA8GDQqpchLzWUraiIh0o8FkwHORuB60TRc/NRKR2oGLk7hCJoE9tv7+dzFv3tPRpSlMnVuD1D/qs87zVL3q/57fvmPmS1ATkuAIFU80sMFQDAWAywAMeBwMemBAIMEwhTQEgAAHzvewWdHiPk7UAKfd91a7qRjGep716t3DDd293PmVr/mKLCmuzwnU2PWpv0ubKu+/anp16i5tK96un/+5Jk44DC4ERV0wsy7lKoOjJh413LDRFGTLyrsZmP5gm9rSn/6uqb1GT5H61DxNCg3afHnWgAJSjaQCiQN2xJs6AyHVNLDNGrQ6zIQF5DjNN3/i+ntfUk28X1e1426blzT6pMgFyYIDygESogKmI3UK/WpENBj/RhAJPNhqKwwhThoca8V7prHb/kug8KjDCZkafWRg9WBjeAINMkCkRgoWMAQvjAhHQDCpFHx6Tbjp4FX67KQxUXC4ihnH5ZP1JPSy7Wdmrnnrdz9/gE2AXc8gArYYr0yRGA0hoXeEkjtJCotw33Jf+OTBuFThaXUx4Syp5IRdcwBKhAdyMfFUDTGiEHCgABxUKBxSRGpcIEjA2G05iyfKlkociIT7pymhcaUTmNWxle5+erGX2cbXPqqxDL5jbIAtRzoCOCU4QG6bIE+1JP6FI3dXtTf1NKdCX2VhaVqgBBGSccTAGViZkK3SanDzyvWpgy6C5EBOIxYQC6ESjnFLIGrxk7LFK6aXdSS4UmhiHxOfQpVJT1dvoJD4x3WTJSjJWh1Wr8lMRcfFQf//uSZOuMg1hEzht4QuBWBlpXYeNdzPTbLi5ga5GCIacNvIlwKa96Dr34Kxmw+SHupG8CkwAjdMBCMSdkC8Mi1D2r5lSgbJYCd4D0p1A9VMk242KbVOIuH1853m27ZxjX+9BlYUbKaqMFcQzjMxpQZ8dwBc3+fvr6kXwkxGY3l9/jdP9KSq8wrToumglHZgCWvO9Bw5CEoIykQSCMCBhYIAgsBhgvYYmAhjnXVDWaym0kE8S81Ho3NPlY+USfVfPDP901793Od32O4I6tJUVwQUxLQdago2vrnm1yR0xPoKniWE2NE69hSHreJQQtA+rkyOIg3UwScs4BgosfOMmMC4ACDKgQGAJiQKVQIysLQkpQN3BXlKnSDF2jLLGjoCJdIONFc3WIWJses19Qn2bbuqIExRTmv6MldhJmVXSrps5FEKuo9XV5D0r2p+y+5SILElUTviV6AGt0wENY+0ZaSMSr1hlbH+gBWBWR9x4Zh1jtSgyeTViBPneYGNx6axh/ndrY9vVZB8xfQXttibuZ1qqmG4SE9GftW9pFN+Lrvjpq+P/7kmTlgILoQ1PTCELsVwgKNmXjXc09CTZt4GuJhJ8nDbeVcU/iqXtGLq2n3Jk7edAkm1wCAw8OcUDmaBGkKo1DzQt+gePAywCuoNiF+diljoKw8HC2TIpBpHzTW968AQwRzGDIpzBmvGK/isrfASNw4WlSZmYFKeIhpkYU2cQb3ooPpch5diA3aZQGXZcAIL0Ht5qpCAjpS0gHnEBAWpuRGIVDFwD7XYbZ9Zc1tHF6VNGxTtBGqK/HKuq3/lr6l6l7d+/lvkY8/O170+t6GCEZAwpFXQpTkh5P8500TOV2zJJk27GIwQYaC7rt7m2t2wJ1DbQUVB1AAEQmCQiBanigJ0msgMQR4PR2qbQGa9bAnn72msRWZ2bzWrFasWaORDTONyL7i2Ved8162dKdLHuKMqSA66S21omwfeP9b3OZmS/1ot/nZS/BB8MotmU+nuUqBNcTAFLkFV5gJGZaHKWIJGyqqL7a2upSwt6OOBgOQszH2QlEupDltNHnvmsC2fe8fPrjUA/QV/uAWFRxAh4KgYmLBMgzaBDbZ6iOESEtKGf/+5Jk5QjCx0JRsy9C7lpF6eNp40wMYPs4beBriYyiaEmWGXe2kzIEpyQrl5kfIR4/3BhQBWuqBnp0W5gA4sQRNdZmzSGSPQ6D+DNnTV0ZRSQVE377ZS9ZvazbbHiU1iSl96SwsGKfHj1MpS1VkEg65TTjr2FHrrZTMnJIUGOiqeQaNkNS74i6DXizMpyjBY7oCSj2AML+TqRMzc4MxGBAHgQsUzIhIwYBGh990oQmnxiKYMtOg6k8NY92eGW6WG4qjUOsudRH0XWMz0xeMlFuRQMXDu7yXDoWba5JTjH23VPFFlhSXKAhmDock6Z19QymJ4eKV81FQcgi3XgAsKnSqBM0GkBRmAEOBQstOXCBI8AAKX8ASzuH+JMISiwRPKTSZgkW8jbY8R4WY3y7tfEuv4RH1ed0Sykc19Gn8ex1yIkIU4MzbrJZM/MvheS/v8hHcHSt0Hj5KgABWKcbbAJaSJNCNuVRhkX5LGpxucGDXpoIDYqu1fNft7/dG5jbdG1jeYyHrAZbbn7C0Y6H1oRk82OK+fVc2hOsgF3Mrgh1ZABw//uSZOcMgv1DTptvGupdaDo2aeVdjPkVNm28a4F7IWbNt41wiMizuPeE5NPwQlAAAAS3VAg2dMaUJEQ7iQrrPzDbaPXQggzctcWxmPdJbPKDHzYyWqcSRe1T3efuDzJ8iI1KcI0bk4nfrHOf/StPIzhOJJiMMqWcRPKUQgokbIDV/xRKrAqR0iORhczmCRAEDpLQILZUCgiAimQFCpCAAXagMqEUp6D0maSwwE2uTqklyzfWJpomZXU/hU3X9+Licr0/RKZ8fMd9ZraEJ1jnzIn69eO7zuTVn498vfzpqNmYq/Us66fUfLqoKioCcd4AqmnwjQKiTQgY0QDMjCQ4cKg8KC5WJgofGRcYYyFlDAYYdxB7sqZ1FYo2+t4ztbmfL3MP7+Xef/xkkA/b9PJudrPGfqXVY6cs57o4zfs3/87++lM5szeZbQXtbDM3YkWnWUXjtGvnvn8DACU444AFosxcNCAYZCBIjZwRE9tQ4iDFb1/BV4uInXFLpO5DSwgshKBsaucYvJ1m8+havCMiJG30Sof355O8EkTZk+i+flXMrP/7kmTkCIKpQ9PTKxruU6fKSWWjXc0lBzZOPMuhtKKmjbwZcfO1PPyrZlfbyUzQILGGvrQAgD7ckjgDZQ57TIo/Egitu7A8uzC0VrQWfFSfThK/XOtfS1Rv/szoEhNUZmIlmuZeZkdkEmcxZ0e7s7shWtYjUSrVazvMx9rjlN9Sxp7ML0oAJTgBgJBZiiDA8s5hcGxleHAXDcaOYDAAChKMZgHAwImDIln/MKEp9I3kikmbM0hWtfLywIxbVNAM7LnTxoYpazdG1q33VDlmrQxJP1gP+M/X3hMepyuZ6tnCOG+ybmmoaXILPoIhP5FgwYsUZvXHZU/jAi1KuMVxOMU5GjKEA3pd8eTewSGFh0qiqIAasx7nMSu5+xnJfZYiEZw9gUzt7emTeVC7yyP2SbDKwNmrajR1qoXtQbW8UnqERA/o+bFv+qvMi5hEfBdX7c0RjHwWUH1DqhVJJABFPmDB5hZalaHOYYNhgkwJHtqyPCHUXxAsnnkaaR85XFq9u7NY/zDuvmd7xkkxhL7+Vq3eQiXKmbDxdTG+hoHm44oakDj/+5Jk44gSyT7Pu3Ma6FDIqqphZV3OsRUsbuRrgXefJ02XjXTbvHPzOoV8xgy6yGZXq53q8QH6KPQTvRmqAAXtyWRwBR0S21yISDKT3I1jYqDPP0+bLVmV8eL/mzvTeDLWWqbRdjVfOUPJ5EASXLaFTMc6/GPJAUaGp5qW37IRy+df2Xbz7m8yGtEcsAVhEdYA/gaaIQhUEhkoCgy/TpqPrGQ5JeB9ZRR6TPlzyXZNN/2W3t1c8q+WXcM6Gcv53c7tLwkZElaYokY3imHJDyyIqX65KS/g2pchtUlMEE4//VhNu6Cc5fjzzeoA226ACKMDd4GzDD1oz4FEKSZeDEJWKCRMcAIdbmD/pe0GHyalhcitvwwGVUbLK8mm5fjMXZnXO5frX/zW3oHA2LPd0cYzEYpXdlVUYphJDnQ2ouJvUdaioj77KzqrV93MTHNjITN8M1kIuRwAwTGzFQNMgi4wEWwUtjCYrMJgEswVQSUCowuCgQHDq+4xBn6AhjaBtE77gQPYlEuqSqEZ033sqDdNOazuZ67WKVw5mZk1lgh0dqkM//uSZOOJgxBBzxt4GuhQZ8qqYYNdi5jzPO1ga6mjoKYNvJVxQblkTvFhzuycgj5TQoxzK/l7X/NjzhF1gdr67pasbgBYSziw8zQgApEkiWjkJf1aiWJoFmXB+r10hcN96oh3pN4h61+5hbRJE9hCafAyF5aKRUWC4qkPAeAwXhtDK1ZGlYqROWiYpQk8B+2ZCEm24AFPIHWgIWQLXJJA7L2lM3VjUreUpGjju5uDHVR5SOSYff3qrd1dw139XbGH4XqvLg/jMdq8OqED5HTojCkxmbZ1p+CfPDJ/HyJ3Nm6/qn32PASrB0M6MwjCpHQAmTVtgEP58hms0SsJ+lkUBrLESVQ5OoTEfx76d7sqLlqCqT34w5nV/nm9cpoi03+v2BlQ35iWn1vl+735avjFmEgxloayoc3B5kgrSlo+8m95OgsIPud+D5gkfGD3iaEGRhI8gZOGMR2Cj8NFcwQdTAhdNTCEQkiZqYAZcIABnRTG1HFjOGsgWQR1+mkWL1JOZ08NzEYw7dw1KscDVMLC1zCEFz2wytuo5o6RjznWsxXO1P/7kmTmiINZQcybmBriT+PZ423jSwvxCzztZGuZSBLn3ZwZLLOMruIq4mG5tpSGikntYe7muGvk2Y4FwAiORqABVTOZIA5pBJU76g5bFrAOAW0UBTkEFUbI2qmMxw8McPBp7iXfWta1tXjzWeZtePFFA6GG5ZSjxQYzFyoPBnvp7KR77eb+Rn23/WZqX/S8uthizobdNc3BSpgET2dcTmGlRCPkUiCBMMLGeluo0QALIRPx7IKgG43ZRiGX9j9JNRO5S45fvPG9aqWtfv/5+pAYd+lmrtgipeUjNukqTVdnvqkjtwqZOaqWaVSKn+bxXN/lgXbt5cAWBtuSRwAKMTMjiRIWjMvl3dWxgn1s4zqt5Imz62+Uqdt7n6nOIoJq73I97q87aEVr0UiEUiKl0c7pZTMVjDNDpanVHVGgxBpR8jh1A+bwb3AApNwAwqnPoEjNyswIhJ2ExABAzQhxMOCkABbowsaOGyohq19iEDA4vVJsBszycVFSxzvzG5JqzhSUmNfD//1VI0qt68d8/2fut4vtdfWbvJ1N5MhWeI7G62P/+5Jk7wwDukHJi5pC4FyIGddt411L2QE2TeRrqUYgqmj1lXdnfPhZmVex+3+WlMfthS22znpjOaAiS23bdrZADZGMqFMeUONCnjVayQRe1SybxLB32/Gfi14B1dRKe0fNqy2AwtUuhd4WoN/SYuFJcGZbyLrFbkH73XnRr3duFsebp3HoXf/QqVOBkhGf0hl2RIKItBeoCES0I8INABgMHBQvoMG0+MPy2VUdeVUE/TQLfvWuf9irU1dtSbmWH6z3VROy6EKeMYmjIJO5EIzqQ7tRCb0O7qt0Vz1a92R2XWW4diPDTJHmE3HXLhJxvACmibWHmKCJg64HYRigEYGAQpDIuUoI1MPtQ0hc2TPxqGMWTLkhd1GSkzxpuY2bd3+Sy3c1nynz+eEhxDcW531IqA8QkZSqQ5U1Vpqt26nZVKn2fyJcaUpeguKO7aD2AAEdRxtMCRk0HSbAohU3UxtTGyBmEIxNfK+k3dTeZ6zbGRx8fkzVJdQbMU7hXFBggWPhojtububpWWGu14i50a99/W1b6SPir+FqRG0+ahe5pGIl//uSZOwIA3NFS5t4MuBPJIrtPehLzI0PNM3gq6mHoCZNvJVxIRS4DFubvIGMHphaURbSipaFqKNhZxPwdDADVQIYeoRyUtp+noOaR+FDcX0tLQsRafSue0zXtc8TVTofu4uVtrOIZ2VjLI67GfZU9XT2Xo+ttCKaFdR/FAL36IsIEa8CULHRC2YLIZAYjKwRQlGBQEjkgcKgQwKADAQKDVqjDguAzZ4moww+9WBY2pjRWb/b93cRxx+Sf3LW7utlYEGKnz+Q/a5TqlhFMtJZWjOiG5d+eHIqYPq7TNgEMQXTbz5jssKYVMAQb5v5CEDphpocOMGDiQFDVFG5hwwiEh0PEGAn5dBH2Uy63CX/cyC1rTcqzr2LPJRz9xG/jLa9HS50yHYO+7uQ4Ed3KYxrfn/duvVn23ObrQw5j1vOxyEMKejAmMcQJmeITwJaAEHw8YTDGQGEKSHQBAgcMjBALEIGAwwA1xpRHjaKmQXAqtWUCv8PDI9xGfTSpMad9e2yMHkajaFDD18lV/Fsr3U3S3EstFrmhyqImqBtWoPgW6L96v/7kGTpCMKlRFNTCULuXGgpkm3iXUyM1S5OaGuJliDmTbyJcQWuJ/qKrOiihkkWAJd6VACEW24AKdZDoAozCAwNW0kRo3YOYOEjQSWmLOneYjPKJomLoX6uSthcpjocJRVr9rKn1G+75atZXN91/F6DHhEcO8C+aal5kH4z8m5PZk9NynciLIv4c4Vy/OyAy7uWaguSYgWqwAKgcw0kpMYIaGPh8DAoXWUj4TBiq6yRfJ35Y9LzxO1VkD6yLb86+tTfdy5/4z9jvc6Leu3xiOkgXZrFcg59JOi4uXg8g3xTaIeDsjK/S9y53RzpMcGqWsEAmBquY5JXqiAkrUfFRWGjUyo2vTblu/D76gYQPXS6Nd6HeK/G896xuYg3xxppBIbZW3RDdmW9mdSHUrpMVLUy2LuUy29Ka//SMB8ShPAB01GaBLblgFFo9psRVMMKA6ekoYflxwMOoGjAqFTEEuZTHmlpEQDIcXJlE9MqX02HLOWWWsP+lvd1d3vPqXcfZ1IRrEU4xUIYY575KmFshXQedpjXV0MhGVCxF6VZXU7lpf/7kmTqDIMuIUqTmUpSY4hZh28jXAwVAzRN5GuRLx7omZSJdyJQtlYjaNJEGI1gADOpJG2ASpXhDbwqI2KljGR1cRv8IlFH024Cfx+3jI9RGwuPOlhMKe181NzD8Ly6D4dlF0HcxHC9PQ+aZr67i35SJq6zrRqMRHPzmnq8wD78HF/+A76P1HDlLnhm8YCg4NARe1dSaIjBh7j5b2+91Z9/N6MLrDKl+za5vlfHn71+ta7l2bpAPuYelr7tf+freY5TFbBDWlfNbYy57u/3as35JV3kN3lK1Tv/3xNtOpEncrEjhHf6oBiEIAXUXlQvh51ZTGItXrG29iUWBjuSqhHeSy2e19luSprYSk5mAMFYlzrs6TLaiXqqkZWXJT1tWljON0FEMOEzPDQ+SNo6VM/bqZ4AFgMGeI7kujNSUMPg006GjDhbMMjAwgPBgNmJQ0FQQDRUdkQodhIPL6oUPUFgyGWBIJiYBmgoIuw98Rlsvkd3mdXsalGGN/W6+OGkRSfQqi2fa02vCF+pbY9ZPaZd7vLuXbXzpnFJX9jdKp2z+t3/+5Jk7gyDQ0XMG3gq4FKHmnpgyF3MTQM2TWTLqT4bqOWUlXecbuX0NmWsPMYJnewEUm4AIGSLg0ymJzGBtMpgARCIwEFVyiAJP6lqmeRSXi+0qfV9UE8uXO7T2309pfh3Plz7P97M3btizveHbOEZupzPYWbW2Zzvu1juQtMhTLpRJGVtVWz6SlIyqiRbKO60cZUCikoAYV2G3G5hgIYKJmwihjQWYgApmL/Gg4wMOBJIcLaXzdIBS5cMSZmZenvDNMptau7tzPNWq16pTWc9cwq54bYEEHWkI3y2+oZ9MJKprlqZR+/XYuQE5CPBEVzcv0LO8gkZseZGPe80+38BAVtSRiCownYyT7blvcJxm4hiY0AtqM4D4JMLKWYxjKLIfrnQxlN1G3mqikSs63YjzMpL6bPVlVJ3ksVLGblaNRx5RUoqwTmiRxj1RSIOBFrDAdmOdCooaBjMRhgHZ6Y2CqMJMGgEKwCKCIJHtJDQYmOsIR2QQgpnPtNEQFk0lon97Tc+iweC9Wopm5jv+f/8mA6nE67cskxs+RE2t0j1dvL3//uSZPaME9lASRObMuJjCIlzcwVcTYUFLG3ka4k7Iyno8ZV2NL87VpMXfFctBFot+xJUUDQjOhIBJPHk1/9lAAABJUUkbbAKoSjjzKJy3kK7lIJRkLReEyg3w1+Sp7HudxcvySAiIkFssPcMLTIyL0OuSEhLxD8y/KrZHVd5+RSoRsTThBDMiYo6oYrCPkfqYTkYIASbdAMD+DYRUxY6MhHTNQ4wMSShUKWcJAZIBAgDAgFVXLdputwINqKxxz8XV39mc3Y3Er3Obv2Ofzm/lYCcclNc8+8D/ZZtJ6mLXqk1bpm0oVlXnb3ftXlEqv7mOrFcZGVzZ/78PxY8AQU3+mARAjZA8UOEoGOzD1PNuZLKUNEz1Q1MM1q++/kUWw5VvOuLTktDJMnnQKC92cpsLbHLPt/bFtzpQZDf/ZTeuOXy6LuKvbUzFdxzzTa9lxpM+KhsI5g0WgABPUkbTAIXI0WG5tTytW57O7OBxi+9xl2gkibMqm7sgzvpLGEmJ+6wFmCiI9BUXQcC46FIiExq0m9MqS0qW18jrI+huZtuIBlXrP/7kmTpDAN7OUoTmkLgVGhKbWDDXc0BGS5t4QuBayEoZZStd2uYIMSgQUKLA5PZGNVfwAFopyS22uAF8BpPLpEdItSCYECIZ8dFx+8zWAnq32oKpsNNy6a5lb4KMvv9bs/3c8z0pnHhil/Hx9VUP5tdIz83v/sn7a81pyboHK6DF/AEltwAwZGgzNmEAKYlJ5jkSAoTJNKnMAgBLkRA0twY5soXo6qXyyy/LZWvMCe2nW5SUtTLlXdJ3ec7zVjDPDDF5QiEeSHHpjQy4YlBZ7llChOaDx0I0ujvDjqrm80VSuG8+CGEIFCuhpiDk4edUJVYGCCqdAQRiEdGAQKbMAhQGR5gJFFu06l6FnAoN2mavKzSYiVK+idkhfxhc/Iq0oywsU9W1yN38ss6/f1JgxZ2SiLtBysdEHCx0Ow1tL3Fw8znp/kzt8VDvVNf9zhQwDFjkvBWmgAAGf7cCTFluyq7Q4apZumxlMbIc7rqJlbzNmLI99d13j4+s2ne09PJkQU4QZ4x2HkcyKRN7kdyHQqIiuxolMrTK8aQiWPr07o1F0H/+5Jk5IgCzD9S0wsa7k+Fqr0wxk3NtQUsbmBrgZefZUnMDXARh3GylEh5DsMYsbCdsAAoouy62yAQBYVdARkKb+NBij/sZmf6pwrjt+d1B9w85rtNWwHbSB49LMUuXNqI4utkhqlq5dGRKTtOo14uKpaT2QfOfC/tat/xE8jFVhRb0gKuBieeHQzIYNAhgE8hiFMHB5IUsqoITAcs6YRFpw001Eu2g+4CKU1ZQ/juJd63SU+NJulppJjSY8+5z9ZcFCiBhJSrCH0oVEfckQy1YvI+wlPmHzPyXEnP55c/Q6fqEDtAehgxpcMBD+foFJtwAhCjuCQyMXEZgaUBmAClOp2woIDkE5ABmME25TjN7BrUexN95jjo1b/L3N57z/Kte3zHWPcvAgVPMXebkmbFfuYuLXTY43TpkR50tFkXz7Bzw7qI2/mGALX9OAzCAAAq/poHdAZ6lalbuQA/fIplavkNlt2TrGvV31TqJT+/h2vfGNtdsYksOQlg+TsxxTbNjH7Gu+cL9WdeFCJobZnqb9mV41yLP/Dg6GKU5wMgly4B//uSZOUIAsxDUcsPKu5RZ/q9PMhdjV0FKE5ga4mAGyXNvA1xFKv2/WAIflQLAUcEVqUGAmxZgBGTpuoyh5Uu4ZF4QxCYWqOnfvOfgEVxBk3PLvNKfNQOhV7W46WvQelkADEOg3BEWhS338V38+3ZhnWXoTcIHRG96/yGf/fgCtYFZAdZWwNFhkEimghmYUEQOUZdcLAAmDAjAi2jStfAsVVAKFZ+EPk7L07rkQU/Yx3b1e+lt0meWPLm8vz8e0I3WIy6CIiCOsGvDY0T+FZ5lDGl16REnt2FwJXQ6hXdLiShnLmPGmQP7uvSEEUlAYUPx2IJgkaAkxCRXHRAXIR0VgRxcgqoHAjYZTAqtjgKxUSjDaSOu1qL1MPznPrXs6WJiASoCCGxQ6RzJiPTsd8AyNPdLz+uOVMjQ/t3BueDGKKSaDr3pm4kOf1J2p7KaiAk3AApmHJy4CkjBRM2IqBx6EKS2lOShICwEtEIU0p33/ItSVa0tlS2vjOqmeX5RqzKubzv5ZZ77j/57dStij7Sg4/SdaRe2i8L0YjDCbXb3MniNP/7kmTpCILDQ1FLDxrsVUMplm8JOU2JCyhOYGuBjZhlTcyNMGDXMoePHIJpco7I0FZC4s51QAlFiAzvI4TdHsRsDNgQEiU0icBp6rELZAfeA1xRxFFfDuZOu3Kmr27eO7/N2ojvfLOO/z/WuMyCKLR5CNI9LVHshDsrKRTWcpiJdTOyofRiOlEfWe1HNaIBLRxUSaJT+dpKACmEnHZZHICgAak/DSsqqhoeYuVkRJyQQZaHWFHESvaFSXv0oiLSJ2webH0SNTz35FAlVMiNu5J7R/5ImnCsLbp07mWEpyYZ9TDs4uDQ8LntXXtrMTSTABB0Tjpb0EgQYhA0So39n1N3wR3B5rcORcodJ1+7pprDCzvHvNcIMRGEEmQKjKV8S8+ZyXkUm2C7g4Y/+3fpW4gg1K9oz/NHByoo2i4AnQaGyX5VCpvBDPH/yJhoCZmMHEEBgwGXbAASYKHuSIQ8VADolEVqKSiXrECYc9LFpwXFlT385Nb+1aoabv4c/63N90MMLCc672moGXk301pz2KV8yMp0/bS+Um9faYv/prn30aP/+5Jk6QCDK0JLG3ga4GKIOXZrJV1KhP1Tp6BrsVuR5o28DS2ZRJ67fPHx4KE/9IAADFJlqMCl40QkwQxYYBO0VEq6Vri63vFAYRCzBzM2UQHT2aKvYws27PdZ5fc7lur+97/uGKxIJfKtXZlsVypdlRmql1UhSs885XWVi2Kei6VpKYjibjKIceINPGOPi5CI3ov1KNpuQGHXH1MCRIVEBxRG9a9RjKNau2vAe0lBeBNtxcJVWuX2UM3feq/3pNqNfOZrQpdtKAtMjTl+PlTlKFkU9ZcrwSZvrk5zUHPrnVHjJYZCDcHDBmHKGCN++FdBX+R/GAgBlKWS2RuA2B0t713GvuJzRYGNL2GPR2vDNi1ZxhilGJtbpZ/mlZmeQoaXtbrS2+czvT1m1fcyBISKhm0Tsc8TrcsihJwscBqQSWc4gr+97X2dYYUFZsEZofetmNl4JJDIgEteqdAWlyRETN1Mxq1NAzpl4ImjTDsSgCB7rN7N2vb7r6TO1/45487zmucNkatl9eMVLStGy/dit0T5/nCHQZ2qt3JSlcvdWuT2//uSZO6MA1FBSpN4QuBlCImqawVdDBkVNm08a6FSkyp09hkuVtYKUkGjaXfv5d1YAS03E4BHUMkOAx0RhyIeBkD+NeS4clfqBABfR8c7A51xCd21iAeNps/W8y/G3ttZzuN7l4UsqZmzmC9DI9QLVmJE8rUHQQ1F2HWR+ZmRceJ9XJdzMvLI5gzMMSDZUoc+d2eSJ2fBAEPGyBrEw5howwFZw8JegaFuwnuFY1yIoMFIi1uSVLpI2uFYmIn1i+rYj68SP74tRiFVqKS6jVc42kzaMnUzq50mcju7qVFfWpCshConPZ9xJxQhQgQDFmiGrYzv+KlJhu0AySNkYTChAkI2HDQAWSGQJFeDkoHOI+vnW7pXPsnhKdxKfpmz1t4Y/z6TvO0mW9f+Pc3dzvlKhiOaLa7FP7f6srGPTZpDbs10Za6Pojs2uYzaFECzLJf3e3UqACHXJaAkYc2khgGFxYDA5cMFBChxaBlzKIDDpTr1SA1moY25U8mtTYpNfc/3XOIv3Ht80/qH4QnwtXXfdX3L6M8lv3P36VdSsjWGXfxNuP/7kmTrDIMdQcwTeBroY2g5p2njXQw0/zJNPKuhdiElzbyJcP3OR6RZgfSJEF3D++LCwc48hEcIACI3G5gYH8AXiCUAJTDAi+wsniBESbMMgKCEmTzgkwdEi7zhEUjqSS+saj+u2LIYw+SvcZsJtrt9/3VNMx+Wyg+FQ8QGvSppE5KBt0JY1yUECJykRlnFafQjpz2mbpsMKJPeOMitBgwSDDQkoWytVROAlCFqjci5MhdEc9fHes2gVxnfqYGIZ1Odkm/gJkCzVeErF1hqa00JMHS4COrOGRCYFCwVmBADKThCB3NiYGwwgQxk/tVZf1NNuccgEWxnRl6RwMMQaSJFtJXFdydUMwiT5cL5qfSWmeYm77oIL2nmSeyKJKAMivdogWICoqZ1OL9jMReRug5ERju6u05/rXLqyZx8yRr0I6izb3kfp9K6BTTkwEYmdGOmIJoMFhIya4HIKqjXhoUWkzRCF7DOP1FkFfq0ZMdqTvrmbW911e8lt/Ws500aGR6OcEOuc68LaEf7LNKQMa7q7ERfIX0ORKEQsbEgjPkiImD/+5Jk5oiDGD9Mu29C4lzEWYdp5koLfJsyTTxpYV+gpx2YFXQoZUBlAD0da1SIwrUAQArUpIK6BU5rq8RplL9Ne26GcZdAAUcLDFt3YuiQeZqvnposclQpUq6Mhx1TEaZUEjCRjbo1xVe65mrTdaq6UYzWfrd6+2BWAwKGjTiqg5RSICLC4xzCT+l6AiW3aBh2esyFBBjiCtRKMDlKDSB4sFTZQADzX9rw0/jopnW6sUfqDHe/mWPPuZfhdu8s/juxnw5YU/ZDpnmVmVyMwx1UpjSDVQ1DnKxWfdSJzZWoaqsqm6FEGEnKpnccQ41zKj1heV7nF9SQCknGATRGTp5ggaXENkECqKozAoTIiBYZgLpFJb7NBeMiLn34m5x6bUZU9Un8tZYZzffw7j++a5/rYLHLq9tkVarOcrkp1Uy/ZkbOrTMLVZNJCutKpqdVFEJLH1nYdcz/6QAFbckbagYSUegNllNcvYW8a9QN5khXSD84/m/Vzu1obtkzjVJZLdmY6E1jzHKjD2+dqQdrG1dzYsMxrK85voDOjNNF69JkDBfE//uSZOuMAykzy5tvGuBbKNnZZQVdjWkPLG1gq4GGIiVNvJVwNnDw1KgtAlZbWqkOCONcTQ+UAB5t1yNtgPoonrYcK/Elm8ZrC4lp9Bp390x5DP9ac1j+xbU5o7d2kPXN///I6RGzpANRZuD6E0hSl+ppLCfhiqQRoNGFOce5M6rzZDTCe2j4KzOX9+pIBrNxuQDEodGYCJmAKxsqYI7EPw+nK64PxWWT5PG40WMB1Gh0nqBgzoKU2eMjcvGCjKcHkiQz/BZ5i69mO8cjFYISGDk2fk7gn/ZD0AWZAzE/r5UqdxYDVM4PB8Ad5YQ2RXR/dQAAASbbaUAglHBLtZCwYeWsbU4XI5rqwNIQsXByQwhMRptDarSRfe9PisLecPqa+fL9IxI1L8++v98UXCPjnI65NnJKRwpwxMRe18i/P9VLuWYZeINXNNzPVQAzSthKtB/4HCDRBB4uW6aBBM40ohIDeGNDYoJ0LtrxKp2iDC1asv7jiSF2SdeFJAZG0ThklSbWfAik7HjQi856gLb0qBsAZRha4j9cjS5nZmXBv7/Pd//7kmTkCALgQdJTCRrsVqiaWj2DXYyZBzdMxGuhZR+mqaeNdP0a/v/f+lMjgh2GjlIfgw9EBIKPIVAi9KE0n5mBBVSdDeCLXFNKJ9EhT/Of/8Thmm5/lsptBkF7j5n14+Z/+i0nOXBMesMAwpCQydDb51AobOBR4wQtYFXoaQQl1PylFztBaSalBh+p7UZVJDZQDkwuMS9ZpIG5IpKTH1WowI+DcaRZ1/if/arXd/Wv18OUuVzlTVrlbut4n4kWJGIuq7sVJsLkQPDpsd1ikPFQ1Coz0lREKcl6XubKX3N0OnQx+o9uBHS3pXTVaysZWsBEMfGngwbLCEYaOgQHCHGlMCwMNCFmwf9h0tWHLIWoQ8rQKMFJQWl8lsK9wLX//Wv9wm2XqABtLmEGQ2CQOtCblm7Q8bckwYOGwfBYqBDL3MSkBpoST/vuxm9KACWWkVAAIJwSwiEgaKET27NbYE/7mANxRGGhzK+QTxUYufq1hPX3fOoce297Z5QbiQ6QpJlD8/SiyU+hSQriLB1NbsKpFHoJ1J5NyKnQKS7O9nzNgdH/+5Jk6ojC5yNMM08aWlvEqXJp5ksNDREqbWRrgXaNpMm8GOCfSbJD//X2r4f8T+W0OKTSLgAvRxrMCEBQGWjg8ghyXegfBTOwnxYmPQJCZFJI6Y5siyfQSZ1mjLrrXeEDeXfUjXT6R07089bzkzOeeR0/L5l0onnelXU5w+aFtWK9EvZK94A0MFYQbjaLgNPk8YQYcAASaN4JOsGuuDUepANaHPFMRdI+d4kHLTqu/vGn/i58Gae1NYxZuaAkGuzJqY3/3T1CNTqCrnPcow97n9Ychdm777/xPb437Zn/e/1dz+Ypu5TiIROKeLsGYsUegtElKgsIx44uYSDiAcBUOqQDGCBwd4OujM3crA3OX3CkTpsVlEPUJ7gEjcZZUbU2mjCLtGNivI/Xh1k4EDwSEYlcxkyDSC9iiefeLhNsWpFFOyooqftlow89lm+FqgAAGalFBFM6oEbC3K/3tjFWB4brS0Qi0gPxIATkMUQEKDHH83Mzyt0q7dyAKzo7kMRSpNK+iEc6XldapdjK6o8iF6TOkz00UzVUtEirjRzqsccV//uSZOoMwx4tTDtPGmpZSJmTZaNdDNEJMmy8y6FzDOUNvBjgKBhzvZ2aAApptpwFQwuaFMaRaepoDop1R+KRQeEWzCdC5L3TWLVcvT/OaRP/NPibOIVKSEAY1l3Mh2SS5mFzyMjO52Oy85qFFjkSh319pq6/51nvmnF0of8q3sSzIAAglQAS1N3bw5CMWawoBPUNGKwaAwIG0aUzSNj+Qy4iVk2D03XWb9q0WFlV8OSi925Oawv5rvmQcJROCGCD/sPSdnLOHS/0nm79MLVUL3G3z2NgpbW+BqYfjilmgEdWM8H/XXa/mDvn2/oJJRcAVSj6xAAmgADDOQBQ5DRmQjCCYBIhUvogLXlRRNE2YDDReQQBdokRJzPV7djdHhvdvD8t6u8yjkBkQqtJF3O5yWTXk3ZVmW6SPdASqVvpVam/57jsZUdGcSwIcBH6rxY9vJNc2RoAlJtuOyuNwByZJCmgLFqGMFTKwd91JLKwbXxHqTk/e1x7bpsOJOVTfaDpOcz9A07uZVWyIjyKmzDxSpkMKOdmVUIiFdTGniVox0ciOv/7kmToiILKQs7LCCrsV6hZt2HlXI1AsyRt4GmJoqFkzbwJcDzlMhhNrkF5FGNcWxmTJagABWq2WDYH+gnhe2yZPqhYXMMZzpE5AIVLKgb/uHPaTYjdTJ3Tyfh0OZ54cjomFFOH5Zon/14LTLshG6/qWfZxCwnl9p8UsjuzOK1pXte7W/SsAAAiimi4AJ6dJJg2EpI1A0Z1kbEIJ9Zc2RTuaUzlIWLUU/XOZlt7arJCbc/N/bO66tpHhBWohmo57T0x6B0ossgtYiucqn3RaIpNlupRcUtLJpQqJHCAsHAwhlH5UF3YaY1LFKJVzi7dBsqkoIQkgk81/JX0eeV/YdkMAtHAUX6UOXwYuRr+8Ou2u9R1CY+iKdnKb+54PnlvqqAyQetuF8KDJRxmwhMRaUiwkhCjP3m/kQ08lZulTUssKCQsGnN+xo+ASbeqRJSToMj9LQFaUCCSlQgKInQjFDQBtEOpccslDdQDBIAD8rlQGNgm0LWc2vGdQnHTNX1vXfxTwLIlXYK5RiJ6eZuJUSIPdyqzF7w18+mXVn0mZCNo/5P/+5Jk5YCC5j/T6Ysq7FIIafk9Y12NURcxTLyroW4fppmmDXYyjRgRxSN8NoFMXf1JJNLWiKikqssGBYQ4UxC0RBC2aHZ9V9O7jQsrI2QJnDbHpt586SrneYjY/L945z978aXsOZlPUCs5mlZGszOvMQ13Z2VGyoKjZ2u2PHGaa9w+b6qRFht6+PPe+0n/73Wl9ZVX7uKRFJFwAm07xWMqDEZKjqTbXW/b3JpwPDEJcR2I/YLtJWy0fXr/ObzyBZsx8btSklJQfZ5lTIKexGyDwL+oqJabz4tjvonEY4vlrEPys7qyjQBDUQQ7moND0QZAd1jA1H3kEnFlRirb4MDj9ojKkEGwFXUySDU3eRcUQaUEJjFOxlpVWtuduT997t57z16gKPqMfOgqyXhVKmqt7SWxHWo8VNDBcPBaYJCwmS90dzpJ+RLAIRMcBfv09dUAJCo4O2zXBzAnDFlgN5Lhr1R0KwJQBQ+RuFnULkkQ3ujoa0inUBmnpGtu/h1g1rHpiHvHhnwmqp7ZOZHfch9x6FEUerOQ+B3pBz3pIZ5FmcM4//uSZOoMw01DyhtPGuBexgliZwVNTJkTMGy8a6FQEqUJrBUowIo9rWMsjUQMJFQCVJhblURVir0sQAID99TQXYAVk/OcvUJROFJoVjVZQR5u8qQfJVppNZOjk9pr+7qepAUIcAU3BL/5F39hrA5+9QoT4TvNjhetRIpjZlqXapGiFpc/DBMNidSEO1jsVqFpymPKKTToFbpxRYCRmDXDzVkhQMGgcDrVKoJuA2J9rT7uJg/dVzHrhMend1q2tfl9/Kz+sM7u/7/7dhQ/Anb9BmOBIbkoIqsyHDiSsNHOM83bOEWr5kxNnNJV2YOSHAIJFoo/EId2WUkJRRNEKBfRzsMYApYY3AqAJRTFzQWSSXPAcAMsKG2znOg1fn87ANYMMtMZ9nPgcunJwqtVGeUnsokIgfC6dLwOLMWNela0MM7RBWE6VG2Tmx63oroESa0lFEGAA7giMqqmK8qrFIIVnaLGZQwUyVHiEILRYabGmFgo/987vcmKeyDOvOu42DTKYLn5KR0sYUhGZUhZvM+frBRnuVZaVKkZfMlalAX3hIWDLP/7kmToDAM9PsqzTxroWKiJ+T0jXYzo+yhtYGuBVRLlzZSNLBNzW72/ZEF5996bXhu30AIJBIdAgKHF0mRJCq1c4MAjwZ0EAaNKjUJIOuboeBmRKhqrrOEoNWDuJqsPO4Wd5/+vr3HKhh0M5iv5V+yXaRWczSVdnTKREN29//qvVCUmFJVCoGc6s+evTRIM1AMU20FAOSozIJAKsPD11a26P/8Tf1xDGRbs4fVP0JPcI0zacfe1PKnnwwNTCGaG/9IjSwGDYhghrI0YgxlGM1poGLVSWS/FI/rHDPbKhbCMbYWWWnSu9E+i9zXkgCygoEZD7qjNpwspGACmL9vaYsC4K5FxO6ijeCVbR5zq1rmmFrn1ee2BCcwv/PjNAw8nCOObugtNOlOhAUCQyJTA9QYCYRUAKkqTvyr2rQq0xdsc/OvqF9RAklPA2DkL317iJcPax0KYsO9zexNJOGRNzQaWJDWHwW4ni1oMv71jMaA44m0/19/Mud3tZrp9Z+dDjHJE6uhZbIYnhyGnzmW949ZM1alkWx/Ja5hEQu5oi7e3z+P/+5Jk6IiDDEHLGywa6l1n+Tdp4lwLjP0xTKRroWKSZM2njSgfp3t5/Lv94WKZCRLoELx+1iJsAwgAUubSoIwwcmTJ2W1HE2amAY64JdCdqWE2ikXmxquRKESGqAxpiuMqrkQrj1x3fAxix3o/NRFUNgTj1oe0HFFrsxGWIyRM4ouOigmfbPoHxKKvZGXBZlEcMD02ZjCVLAgu2k+37wq0vGm+zNMrWSdK1slgaJTkyOHPp3I5rj023/pbPRyagiPB5TfclMiPYstpwyfE9LJgoHF63b/XLPIzXfMkbs9tBzfHcNXP1rnrWg/JJFkQkSqBwgS6IYiEUyiFKWeEBKzBKcV82XqUTTmaSKYJXJ5mRhi23u1oGRTo3PvDtzMnH1+z581/XzHvGnZeORCAOOCo0Vaxpr9emu+w/QTJVy0khcHgHVYqAAXDQ7UqT4GWBIYIwowMXMSCCwAGAAqHokEpDgMRhr8xq3BSBO1LXeaBK4B7y/+e+cs/U5Wz+kx+kzUHVRCUoPAr45MOilEUKggule3MKfTrGt946WeYi6Jb54M0//uSZO2MwzJVyhtPGvBhRNkzZehKC8kPLEywa6FgEyTNl5koI9uklzyXGOuW28oOJxYohF1nq//UAAARSLScAyADw1rvr71z0ApQK1y22DD8jnD2qbi9yaUmnjs+ZpYRXW5Xdrq19f6OUVHMFMJHIzrV6bP2LtV39T6arSrq6jimiT505w0wiGMOjQGiBSQAMicTMgLJmkT+oSSmUNskjDE4vDjtBOwLtq1IoPO15y5TwHDXgVvTciqm1/ale809jz6KOowRAhoymRUKVIvjyn5EKyeul20+94svn/CGeYRRZ49rwGdLkB2XKqYeg2itAkJxy2WyNwHBAno6nCGmQNSyAFaAnfEwENc7eJQyEndN26RgxUaqR0xdRlIev5ZKweMMAI6JooWCglUTqUgyqLLVU6Pep7vwJ1h1MRoqAEXDHqE2NRMaMzLEketzCAUiDVFSshJg5PQEixtXSUz6j3FphCZbMNxi0yxye7Xz+V585lcjvOatd12nglyOuDgKENY6Bn0ZlU0QJUXPGsPiTSFrwqENew70QtbBEHOxRY6Hq//7kmTtiAOPQ0gTeRrgVggpmmUFXIwdGzOsPGuhNhMp9GQNLv0wYHCQCQ2li5xVZ99aAAACSTaCgEXAl6EhmzMINYO2SJO5LJsdzjjhkQA3Sel2NVN6nlSJt3zFXXUwZNtCMRztVGNXPEKW1kKV5TaofSh3ou6f9bS1M+9R30EIJVCPW5TjvF0CklKAJRNsaATUEORGMRVDAqCMu0qJrTUhfUThMFK5fEenRvJKJHyNcxoNbqZc7zDf5b1rDmyF1Tsggyvwq5Xp2fkORQ9ChDIzPsXCPU+TKdymWjx+ilGFDlSD14ESRX/jzH6nPHu5bX9UABY/rpoCwZtND2XzZMLig06EGNHaRDYjVHqhrbJl8W5z00drIjmGeib6HY5R00cPWNShJ1EUe5CPiUrLuhDN0tLQ1UuYilOLuHxw8QhoONjQJWcUpzRLSpW9FQCSi4AI7nIm4CJDDjMSIUABEOMBSUdSNDAKG3DcNyJAyRSAaqSKI+D5wZFkDFKZscosuizMyOpZofWykkyMzjMp1wjKWyOpf05tWooyb+GvfhFVIiX/+5Jk8QwDkkJIE3ga4FWIqYphYl0NSQkmbWBriWmf56TFlXaF7NP2ugMFRLlgkEhHT/nP/Vv/L+8G1AAAOrKOAxY5QAIavZ+BQF2J8iPIgYahgw21mbAsF2p5ItYsqC3XwL3zWe0PHxm8uN4pdG1ZjhnumRn50TlmmCM6VX9IheZ9CyFekRMS8Lh2EVT0MeEPl0bMZXLuIkQ+/cVNiEAGFNJpwGWpkA4pcEOxDjJI4zSBaSHQREGMuU42H1qe0TDPvU0b61X2pT49cZ+SSsc7R/yjES5yU+GPOX/peuqCiLlkOz6YkFEeH/vsisdDUOwOqY1zVqXuHPalhi0YCTo23E6yRSc7Vnzc9pLQILfud7VEx+iICOUk61/lCkTYyhjXRSrNvWvXcPbXyz9fRimrlmqrophOrSlWUGVCVXWe9EdWT9ivnJefL6f6hDzSIKbiJBX7//pVAAAKaEUMnvBVsIMF2SJonM9juxVThnrCBNbtD4Ol8nbyNc0hyfL6b5fXjw5J9b8985yLmGhKoi5B/kQTMpjMZ3ZGda2sRTMih9jm//uQZOmIg19SSRtyGvBjaJlZZeNdC9UBMaw8a6FlpWa1hYl8Q76SKtUIYPzu2hu0ohsQJgDP+zQihz11oAAACAkiiRcA6o7mTcZG28VRZbq7MLj8VB+NHcwg0tq0+5WP7ext52zRMP33xuuI9tNCB/Ol/nTEMSSKXbg9IeYdX/yl2p5lL9ikXOpc/zvio7gOY8BYrYqjE3KZ9olrAYqJEqA7LKCptKEjyV9OO6jrxWG7ESzFdGNmNqLLeQ//62+K43rGWehZosYEAdpDDH6URs8rOVxXkO1jOtLRvD+53/LT5daviOEcIhr6zuf/2xvJr4KGTYxvQr11DAIYIOVJf0g8PGqpjQ14GYs6IG1dsXiA9xZUNNatpJ/qDk6bCogL7pv9RqrLBikJHhiTkeYg8VdB5WFS0I8tfop+W7t9z0HnZo4qMzr6deZVekYNAPKWhBZ+puEFMwZBjpQBRQX83zzx2D4eW2AUfLh/CNh7hqLsgPuuYm4s3uc6hCcKlhCPyh3f/Zw3b5lHqDYbd7SSf4btUgqrmrjj2VWiEaF5j4Wl//uSZOQIgx4/yktPKuhfSHl9YeNdC0y3L0w8qaluJ2ck9ZV/HY4yBBYfFOOMmosoArcA3sFmgcChIQOtH9+9nYt6zAKJBcBgs8ZySIWmLjrSUEzM4i+s8/YjccQyGncCNypY2qPPCPKr5fzPu2q+xA5x87YtdBEO7Ma/iamCmjFhkuEihlE9EAj20z1ZWRliJsIBUAnUA8G/nitwqw+VwkaADkt0tuAguDguQ2aMwqjj8JkVqOhKIWOqI6TqeTe9UxesxPoKZ3SUikzdsM/aJPzDmVgaw/EkCp/xgwhX3zQzU78atAplOR+kU1IGcJCiSBl2tmjeAMuAAUATt7dbdZALTdKA2mw1F8KfGmnxnem7do1jP7d9d9rGVFPjDM6gZjZjR8HcpVlVf1KXotDqJqciA6KKvXoztvu7exrSkMgiQvlXg04QCFd7fhI7MB0nSGSjq0Kfs/01FHvDX5TT0BAKCGIk4bVXw4ISQVeuoQCAApI0DqQ7B8CnMkZJxwd6750ydzmvIeYRQe/a/1bexj7QS2+MQd1eZnt6pgnZSshOyf/7kmTmiANxQ0qTS0LoXiP5E28ISgrc+zesNGuhgRynNYeVdH7ooxHVIZOkpgGr0C3rAIG05JUZr0c1EYEWOBS+CjUPulDcPyIdAgFweBYQwuRJhXuNqDxY6z3MdR1kjGy3i2iR0IPbtBfR9kOcZKSh3/YKWo8EroC6FtCLi2AhHTutca8NkW1SkQrgOusTDEe7SCASlAajinXL6XocEgZcL5hAWjkocuh5iUYA0oM0PEYI8IMHNJA8dNTgoPQupZsenTZjE4uutlUT2gp1zs1DwjCiTwhhToKMi99VUVXXEAvMlIk5C/VUum7hkIGmqR29HIPEawKZ0SoqKO7//UpQVcN/LAe5Ep+MkJjBeEAyUCKay0K1nOoN1WksnVK7Lqqmk9LaprqS3/qX81lje/Us7Vu9/f+ZXHH2+c4PJxKSMKOREYUx+91YIA17PLrDNVXoOz0s4calKu9RmGiZo4eJRdKanf+hAABBTsrbaSQ4NTB2Jptft3Z6is2yu34T3mX5vaVVz0fQtS1VN91PJxfQt4a8V/7XrEXWN916ROIvUwz/+5Jk44yCuETIk1QS4GCoOTdpolwNrSkebdBLwZsco4m9CXAxxqComujdhpFZWZbgq+UqI5xQSU8dVT7vU5zDI8gZRUn6J7pKrfmd4/JfZ34aAAAL7p9NQYF/QIwsoBUM+bi7f1E2gaRhC8SJUgF8W7JrLrXOVy+66FS9bVpSYfot2ohnnXBHoHRSh7rM31CnSuvTeU25GSztozE8ggTUdSTtbVNOhS1PPByKRJT/vWAABCqSabIVVPJsUWIBEHF8z7SG2Y7Sp/iOOMWh5Lgk3/eqUQzfzn/D95nCdPNYtCj6cdsyCB0ej+g2Ji8UoXFBj0v+2g0xNh1yDvzUSObts9NYkrjI8KOuaNocJFO0FhOETlv//0HahBp1R9ygQPQQsVRQRqlTxMWeBygUhkHIIT4sJREGpskaGY960eyGo99ps1JBK90qwUFBCNQ4XMjSOVn/1V/3f9aIRvbs/1ZqurV3+f12vNN5Y3/qR9qFPJSTiIGk45CVQFBwVBVK0kq7BXtdFkIEppIqIeWBrAWEE6fOnVF1qBzoFWolCaPpomZo//uSZNyAg0hTz2sPKvxeaglZZaJfDMkLK0y8q5FfqaTJqgl8cOpvMnvv3VKki1UoqIxo5E17ZhWvoKfrjrvk6JsqmDysMWgb31bfs1c9E1K7eNFehPFNDvJAAAVfS63GLIGzDI26rdjyn4JhytUekJEmdQPGY3u1KWaldMgrRMzzMpF1pEGgeWkv6fzCjoQSiTk5/bcx85DEIfc6YWEbCLlu1pXd0k3azJjnr2evs9y+gBFJKTbySNthKA08TFZfG6VS1KZDbbzWGEZ+NWs894UHXwzS4bi30nj7miaeo266P5kRMOyQ+4DJFlmQrx27yHZfYXHH48YjoKncjxDo7qxTGNYZwZaUoHVpLzhGk+uDbO1n79QEBvkbJRLXHVGNnayW8ZqveqySEk2MqCoLRXNC2SgF0Zn2djfWvWTCzqydP3WrbJ2noKp6///eTTmr/n3rF1RF3dvXhvu+sQfFHbmmkvEdeTcH7jl/ZTva/uZ9Xs+pABSab1+0scgCkCJTZ6szVFgdaGvCLrrM+Un4bw4sQhZChpCOrmEg6WgsSzlMBf/7kmTYgINDVMibdCrwWCbZimGnXQyNDUWmPKuxd5bldaiZNFVBDGmOnylYMIBxWQiGOCP6KtrCaihBgou6X1V1lchx+/WIbAMlzyJc+LgtSaLPfh1ie00pNY82ACCQHJrEkkH0DwNcjzQ7l/V+RTVsk09/WVb3r/ZO96Y/v6rjrhRE1hvMPNxnIDBSg3BORPGxds0sD22kf5HLdaPf5j/UmvNQeIGGPjaVXzXZmHks2fTLzVNUdzMs/f1Rvn5QAWW5L99ZZJBQgOgk4OLIMCCUWYsJK++/q5ezraZyHDcdcqUTUWsdnKijB/3FtfHRT0tEyh00xxsRLzqhC9zIxwgCbi+6td8RjQ+PqO8ABdUJuSQg2MtEBxXJM66sV0x4AABnlFBEgFWeRSYQE8w8zfl95t3GTMKbqEGnB2ghYFGTGqI2w5de6tQgR/YwwLJZUeDfp7RfTCaHJFlX++dEt1UUvtb5aiXI9jLYw6HBHA6MLCoksXwIpjVWNTsX1b+xKgAACEdJYkkiY+aHGUE7SkwnRdKPq1516UHFD8otirHwMqv/+5JE1gADL0DR6Sgq7GMH2d1h513L+QlJoaSrsYMgpOmliXStq5EaZQVb+D+HsRqDAnTTE9OwIyK/azAhtjnK6tbsR9rCDNVSQlm6oDCQHKjHUdz2XkVWvLtL7n6dHqqBTcbd++11tqQEOmLwiqg/Qu/uNs/flBnEjUN/PM9JQe+QR+8qaj/p/vpC/w+SRxadb3C9p0XYYL2wZHnopLqxZPZBxX/CBMLAU7khefNZfSpIZfXRJetPczQAVG4yQSSQBxEibjdV6ifwsZoN9OkwfM+iUsdmbuEQ9Ip7+45ulLZapWQ27JMaeycGZSm+D1uYGcZ+X263F1vYHprlClEhhSlEAbbnLfcl231aKvc9Z1b9b/a1foUAAAQFH/ZpdVTAOquGdqfkNLUuSbGyLmW4WG0WgeofxJ6B5zYOVz1YySEh/R+//sfDFQbzHrBOm9CJDMpDi5f5Zdzh/g8vIiYFAQI4f9dM6OpIjkk232ziBycv0KnkVQAAAANN7I42FyAHEJFMrcqMzMz8Vq7DelAEVOpeT8sf/gf7GH3jSam2zB8I//uSRNAIAvI+SmtIEuhZ5/qdJSNdi6E5M6eYS/F4IGa1go10Ph6Fxcs1Lm5iVvYaMOm/F0jTfi1VnstXj++uOb2f8Pm5MOnc7+1jZA4dMqW93jFWJJFn77L9OWci3tFwAADNkSYREOJ3vmSCWoSAYi/TgscaFE5gBtIsNw3JRCVESib2hX+YV26FNhvTFrrQLwbvWjPk/8Z/0NsXbdOJjZ9Tz6si4j8bWlpFFf8OSHQM7WBybv9p1F4Gl8912+tfZUAFJcUUAEhtidKA+jdWW0W52JvuCA6SUBGdNz058pICkbvrJFZw8h/Tbd/Vp8OnSwZZpJf2znOoQTJThOT3i8P/IEcP/2EHin6QO0Y+qhr/nx6GKn/n08U1ubqAbUku++10toUU6BQowQbUOJnS8mPJtNg7I0rqN38h7vaSI9I8auOvmIhbbTU2OhyaVrGj6HCccY4eFjioohELGN3fMv3mRkXQ7qLEEhMeODj02GjNZYcMKpbHKH+3Tezf4dUCJEM1Zou3uttOCxx7pwRW3ekdQmQbGkrmiKyrffdmbecU4f/7kmTVCAM8QcvrSFroYecpSmVoXQtc7SeMrGuhiSFqdDWVdsy5nBku5qQyDm1ItqEuULizq7wYw4fwbzsCg2+RFMcN9To5TKcF8+zFnUPmLkr//tWAAAABClCSkQr+eoqrxgiIUq1XiksUh6DQDGl51VUujmsnXF9+d959f9kvRvOJRkWgtctVBucutFNKfBmuV2TMzL6NufN9kczKz7VSKEOMK9STW1uzMq3dnU3d1AAEAF4vRItoCEOAEKqZekdcTOEP9MQ0lel0CjosJdIEXwy5V6/yR2//SyUDsVHCUdQUH4ipx+pePqP5W+TqVPzW2vYh6/Sfmuoj//ydb/mpGWxclG9ATlkZbSlJNQkT8Vf6Ue1qAAUCBebs25KApiIpckDlh7tLvWbQBrJLficSKL6bGkdjpUqK4DuJHi+PVV1og9/MZqHoj6v41WvunldF9nxGn24iOBfE+ipO6jsUA7qKlva+JrijmBUAAAA7yTxy2GLBTFx8nlqwJjLOSiaJUy0cZpY4AUZsZkOexz9Dkeh3VpnR0mM2Vx39BSQoll//+5Jk0IACoULVeScS7FvIWU1lYl0MrQsrrCULoVcgJnTzlXQ/3SnYHqqsDVrb5juz6MOjhWDkFJER1IxtU0UcEngDCbPU/6vrASMzNGiNt7ZLQMnZi9ShadqM/+H+0fukF3MIC5237b8bXh2J0EjnLjXR7SurVmQPFB69RVYwrod8plbKWR8XYpQVORViiuyoUHd9TBQSWNiEms+eSzdcqDF1ivSAAsaSuORhfgZBs7lYS5oPnjBAMAX6pPk9byxUCZHR1jgypQqZ6Kz1KrGkU2ywHdgqKhooMa+sNILDZRpBpPPBo5ewRNWOBsdIsQWEjlqNkkywa1VsR/+gEpNSXW3RtuA6LPIH7KNTOIk68lgTJjsZMWkWL9z7mq046vtRVVn0CW337eVPqHqftt/+lTslzVfY+O0iOpqw5eNfB+dPwNiyjJ/enVlVOo+pSd/KKgACknNba42mIgHTpMb2d2nSyvvCoSZf7g2xP+bVSXGXv90vrBHMoCFHqbQ5cv8rfmRSEZ8iZByMrbYNf4Jx8LhtYuMCbA+WABM2xIDMzzxl//uSZNoIAthCTOsKEuhcJiqPGeVNivRjL+wk5yFRk+j0lZkuQWrU9KjCXvoYU2i5xfe6sJttGb773SShYpVrz3VNmcekh/7gPU/TQ1uXW24CpjIPnlqQe5qNxQGl0tpcyw1rZk15+4true4zI5WY0YfYy9GqcZ7hDS6/UH22vk1pUtnAX/ybwx9fpmyuvU063/TA/tq/a/VL3/oAAglu2yxtJF2G0zyNMKL9xc1H/TwKcd4iVP63T4ZHIkLcO8//xha4VZDO57SEZokaOT8/M79zUzwRIGP4iEYXnoEECKaQapZnBqp0Oz5BZy8WIJQxmly/0gAEABaf/a2sGqBoGJuvJqmEru7tR0Y2yjIUG8l3avmR7NLKWraih0HoiD0NRp5GWyEY2bMPMa6UqYp2k2nW9JFJcialO+7nUjnK8axw2G2DR0yLCgOk1HC7002+78iiAAAABijRIAB0+AQtpyUafbdIOhiNyuOvGJStryLs0caxvJ+avimqdvddrV+Y1nkezk5btdcJbP8jH73i9I/zyvCy4eUJ9SRn5+eUPzJPKP/7kkTnAAL8Ns/phhrsZ4Z6XTFoXcsc7T2noGuxe6EmNYaVdNfLhL7Qtyp+cp9ksZDJiU+cP/S0fKoKmrqlp6Nj1hJqN6bba2SQHedYQYKvf13hbvSPnAT5E1MKh37LeomH50lEHUpnt+o17V4neHewn/lN7Mv7zhHc+kc44Lc9tQiMQ2Vc9KkJLHK3qaJgyG+1e1rN3/QB5jiRJIFuXchtA8ngjCYr7MUSizHS+dG7UxwNlu//qBjJTqwy2t9BZRFAqZFAWeNPBIQzpAmdm2mji610KQHEJZakUHTuRGEB7kK0CA2qsMv9zvXpoAQhpxsokFFQHpinGz0lHazklIER9eiYoMfjTAiv+viMrHWx667z9RfSJ0mMOChUc2zwDlwGEzL7JZ7RptY9bD4RFkSjIqAn9ldvsv/Tq3NTAAAAAz7bZIJjcwjHgouWrTiSogeGnfd+OsqExbn6JKBIL03v5F7ec6r9PMdrR8Z8r7tzPB3bmRcRy3O7ZU3XI3/FoUIwZSwSZBB49aobn4TurL3O+WaCsykHLKvbLDgyV7xlSVP/+5Jk5ogDZ1JKay8a/FVGal0xo12KtHszTLRpcUCMZmmFrOaeRcW46H7opPpUkAAEHjT/WuxmvCECNIh1oeE9axvTuxgckghtVLh+PvqTWr/ZvnVON3Ps023NYh6cp0j+mUKXMrpzn9MvUuq/p/Sc+5Hkt8/DxbCe5IX+DwplxIcLCZboWECILKKPpVt+31gAWt1sokzqABQ8WqQT1WiL+i0Kg+AmtEe/gPQiaKnW5d9V/GtbztR5zBnzq+st+8XhMW6HQeVRzkjcm1B2SyHcmrqVjOljsjPRDDoxikQbGigZQREwqw+EKMp49xYnGniKmP7zK87YhAGaoiKrR/vtNahJWIj3xEhhFIm3TAacb/K0He39Q4kOxDIbr7IjL0CN90u/S51SjzpdL9HI9GIZCadavyrI/bIYeDYLOCIchFhGURGWyIC6HHAPvUGVm/DGrI/KqgASCVLLK4kkEebKQ7Qo2bx0MLWM8S8aAz2M16oUftK7erNNPR4xWYVBUJn9fp9I/LbZhj1B0uhIlVYQabunpWbGLAynHAdKSRMe2Iov//uSZPGIA3w/yGtPGuhhKKl9ZWNdDRDTI628q6FwIyo8lYl2QLpZT93mm9AAAAMfe2tckIYHsbTr7QKCFamsanlGhQHZcU3UuVCBtGyGhJHmyxfWADv3zuiEz7lLV6uqmfVmfNNft6xqObXwaAScqVccASXGgMlSkFnIBmLvipQcI/e90YIlHd6kgZoZmjPH+9sksEMzsVgmnBpa3w7pUBOf8ZJ+2lUaCGlIbf0HcNlysexqyDgxFYWorzzvdm2+Xqk8iG3m3tuRl8v+28dvfZZr9yOV9yov967Q7c73eb9tVjptWvAd/XVkxaO7ZRsE6HWAhLqMUzfOrDk7YqQLYyVDailnC9DpWfxd5P5KUq58w/nHqvpzuz7lbdXEzbUGQhsjJKQIo4U+D9Z4VL7jdKF3/CMQKl4LMyOzUmMsXutY7lPQvNDnw/1uoqmUbxkYgZUSPUKqAiMzJEeP99ZJQJi99LeGc1t2l/UFCGuekyhHNHfU4fCKnw2hqxysxaIeaFRoCoMYheCaBVFyou5cBP2EAtqPa3PZG11UjqJ4DePbNP/7kkTlgIKnMU7p5RpsXkdJfWDiXQvog0vkpGl5r6sldZWNvPpdjwAAAAddta448ALPZ/Elm428LN7OYG6UAowz3RbOjuosdR0SzecSLNY4dlLI+7LsfyqlXajbVqpqO97O2+DbT/Hacap74RmDhPeLuH1OLMUikrBhlOcRfWAdYAAAEuttsZSBbiFbTYDcvLKvKLMjognVKcYHjxFkD1XHnMtwlQPS4VVlbb3T9tWNfzyz47SUXRxtrxcSBJxffutqXs+urvGQW01S3hkcKIrFNIalgqpChhFINsSkWWHcusA5TxfU1adIAAQBGtdcKSAuoPPJ9J/JwWZfDFe3atBvXq2EHYmC+8bxfXvq+5L6zKaK1B3eq5i3+d1zb+1oHeSt7S3LiSXPrwMEJKZQVs0FqZ/hUubZeXhc1L2Mm/pqaoHXz8oVj6X+fNe0xclYdpI51B1zkoZdXQU023vfdLG4IA62kjj09wdHRINwfHkWzofc8tT4UcWBiwYpRB5RH+Gb03/FpmRfOW98kysJfFBiHBKdBQ6LlBYgoG1JsTn1uJP/+5JE5QACeCfTeMoaXFlnmX1k4l0NCNklrCDLocApZLWnjXz+SYndqXFE2RSpWlvcOBaKbm01sjbYdCxlOGbzmVRaMdLgtIGXOpgMPZGRfQVlCjT4JnjE+8hFD2qhEyGA4BXWC7rDpxyShx6EoUQYyMcxqCD8ohdBOp8vRtfzHr6AAAGiRJTZmI4UXR3QRDQvKWxKwNuqVRds4cMxaeljwt3A2ZyxQ0Xm4QYyny96bOPffOi+3dQXv3KLmDP3kaYNuSaMxRFm+XBYTE3preh05UWfc1uH5Bc1VZxEt63r2PTGoTVRq9hPqMiNrDlhFaJp24pFW4PNS092paBgySxcXe93d30RHe9ERK0RE+XRPyy3vt3f9HnfRER+ERKf0SuSx5guD9IXqcFoYIH7OXC5ubvYTaQDEIKcLqzb97HwQABkUMVmFQQADFUYeZ5qXnas4hDDEAdQ2Ww4neaATNggePJeGJAkEj/aAdcVjD7J8qG6Kfs4CGbtoThO9c4MBjPwY5zD8mhtSFKFtj2jdYJI580/RujK59S8fVIiXlP9aZlQ//uSZOOAArYt0eknGmxPwoodMQc5jBRxGTW1gAGMmGQKsoAA3e7Qqm9fxmLmFuG8VRwPlEqI3wuMx2qFGXbhduxe92BxVMKzkzsSXRkF3BbcwWzVldFlj/MO7NHvb4w1u0VFfP8OoM6dvVh3lhV0WXL1XZl1DzmLjwa6xia9WVinpHgX19ufpEkcWpRPv///////////8SYv////////////EeUigAAkkAGIXmqB54HLxnxlmHOMCpbREfNinQBLDXYHIk5hgAauE/FtQVcBCCApFRCpUNVANQJYHuCwizRkRSSB5TBcGBNAsnBsfyBECIMgp6AhCFlYuQOeIwHJLx0ZUskFUpa02DBA4g+QggZcGRQMTgs5iLFlSC3SUsQTFKitySFxj8J0JoiRdOkyaookOTVZVBOQIXIRAiiI544Ryxk1F5I4TxipZRMSdrsmk6lLl0rpEDIoYEczlxE4tApKnVkyXTp5JaF11rS6/IOYm6iDmRwvEUPEUKZPmxPk9k1////Wt////0CbSJxgIAAAAAAAwRqhadn9DMAl6aIOqP/7kmTtAAbphECObeAA6PCIVc1IABe91RKZyIACsjCnNzjwAy5fEwoSkWCwBEbRGAigMOuJAktyPAOLh2ibC5Y+wJoWwaZ4zFuNEhzCIFQuGkvGBdaT5LEXL6pw3STM1FdibJ8wImcZI6aKQU5qlSNFGiRQOqRs5ugmzrTW5XWTcnziCVq1unQdJFmZSz6kK3Qc6hUyZsppmimb6WkgummxbOIJIPskb0FKN0VK0Td01pGNToHUEE6KbugmkXElOpnZazyj3///6zzP/xcnwMkwGo3Y7XW7Zm5JAGeTipyJIJBUosAXXMTD8wgAJm+5zlxeO91lYexM0FaEMgUfRfoIgBsEYn27g5xvYc4FgKsY+IMWDF//2VYc6cEzLpj0t/fP18D8OYyHo/Ei/tFewryf2377BjhggOZewVaiFwri3x93rvevjev3asiKSIr3Ter83rmb+2Kbxje62tq0Xv48keBExNd5D///////////////vXfjwAjDNGoAAYYAAAGwEtKTxkSkp83FkmhJVhOyMPZHECODiSWviZEApEUuD1n/+5JkE4ADllfDLk2gAE0qmT3GnABM7H6UXJSAAAAANIOAAASHnVl0poKWZJP8+ZrMiSTqSJyJe/LposxM0TLSM3r/ooGxeOGaRmXcypOl/+zGrGS1UFUl/Wr/9NZdQWYqOmqCEkUjaS21t/pKv/+gAAAAEAgQBgMBAMCAIABnBDeE9MfHqe8dLeIyD34OgiDQCf84dEkRSP/jxqCMPP/+aco1Vv/+qEjh45CQ7///Go1sPNHkf///1zVpj2TCAAsKhU0qhQxpUUspBYEjQhAy2FQy4iBImTFKLbihQwIhUoAYDRsBQAhksAZlZFLbjGPjGlkUrVPFQ0WCgNAUFREd/kREeBUYeBp4llXA0POzsGix4FRgcEUNf/8ko8JVneHSoaESqkxBTUUzLjk4LjKqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq//uSZD6P8AAAaQAAAAgAAA0gAAABAAABpAAAACAAADSAAAAEqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkxBTUUzLjk4LjKqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqv/7kmT9j/AAAGkAAAAIAAANIAAAAQAAAaQAAAAgAAA0gAAABKqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpMQU1FMy45OC4yqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqr/+5Jk/4/wAABpAAAACAAADSAAAAEAAAGkAAAAIAAANIAAAASqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqTEFNRTMuOTguMqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq//uSZP+P8AAAaQAAAAgAAA0gAAABAAABpAAAACAAADSAAAAEqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkxBTUUzLjk4LjKqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqv/7kmT/j/AAAGkAAAAIAAANIAAAAQAAAaQAAAAgAAA0gAAABKqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqr/+5JkAA/wAABpAAAACAAADSAAAAEAAAGkAAAAIAAANIAAAARMQU1FMy45OC4yqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpMQU1FMy45OC4yqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq//uQZL8P8AAAaQAAAAgAAA0gAAABAAABpAAAACAAADSAAAAEqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq//uSZAAP8AAAaQAAAAgAAA0gAAABAAABpAAAACAAADSAAAAETEFNRTMuOTguMqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkxBTUUzLjk4LjKqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqv/7kmS/D/AAAGkAAAAIAAANIAAAAQAAAaQAAAAgAAA0gAAABKqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqr/+5JkAA/wAABpAAAACAAADSAAAAEAAAGkAAAAIAAANIAAAARMQU1FMy45OC4yqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqTEFNRTMuOTguMqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq//uSZL8P8AAAaQAAAAgAAA0gAAABAAABpAAAACAAADSAAAAEqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqv/7kmQAD/AAAGkAAAAIAAANIAAAAQAAAaQAAAAgAAA0gAAABExBTUUzLjk4LjKqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpMQU1FMy45OC4yqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqr/+5Jkvw/wAABpAAAACAAADSAAAAEAAAGkAAAAIAAANIAAAASqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq//uSZAAP8AAAaQAAAAgAAA0gAAABAAABpAAAACAAADSAAAAETEFNRTMuOTguMqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkxBTUUzLjk4LjKqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqv/7kmS/D/AAAGkAAAAIAAANIAAAAQAAAaQAAAAgAAA0gAAABKqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqr/+5JkAA/wAABpAAAACAAADSAAAAEAAAGkAAAAIAAANIAAAARMQU1FMy45OC4yqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqTEFNRTMuOTguMqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq")) # noqa: E501 # Big blob
SHUTDOWN.name = "shutdown.mp3"
STARTUP = io.BytesIO(b64decode(b"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")) # noqa: E501 # Big blob
STARTUP.name = "startup.mp3"
@register(outgoing=True, pattern="^.random")
async def randomise(items):
""" For .random command, get a random item from the list of items. """
itemo = (items.text[8:]).split()
if len(itemo) < 2:
return await items.edit(
"`2 or more items are required! Check .help random for more info.`"
)
index = randint(1, len(itemo) - 1)
await items.edit("**Query: **\n`" + items.text[8:] + "`\n**Output: **\n`" +
itemo[index] + "`")
@register(outgoing=True, pattern="^.sleep ([0-9]+)$")
async def sleepybot(time):
""" For .sleep command, let the userbot snooze for a few second. """
counter = int(time.pattern_match.group(1))
await time.edit("`I am sulking and snoozing...`")
if BOTLOG:
str_counter = time_formatter(counter)
await time.client.send_message(
BOTLOG_CHATID,
f"You put the bot to sleep for {str_counter}.",
)
sleep(counter)
await time.edit("`OK, I'm awake now.`")
@register(outgoing=True, pattern="^.shutdown$")
async def killthebot(event):
""" For .shutdown command, shut the bot down."""
await event.client.send_file(event.chat_id, SHUTDOWN, voice_note=True)
if BOTLOG:
await event.client.send_message(BOTLOG_CHATID, "#SHUTDOWN \n"
"Bot shut down")
await bot.disconnect()
@register(outgoing=True, pattern="^.restart$")
@register(outgoing=True, pattern="^.readme$")
# Copyright (c) Gegham Zakaryan | 2019
@register(outgoing=True, pattern="^.repeat (.*)")
@register(outgoing=True, pattern="^.repo$")
async def repo_is_here(wannasee):
""" For .repo command, just returns the repo URL. """
await wannasee.edit(
"[Repo](https://github.com/adekmaulana/ProjectBish) GitHub's page."
)
@register(outgoing=True, pattern="^.raw$")
CMD_HELP.update({
"random":
">`.random <item1> <item2> ... <itemN>`"
"\nUsage: Get a random item from the list of items.",
"sleep":
">`.sleep <seconds>`"
"\nUsage: Let yours snooze for a few seconds.",
"shutdown":
">`.shutdown`"
"\nUsage: Shutdown bot",
"repo":
">`.repo`"
"\nUsage: Github Repo of this bot",
"readme":
">`.readme`"
"\nUsage: Provide links to setup the userbot and it's modules.",
"repeat":
">`.repeat <no> <text>`"
"\nUsage: Repeats the text for a number of times. Don't confuse this with spam tho.",
"restart":
">`.restart`"
"\nUsage: Restarts the bot !!",
"raw":
">`.raw`"
"\nUsage: Get detailed JSON-like formatted data about replied message."
})
| [
2,
15069,
357,
34,
8,
13130,
383,
12281,
5303,
417,
6794,
5834,
11419,
13,
198,
2,
198,
2,
49962,
739,
262,
12281,
5303,
417,
6794,
5094,
13789,
11,
10628,
352,
13,
66,
357,
1169,
366,
34156,
15341,
198,
2,
345,
743,
407,
779,
428... | 1.370511 | 132,320 |
import fnmatch, os, socket
import pickle, timer_cm, dill
import ZO
from threading import *
from tkinter import *
from PIL import ImageTk, Image
PIXEL_MULTIPLIER = 10
IMAGE_PATH = '/Users/colind/Documents/Projects/ZeroOne/ZeroOne/Graphics/Images'
# Handle the window close event
try:
# Create the root Tk object
root = Tk()
root.title("ZeroOne DisplayEmulator")
# Hook the close window event
root.protocol("WM_DELETE_WINDOW", close_window)
# Now build the app and start the thread in daemon mode
app = DisplayEmulatorApplication(root)
app.daemon = True
app.start()
# Now run the main TKinter lool
# print('before mainloop()')
root.mainloop()
# print('after mainloop()')
except KeyboardInterrupt as ex:
print('Forcing a quit')
pass
finally:
print('Done!')
| [
11748,
24714,
15699,
11,
28686,
11,
17802,
198,
11748,
2298,
293,
11,
19781,
62,
11215,
11,
288,
359,
198,
198,
11748,
1168,
46,
198,
6738,
4704,
278,
1330,
1635,
198,
6738,
256,
74,
3849,
1330,
1635,
198,
6738,
350,
4146,
1330,
7412,... | 2.779264 | 299 |
#!/usr/bin/env python
# encoding: utf-8
import os
import re
from setuptools import setup, find_packages
try:
long_description = open(rel_path('README.rst'), 'rt').read()
except IOError:
long_description = ''
setup(
name="magphysio",
version=get_version(),
packages=find_packages(),
# install_requires=['Jinja2'],
author="Jonathan Sick",
author_email="jonathansick@mac.com",
description="Python I/O for MAGPHYS workflows",
long_description=long_description,
license="MIT",
keywords="astronomy",
url="http://github.com/jonathansick/magphysio"
)
| [
2,
48443,
14629,
14,
8800,
14,
24330,
21015,
198,
2,
21004,
25,
3384,
69,
12,
23,
198,
198,
11748,
28686,
198,
11748,
302,
198,
6738,
900,
37623,
10141,
1330,
9058,
11,
1064,
62,
43789,
628,
628,
198,
28311,
25,
198,
220,
220,
220,
... | 2.671111 | 225 |
quotes = [
"Thousands of candles can be lighted from a single candle, "
"and the life of the candle will not be shortened. "
"Happiness never decreases by being shared.",
"Peace comes from within. Do not seek it without."
]
| [
421,
6421,
796,
685,
198,
220,
220,
220,
366,
37482,
286,
32268,
460,
307,
1657,
276,
422,
257,
2060,
26839,
11,
366,
198,
220,
220,
220,
366,
392,
262,
1204,
286,
262,
26839,
481,
407,
307,
34464,
13,
366,
198,
220,
220,
220,
366... | 3.380282 | 71 |
# -*- coding: utf-8 -*-
"""
uuid helper
"""
import os
import random
import time
import uuid
def create_uuid():
"""
Generate random string
"""
return uuid.uuid4()
def create_short_uuid():
"""
Generate random integer
"""
result = str(random.randint(0, 999999999))
return result
def create_short_timestamp_uuid():
"""
Generate short uuid plus timestamp
"""
short_uuid = create_short_uuid()
return "{}{}".format(short_uuid, time.time())
| [
2,
532,
9,
12,
19617,
25,
3384,
69,
12,
23,
532,
9,
12,
198,
37811,
198,
12303,
312,
31904,
198,
37811,
198,
11748,
28686,
198,
11748,
4738,
198,
11748,
640,
198,
11748,
334,
27112,
628,
198,
4299,
2251,
62,
12303,
312,
33529,
198,
... | 2.527919 | 197 |
from flask import render_template,request,redirect,url_for
from . import main
#from requests import get_news, search_news
from .forms import ReviewForm
from ..models import Review
#Review = review.Review
# Views
#@main.route('/')
#def index():
@main.route('/news/<int:id>')
| [
6738,
42903,
1330,
8543,
62,
28243,
11,
25927,
11,
445,
1060,
11,
6371,
62,
1640,
198,
6738,
764,
1330,
1388,
198,
2,
6738,
7007,
1330,
651,
62,
10827,
11,
2989,
62,
10827,
198,
6738,
764,
23914,
1330,
6602,
8479,
198,
6738,
11485,
... | 3.170455 | 88 |
g_key = 'AIzaSyCKWaRCRJwLO14DFafu9-U5D_uVD_8g4iY'
weather_api_key = 'da7023607babfcda2533cb107c9718b1' | [
70,
62,
2539,
796,
705,
20185,
4496,
13940,
34,
42,
33484,
7397,
49,
41,
86,
21982,
1415,
8068,
1878,
84,
24,
12,
52,
20,
35,
62,
84,
8898,
62,
23,
70,
19,
72,
56,
6,
198,
23563,
62,
15042,
62,
2539,
796,
705,
6814,
2154,
1954... | 1.672131 | 61 |
#
# PySNMP MIB module HM2-DNS-MIB (http://snmplabs.com/pysmi)
# ASN.1 source file:///Users/davwang4/Dev/mibs.snmplabs.com/asn1/HM2-DNS-MIB
# Produced by pysmi-0.3.4 at Wed May 1 13:31:23 2019
# On host DAVWANG4-M-1475 platform Darwin version 18.5.0 by user davwang4
# Using Python version 3.7.3 (default, Mar 27 2019, 09:23:15)
#
OctetString, Integer, ObjectIdentifier = mibBuilder.importSymbols("ASN1", "OctetString", "Integer", "ObjectIdentifier")
NamedValues, = mibBuilder.importSymbols("ASN1-ENUMERATION", "NamedValues")
ConstraintsUnion, SingleValueConstraint, ConstraintsIntersection, ValueRangeConstraint, ValueSizeConstraint = mibBuilder.importSymbols("ASN1-REFINEMENT", "ConstraintsUnion", "SingleValueConstraint", "ConstraintsIntersection", "ValueRangeConstraint", "ValueSizeConstraint")
HmActionValue, HmEnabledStatus, hm2ConfigurationMibs = mibBuilder.importSymbols("HM2-TC-MIB", "HmActionValue", "HmEnabledStatus", "hm2ConfigurationMibs")
InetAddressType, InetAddress = mibBuilder.importSymbols("INET-ADDRESS-MIB", "InetAddressType", "InetAddress")
SnmpAdminString, = mibBuilder.importSymbols("SNMP-FRAMEWORK-MIB", "SnmpAdminString")
ModuleCompliance, NotificationGroup = mibBuilder.importSymbols("SNMPv2-CONF", "ModuleCompliance", "NotificationGroup")
Gauge32, Unsigned32, ModuleIdentity, NotificationType, TimeTicks, Counter32, Integer32, Counter64, IpAddress, MibIdentifier, iso, ObjectIdentity, MibScalar, MibTable, MibTableRow, MibTableColumn, Bits = mibBuilder.importSymbols("SNMPv2-SMI", "Gauge32", "Unsigned32", "ModuleIdentity", "NotificationType", "TimeTicks", "Counter32", "Integer32", "Counter64", "IpAddress", "MibIdentifier", "iso", "ObjectIdentity", "MibScalar", "MibTable", "MibTableRow", "MibTableColumn", "Bits")
DisplayString, TextualConvention, RowStatus = mibBuilder.importSymbols("SNMPv2-TC", "DisplayString", "TextualConvention", "RowStatus")
hm2DnsMib = ModuleIdentity((1, 3, 6, 1, 4, 1, 248, 11, 90))
hm2DnsMib.setRevisions(('2011-06-17 00:00',))
if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0):
if mibBuilder.loadTexts: hm2DnsMib.setRevisionsDescriptions(('Initial version.',))
if mibBuilder.loadTexts: hm2DnsMib.setLastUpdated('201106170000Z')
if mibBuilder.loadTexts: hm2DnsMib.setOrganization('Hirschmann Automation and Control GmbH')
if mibBuilder.loadTexts: hm2DnsMib.setContactInfo('Postal: Stuttgarter Str. 45-51 72654 Neckartenzlingen Germany Phone: +49 7127 140 E-mail: hac.support@belden.com')
if mibBuilder.loadTexts: hm2DnsMib.setDescription('Hirschmann DNS MIB for DNS client, DNS client cache and DNS caching server. Copyright (C) 2011. All Rights Reserved.')
hm2DnsMibNotifications = MibIdentifier((1, 3, 6, 1, 4, 1, 248, 11, 90, 0))
hm2DnsMibObjects = MibIdentifier((1, 3, 6, 1, 4, 1, 248, 11, 90, 1))
hm2DnsMibSNMPExtensionGroup = MibIdentifier((1, 3, 6, 1, 4, 1, 248, 11, 90, 3))
hm2DnsClientGroup = MibIdentifier((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1))
hm2DnsCacheGroup = MibIdentifier((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 2))
hm2DnsCachingServerGroup = MibIdentifier((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 3))
hm2DnsClientAdminState = MibScalar((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 1), HmEnabledStatus().clone('disable')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: hm2DnsClientAdminState.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientAdminState.setDescription('The operational status of DNS client. If disabled, no host name lookups will be done for names entered on the CLI and in the configuration of services e.g. NTP.')
hm2DnsClientConfigSource = MibScalar((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 2), Integer32().subtype(subtypeSpec=ConstraintsUnion(SingleValueConstraint(1, 2, 3))).clone(namedValues=NamedValues(("user", 1), ("mgmt-dhcp", 2), ("provider", 3))).clone('mgmt-dhcp')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: hm2DnsClientConfigSource.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientConfigSource.setDescription('DNS client server source. If the value is set to user(1), the variables from hm2DnsClientServerCfgTable will be used. If the value is set to mgmt-dhcp(2), the DNS servers received by DHCP on the management interface will be used. If the value is set to provider(3), the DNS configuration will be taken from DHCP, PPP or PPPoE on the primary WAN link.')
hm2DnsClientServerCfgTable = MibTable((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 3), )
if mibBuilder.loadTexts: hm2DnsClientServerCfgTable.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientServerCfgTable.setDescription('The table that contains the DNS Servers entries configured by the user in the system.')
hm2DnsClientServerCfgEntry = MibTableRow((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 3, 1), ).setIndexNames((0, "HM2-DNS-MIB", "hm2DnsClientServerIndex"))
if mibBuilder.loadTexts: hm2DnsClientServerCfgEntry.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientServerCfgEntry.setDescription('An entry contains the IP address of a DNS server configured in the system.')
hm2DnsClientServerIndex = MibTableColumn((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 3, 1, 1), Integer32().subtype(subtypeSpec=ValueRangeConstraint(1, 4)))
if mibBuilder.loadTexts: hm2DnsClientServerIndex.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientServerIndex.setDescription('The unique index used for each server added in the DNS servers table.')
hm2DnsClientServerAddressType = MibTableColumn((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 3, 1, 2), InetAddressType().clone('ipv4')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: hm2DnsClientServerAddressType.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientServerAddressType.setDescription('Address type for DNS server. Currently, only ipv4 is supported.')
hm2DnsClientServerAddress = MibTableColumn((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 3, 1, 3), InetAddress().clone(hexValue="00000000")).setMaxAccess("readwrite")
if mibBuilder.loadTexts: hm2DnsClientServerAddress.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientServerAddress.setDescription('The IP address of the DNS server.')
hm2DnsClientServerRowStatus = MibTableColumn((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 3, 1, 4), RowStatus()).setMaxAccess("readcreate")
if mibBuilder.loadTexts: hm2DnsClientServerRowStatus.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientServerRowStatus.setDescription('Describes the status of a row in the table.')
hm2DnsClientServerDiagTable = MibTable((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 4), )
if mibBuilder.loadTexts: hm2DnsClientServerDiagTable.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientServerDiagTable.setDescription('The table that contains the DNS Servers entries configured and used in the system.')
hm2DnsClientServerDiagEntry = MibTableRow((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 4, 1), ).setIndexNames((0, "HM2-DNS-MIB", "hm2DnsClientServerDiagIndex"))
if mibBuilder.loadTexts: hm2DnsClientServerDiagEntry.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientServerDiagEntry.setDescription('An entry contains the IP address of a DNS server used in the system.')
hm2DnsClientServerDiagIndex = MibTableColumn((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 4, 1, 1), Integer32().subtype(subtypeSpec=ValueRangeConstraint(1, 4)))
if mibBuilder.loadTexts: hm2DnsClientServerDiagIndex.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientServerDiagIndex.setDescription('The unique index used for each server added in the DNS servers table.')
hm2DnsClientServerDiagAddressType = MibTableColumn((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 4, 1, 2), InetAddressType()).setMaxAccess("readonly")
if mibBuilder.loadTexts: hm2DnsClientServerDiagAddressType.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientServerDiagAddressType.setDescription('Address type for DNS server used. Currently, only ipv4 is supported.')
hm2DnsClientServerDiagAddress = MibTableColumn((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 4, 1, 3), InetAddress()).setMaxAccess("readonly")
if mibBuilder.loadTexts: hm2DnsClientServerDiagAddress.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientServerDiagAddress.setDescription('The IP address of the DNS server used by the system. The entry can be configured by the provider, e.g. through DHCP client or PPPoE client.')
hm2DnsClientGlobalGroup = MibIdentifier((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 5))
hm2DnsClientDefaultDomainName = MibScalar((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 5, 1), SnmpAdminString().subtype(subtypeSpec=ValueSizeConstraint(0, 255))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: hm2DnsClientDefaultDomainName.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientDefaultDomainName.setDescription('The default domain name for unqualified hostnames.')
hm2DnsClientRequestTimeout = MibScalar((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 5, 2), Integer32().subtype(subtypeSpec=ValueRangeConstraint(0, 3600)).clone(3)).setMaxAccess("readwrite")
if mibBuilder.loadTexts: hm2DnsClientRequestTimeout.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientRequestTimeout.setDescription('The timeout before retransmitting a request to the server. The timeout value is configured and displayed in seconds.')
hm2DnsClientRequestRetransmits = MibScalar((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 5, 3), Integer32().subtype(subtypeSpec=ValueRangeConstraint(0, 100)).clone(2)).setMaxAccess("readwrite")
if mibBuilder.loadTexts: hm2DnsClientRequestRetransmits.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientRequestRetransmits.setDescription('The number of times the request is retransmitted. The request is retransmitted provided the maximum timeout value allows this many number of retransmits.')
hm2DnsClientCacheAdminState = MibScalar((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 5, 4), HmEnabledStatus().clone('enable')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: hm2DnsClientCacheAdminState.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientCacheAdminState.setDescription('Enables/Disables DNS client cache functionality of the device.')
hm2DnsClientStaticHostConfigTable = MibTable((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 6), )
if mibBuilder.loadTexts: hm2DnsClientStaticHostConfigTable.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientStaticHostConfigTable.setDescription('Static table of DNS hostname to IP address table')
hm2DnsClientStaticHostConfigEntry = MibTableRow((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 6, 1), ).setIndexNames((0, "HM2-DNS-MIB", "hm2DnsClientStaticIndex"))
if mibBuilder.loadTexts: hm2DnsClientStaticHostConfigEntry.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientStaticHostConfigEntry.setDescription('An entry in the static DNS hostname IP address list. Rows may be created or deleted at any time by the DNS resolver and by SNMP SET requests.')
hm2DnsClientStaticIndex = MibTableColumn((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 6, 1, 1), Integer32().subtype(subtypeSpec=ValueRangeConstraint(1, 64)))
if mibBuilder.loadTexts: hm2DnsClientStaticIndex.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientStaticIndex.setDescription('The index of the entry.')
hm2DnsClientStaticHostName = MibTableColumn((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 6, 1, 2), SnmpAdminString().subtype(subtypeSpec=ValueSizeConstraint(0, 255))).setMaxAccess("readcreate")
if mibBuilder.loadTexts: hm2DnsClientStaticHostName.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientStaticHostName.setDescription('The static hostname.')
hm2DnsClientStaticHostAddressType = MibTableColumn((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 6, 1, 3), InetAddressType()).setMaxAccess("readcreate")
if mibBuilder.loadTexts: hm2DnsClientStaticHostAddressType.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientStaticHostAddressType.setDescription('Address type for static hosts used. Currently, only ipv4 is supported.')
hm2DnsClientStaticHostIPAddress = MibTableColumn((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 6, 1, 4), InetAddress()).setMaxAccess("readcreate")
if mibBuilder.loadTexts: hm2DnsClientStaticHostIPAddress.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientStaticHostIPAddress.setDescription('The IP address of the static host.')
hm2DnsClientStaticHostStatus = MibTableColumn((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 1, 6, 1, 5), RowStatus()).setMaxAccess("readcreate")
if mibBuilder.loadTexts: hm2DnsClientStaticHostStatus.setStatus('current')
if mibBuilder.loadTexts: hm2DnsClientStaticHostStatus.setDescription('Describes the status of a row in the table.')
hm2DnsCachingServerGlobalGroup = MibIdentifier((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 3, 1))
hm2DnsCachingServerAdminState = MibScalar((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 3, 1, 1), HmEnabledStatus().clone('enable')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: hm2DnsCachingServerAdminState.setStatus('current')
if mibBuilder.loadTexts: hm2DnsCachingServerAdminState.setDescription('Enables/Disables DNS caching server functionality of the device.')
hm2DnsCacheAdminState = MibScalar((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 2, 1), HmEnabledStatus().clone('enable')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: hm2DnsCacheAdminState.setStatus('deprecated')
if mibBuilder.loadTexts: hm2DnsCacheAdminState.setDescription('Enables/Disables DNS cache functionality of the device. **NOTE: this object is deprecated and replaced by hm2DnsClientCacheAdminState/hm2DnsCachingServerAdminState**.')
hm2DnsCacheFlushAction = MibScalar((1, 3, 6, 1, 4, 1, 248, 11, 90, 1, 2, 2), HmActionValue().clone('noop')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: hm2DnsCacheFlushAction.setStatus('deprecated')
if mibBuilder.loadTexts: hm2DnsCacheFlushAction.setDescription('Setting this value to action will flush the DNS cache. After flushing the cache, it will be set to noop automatically. **NOTE: this object is deprecated and replaced by hm2DevMgmtActionFlushDnsClientCache/hm2DevMgmtActionFlushDnsCachingServerCache**.')
hm2DnsCHHostNameAlreadyExistsSESError = ObjectIdentity((1, 3, 6, 1, 4, 1, 248, 11, 90, 3, 1))
if mibBuilder.loadTexts: hm2DnsCHHostNameAlreadyExistsSESError.setStatus('current')
if mibBuilder.loadTexts: hm2DnsCHHostNameAlreadyExistsSESError.setDescription('The host name entered exists and is associated with an IP. The change attempt was canceled.')
hm2DnsCHBadIpNotAcceptedSESError = ObjectIdentity((1, 3, 6, 1, 4, 1, 248, 11, 90, 3, 2))
if mibBuilder.loadTexts: hm2DnsCHBadIpNotAcceptedSESError.setStatus('current')
if mibBuilder.loadTexts: hm2DnsCHBadIpNotAcceptedSESError.setDescription('The Ip Adress entered is not a valid one for a host. The change attempt was canceled.')
hm2DnsCHBadRowCannotBeActivatedSESError = ObjectIdentity((1, 3, 6, 1, 4, 1, 248, 11, 90, 3, 3))
if mibBuilder.loadTexts: hm2DnsCHBadRowCannotBeActivatedSESError.setStatus('current')
if mibBuilder.loadTexts: hm2DnsCHBadRowCannotBeActivatedSESError.setDescription('The instance cannot be activated due to compliance issues. Please modify the entry and try again.')
mibBuilder.exportSymbols("HM2-DNS-MIB", hm2DnsCachingServerGlobalGroup=hm2DnsCachingServerGlobalGroup, hm2DnsClientServerIndex=hm2DnsClientServerIndex, hm2DnsClientServerAddress=hm2DnsClientServerAddress, hm2DnsClientServerCfgTable=hm2DnsClientServerCfgTable, PYSNMP_MODULE_ID=hm2DnsMib, hm2DnsClientServerDiagAddress=hm2DnsClientServerDiagAddress, hm2DnsClientStaticHostConfigTable=hm2DnsClientStaticHostConfigTable, hm2DnsClientGlobalGroup=hm2DnsClientGlobalGroup, hm2DnsCacheGroup=hm2DnsCacheGroup, hm2DnsClientServerDiagEntry=hm2DnsClientServerDiagEntry, hm2DnsMibSNMPExtensionGroup=hm2DnsMibSNMPExtensionGroup, hm2DnsClientGroup=hm2DnsClientGroup, hm2DnsMibObjects=hm2DnsMibObjects, hm2DnsClientDefaultDomainName=hm2DnsClientDefaultDomainName, hm2DnsClientStaticHostStatus=hm2DnsClientStaticHostStatus, hm2DnsCacheAdminState=hm2DnsCacheAdminState, hm2DnsClientRequestTimeout=hm2DnsClientRequestTimeout, hm2DnsClientServerDiagAddressType=hm2DnsClientServerDiagAddressType, hm2DnsCachingServerGroup=hm2DnsCachingServerGroup, hm2DnsClientServerDiagTable=hm2DnsClientServerDiagTable, hm2DnsCHBadIpNotAcceptedSESError=hm2DnsCHBadIpNotAcceptedSESError, hm2DnsClientAdminState=hm2DnsClientAdminState, hm2DnsClientStaticHostName=hm2DnsClientStaticHostName, hm2DnsClientRequestRetransmits=hm2DnsClientRequestRetransmits, hm2DnsMibNotifications=hm2DnsMibNotifications, hm2DnsClientConfigSource=hm2DnsClientConfigSource, hm2DnsClientServerRowStatus=hm2DnsClientServerRowStatus, hm2DnsClientServerDiagIndex=hm2DnsClientServerDiagIndex, hm2DnsClientCacheAdminState=hm2DnsClientCacheAdminState, hm2DnsCHHostNameAlreadyExistsSESError=hm2DnsCHHostNameAlreadyExistsSESError, hm2DnsCacheFlushAction=hm2DnsCacheFlushAction, hm2DnsClientStaticIndex=hm2DnsClientStaticIndex, hm2DnsClientStaticHostAddressType=hm2DnsClientStaticHostAddressType, hm2DnsCachingServerAdminState=hm2DnsCachingServerAdminState, hm2DnsCHBadRowCannotBeActivatedSESError=hm2DnsCHBadRowCannotBeActivatedSESError, hm2DnsClientServerAddressType=hm2DnsClientServerAddressType, hm2DnsMib=hm2DnsMib, hm2DnsClientStaticHostIPAddress=hm2DnsClientStaticHostIPAddress, hm2DnsClientServerCfgEntry=hm2DnsClientServerCfgEntry, hm2DnsClientStaticHostConfigEntry=hm2DnsClientStaticHostConfigEntry)
| [
2,
198,
2,
9485,
15571,
7378,
337,
9865,
8265,
25904,
17,
12,
35,
8035,
12,
8895,
33,
357,
4023,
1378,
16184,
76,
489,
8937,
13,
785,
14,
79,
893,
11632,
8,
198,
2,
7054,
45,
13,
16,
2723,
2393,
1378,
14,
14490,
14,
67,
615,
4... | 2.82388 | 6,047 |
from pwn import * # NOQA
context.log_level = 'debug'
context.terminal = ['tmux', 'splitw', '-h']
binary = ELF('./example04')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
p = process('./example04')
gdb.attach(p)
atol_got = binary.symbols['got.atol']
numbers = binary.symbols['numbers']
offset = (atol_got - numbers) / 8
write(1, 1)
atol_leak = read(offset)
libc_base = atol_leak - libc.symbols['atol']
system_addr = libc_base + libc.symbols['system']
print(hex(atol_leak))
print(hex(system_addr))
write(system_addr, offset)
p.sendline('/bin/sh')
p.interactive()
| [
6738,
279,
675,
1330,
1635,
220,
1303,
8005,
48,
32,
198,
198,
22866,
13,
6404,
62,
5715,
796,
705,
24442,
6,
198,
22866,
13,
23705,
282,
796,
37250,
17209,
2821,
3256,
705,
35312,
86,
3256,
705,
12,
71,
20520,
628,
628,
198,
39491,... | 2.281746 | 252 |
from book_center.bc_profiles.models.discussions import BookCenterDiscussion, BookCenterDiscussionComment
from book_center.utils.mixins import DisableAutocompleteMixin
from django import forms
| [
6738,
1492,
62,
16159,
13,
15630,
62,
5577,
2915,
13,
27530,
13,
15410,
21585,
1330,
4897,
23656,
34255,
11,
4897,
23656,
34255,
21357,
198,
6738,
1492,
62,
16159,
13,
26791,
13,
19816,
1040,
1330,
31529,
16541,
42829,
6677,
35608,
259,
... | 4.0625 | 48 |
"""
Entradas
Billetes_50000-->int-->N1
Billetes_20000-->int-->N2
Billetes_10000-->int-->N3
Billetes_5000-->int-->N4
Billetes_2000-->int-->N5
Billetes_1000-->int-->N6
Billetes_500-->int-->N7
Billetes_100-->int-->N8
Salidas
Cantidad_dinero-->float-->c_d
"""
N1=int(input("Ingrese la cantidad de billetes de 50000 "))
N2=int(input("Ingrese la cantidad de billetes de 20000 "))
N3=int(input("Ingrese la cantidad de billetes de 10000 "))
N4=int(input("Ingrese la cantidad de billetes de 5000 "))
N5=int(input("Ingrese la cantidad de billetes de 2000 "))
N6=int(input("Ingrese la cantidad de billetes de 1000 "))
N7=int(input("Ingrese la cantidad de billetes de 500 "))
N8=int(input("Ingrese la cantidad de billetes de 100 "))
c_d=(N1*50000)+(N2*20000)+(N3*10000)+(N4*5000)+(N5*2000)+(N6*1000)+(N7*500)+(N8*100)
print("El banco cuenta con la siguente cantidad de dinero: "+str(c_d)) | [
37811,
198,
14539,
6335,
292,
198,
33,
32512,
274,
62,
20,
2388,
46904,
600,
46904,
45,
16,
198,
33,
32512,
274,
62,
2167,
405,
46904,
600,
46904,
45,
17,
198,
33,
32512,
274,
62,
49388,
46904,
600,
46904,
45,
18,
198,
33,
32512,
... | 2.354839 | 372 |
import functools
try:
import autograd
import autograd.numpy as np
except ImportError:
autograd = None
from ...tools import bisect_sequence, unpack_singleton_sequence_return_value
from ._backend import Backend, fail_on_complex_input
| [
11748,
1257,
310,
10141,
628,
198,
28311,
25,
198,
220,
220,
220,
1330,
1960,
519,
6335,
198,
220,
220,
220,
1330,
1960,
519,
6335,
13,
77,
32152,
355,
45941,
198,
16341,
17267,
12331,
25,
198,
220,
220,
220,
1960,
519,
6335,
796,
6... | 3.02439 | 82 |
import os
import numpy as np
import tensorflow as tf
from tqdm import tqdm
import transformers
from tensorflow.keras.layers import Dense, Input, Dropout, LSTM
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.models import Model
from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping, TensorBoard, History
from tensorflow.keras.metrics import Accuracy, AUC
from tokenizers import BertWordPieceTokenizer
#Load BERT tokenizers and transformers
tokenizer = transformers.DistilBertTokenizer.from_pretrained('distilbert-base-cased')
# Save the loaded tokenizer locally
tokenizer.save_pretrained('.')
# Reload it with the huggingface tokenizers library
fast_tokenizer = BertWordPieceTokenizer('vocab.txt', lowercase=False)
transformer_layer = (
transformers.TFDistilBertModel
.from_pretrained('distilbert-base-cased')
)
def build_BERT_model_classification(transformer, max_len=512, transformer_trainable=False):
"""
Function for training the BERT model
"""
transformer.trainable = transformer_trainable
input_word_ids = Input(shape=(max_len,), dtype='int32', name="input_word_ids")
sequence_output = transformer(input_word_ids)[0]
cls_token = sequence_output[:, 0, :]
pre_classified = Dense(768,
activation="relu",
name="pre_classifier")(cls_token)
logits = Dropout(.2)(pre_classified)
logits = Dense(2)(logits)
out = Dense(1, activation='sigmoid')(logits)
model = Model(inputs=input_word_ids, outputs=out)
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy', AUC(curve='PR')])
return model
def build_BERT_model_lstm(transformer, max_len=512, transformer_trainable=False):
"""
Function for training the BERT model
"""
transformer.trainable = transformer_trainable
input_word_ids = Input(shape=(max_len,), dtype='int32', name="input_word_ids")
sequence_output = transformer(input_word_ids)[0]
cls_token = sequence_output[:, 0, :]
lstm_out = LSTM(100, activation="tanh", recurrent_activation="sigmoid")(sequence_output)
out = Dense(1, activation='sigmoid')(lstm_out)
model = Model(inputs=input_word_ids, outputs=out)
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy', AUC(curve='PR')])
return model
def fast_encode(texts, tokenizer, chunk_size=256, max_len=512):
"""
Encoder for encoding the text into sequence of integers for BERT Input
"""
#Only a small fraction of input is > max_len, not biased across toxic/nontoxic.
tokenizer.enable_truncation(max_length=max_len)
tokenizer.enable_padding(length=max_len)
all_ids = []
for i in tqdm(range(0, len(texts), chunk_size)):
text_chunk = texts[i:i+chunk_size].tolist()
encs = tokenizer.encode_batch(text_chunk)
all_ids.extend([enc.ids for enc in encs])
return np.array(all_ids)
| [
11748,
28686,
198,
11748,
299,
32152,
355,
45941,
198,
11748,
11192,
273,
11125,
355,
48700,
198,
6738,
256,
80,
36020,
1330,
256,
80,
36020,
198,
11748,
6121,
364,
198,
6738,
11192,
273,
11125,
13,
6122,
292,
13,
75,
6962,
1330,
360,
... | 2.675136 | 1,102 |
'''
Created on October 17, 2019
@author: pashaa@mskcc.org
'''
import yaml
import sys
# an instance that reads from the defaul config.yaml file
default_config = Config()
if __name__ == '__main__':
print(default_config.get_redcap_token(instance_name="production"))
| [
7061,
6,
198,
41972,
319,
3267,
1596,
11,
13130,
198,
198,
31,
9800,
25,
279,
1077,
7252,
31,
907,
74,
535,
13,
2398,
198,
7061,
6,
198,
198,
11748,
331,
43695,
198,
11748,
25064,
628,
628,
198,
2,
281,
4554,
326,
9743,
422,
262,
... | 2.914894 | 94 |
import os
import csv
PyPoll_csv = os.path.join("..", "Resources", "election_data.csv")
candidates = ['Khan', 'Correy','Li','OTolley']
print('Election Results')
print('-------------------')
with open(PyPoll_csv) as csvfile:
csvreader = csv.reader(csvfile, delimiter=',')
csv_header = next(csvreader)
Khan=0
Correy=0
Li=0
OTooley=0
votes=0
for row in csvreader:
votes +=1
if row[2]=='Khan':
Khan +=1
elif row[2]== 'Correy':
Correy +=1
elif row[2]== 'Li':
Li +=1
elif row[2]== "O'Tooley":
OTooley +=1
print('Total votes: ' + str(votes))
percentage_Khan = round((Khan/votes*100),2)
percentage_Correy = round((Correy/votes*100),2)
percentage_Li = round((Li/votes*100),2)
percentage_OTooley = round((OTooley/votes*100),2)
print('Khan : ' + str(Khan)+' '+ str(percentage_Khan)+ '%')
print('Correy : ' + str(Correy)+' '+ str(percentage_Correy)+ '%')
print('Li : ' + str(Li)+' '+ str(percentage_Li)+'%')
print("O'Tolley : " + str(OTooley)+' '+ str(percentage_OTooley)+'%')
print('-------------------')
if Khan>Correy and Khan>Li and Khan>OTooley:
print ('Winner: Kahn')
elif Correy>Khan and Correy>Li and Correy>OTooley:
print('Winner : Correy')
elif Li>Khan and Li>Correy and Li>OTooley:
print('Winner : Li')
elif OTooley>Khan and OTooley>Correy and OTooley>Li:
print("Winner : O'Tooley")
print('-------------------')
| [
11748,
28686,
198,
11748,
269,
21370,
198,
198,
20519,
39176,
62,
40664,
796,
28686,
13,
6978,
13,
22179,
7203,
492,
1600,
366,
33236,
1600,
366,
14300,
62,
7890,
13,
40664,
4943,
198,
198,
46188,
37051,
796,
37250,
42,
7637,
3256,
705,... | 2.170904 | 708 |
import unittest
from pythonapm.instruments import monkey
from pythonapm.surfacers import Surfacers
from pythonapm.surfacers.log import LogSurfacer
from pythonapm.surfacers.mem import InMemorySurfacer
| [
11748,
555,
715,
395,
198,
198,
6738,
21015,
499,
76,
13,
259,
2536,
2886,
1330,
21657,
198,
6738,
21015,
499,
76,
13,
11793,
38942,
364,
1330,
4198,
38942,
364,
198,
6738,
21015,
499,
76,
13,
11793,
38942,
364,
13,
6404,
1330,
5972,
... | 3.206349 | 63 |
import os
from collections import defaultdict, namedtuple
from copy import deepcopy
from pprint import pprint
import lxml
import lxml.html
import lxml.etree
from graphviz import Digraph
from similarity.normalized_levenshtein import NormalizedLevenshtein
normalized_levenshtein = NormalizedLevenshtein()
TAG_NAME_ATTRIB = "___tag_name___"
HIERARCHICAL = "hierarchical"
SEQUENTIAL = "sequential"
DataRegion = namedtuple(
"DataRegion",
["n_nodes_per_region", "start_child_index", "n_nodes_covered"],
)
| [
11748,
28686,
198,
6738,
17268,
1330,
4277,
11600,
11,
3706,
83,
29291,
198,
6738,
4866,
1330,
2769,
30073,
198,
6738,
279,
4798,
1330,
279,
4798,
198,
198,
11748,
300,
19875,
198,
11748,
300,
19875,
13,
6494,
198,
11748,
300,
19875,
13... | 2.948571 | 175 |
import pytest
from . import create_app
@pytest.fixture
@pytest.fixture
| [
11748,
12972,
9288,
198,
198,
6738,
764,
1330,
2251,
62,
1324,
628,
198,
31,
9078,
9288,
13,
69,
9602,
628,
198,
31,
9078,
9288,
13,
69,
9602,
628,
628,
628,
198
] | 2.645161 | 31 |
import os
import cardio.batchflow as bf
import warnings
import numpy as np
from cardio import EcgBatch
from my_tools import calculate_old_metrics
from my_pipelines.my_pipelines import LoadEcgPipeline
from PanTompkinsAlgorithm import HilbertTransformPipeline
warnings.filterwarnings('ignore')
SIGNALS_PATH = "data\\qt-database-1.0.0" # set path to QT database
SIGNALS_MASK = os.path.join(SIGNALS_PATH, "*.hea")
index = bf.FilesIndex(path=SIGNALS_MASK, no_ext=True, sort=True)
dtst = bf.Dataset(index, batch_class=EcgBatch)
dtst.split([0.1, 0.9])
pipeline = LoadEcgPipeline() + HilbertTransformPipeline(batch_size=1, annot="hilb_annotation")
ppl_inits = (dtst.train >> pipeline).run()
batch : EcgBatch = ppl_inits.next_batch(len(dtst.train.indices))
print("end")
| [
11748,
28686,
198,
11748,
47926,
13,
43501,
11125,
355,
275,
69,
198,
11748,
14601,
198,
11748,
299,
32152,
355,
45941,
198,
6738,
47926,
1330,
14003,
70,
33,
963,
198,
6738,
616,
62,
31391,
1330,
15284,
62,
727,
62,
4164,
10466,
198,
... | 2.687719 | 285 |
import os
import sys
import argparse
import glob
import pandas as pd
if __name__ == '__main__':
sys.exit(main())
| [
11748,
28686,
198,
11748,
25064,
198,
11748,
1822,
29572,
198,
11748,
15095,
198,
11748,
19798,
292,
355,
279,
67,
198,
198,
361,
11593,
3672,
834,
6624,
705,
834,
12417,
834,
10354,
198,
220,
220,
220,
25064,
13,
37023,
7,
12417,
28955... | 2.809524 | 42 |
"""Module for interacting with analysis API"""
import inspect
from .base import JSONDict, handle_response, rate_limited
from .models import AnalysisRequest
from .session import HexpySession
class AnalysisAPI:
"""Class for working with Crimson Hexagon Analysis API.
# Example Usage
```python
>>> from hexpy import HexpySession, AnalysisAPI
>>> session = HexpySession.load_auth_from_file()
>>> analysis_client = AnalysisAPI(session)
>>> analysis_client.results(request_id)
```
"""
def analysis_request(self, request: AnalysisRequest) -> JSONDict:
"""Submit a query task against 24 hours of social data.
# Arguments
request: validated AnalysisRequest.
Example Request
```python
request_dict = {
"analysis": [
"volume",
"sentiment",
"emotion",
"affinity",
"gender",
"age",
"location",
"source",
"reach"
],
"keywords": "iPhone",
"languages": {
"type": "include",
"values": [
"EN"
]
},
"gender": {
"type": "include",
"values": ["M"]
},
"locations": {
"type": "exclude",
"values": [
"JPN"
]
},
"sources": [
"TWITTER",
"TUMBLR",
"INSTAGRAM",
"BLOGS",
"REVIEWS",
"GOOGLE_PLUS",
"NEWS",
"YOUTUBE",
"FORUMS"
],
"startDate": "2016-09-20T00:00:00",
"endDate": "2016-09-21T00:00:00",
"timezone": "America/New_York",
"requestUsage": True
}
request = AnalysisRequest(**request_dict)
```
"""
return handle_response(self.session.post(self.TEMPLATE, json=request))
def results(self, request_id: int) -> JSONDict:
"""Retrieve the status of the analysis request and the results.
# Arguments
request_id: Integer, the identifier given for the analysis, generated via the Analysis Request endpoints
"""
return handle_response(self.session.get(self.TEMPLATE + f"/{request_id}"))
def image_analysis(self, url: str) -> JSONDict:
"""Get object, scene, activity predictions for image from public url.
# Arguments
url: String, the url of the image to analyze
"""
return handle_response(
self.session.get(
self.TEMPLATE.split("results")[0] + "imageanalysis", params={"url": url}
)
)
| [
37811,
26796,
329,
24986,
351,
3781,
7824,
37811,
198,
198,
11748,
10104,
198,
198,
6738,
764,
8692,
1330,
19449,
35,
713,
11,
5412,
62,
26209,
11,
2494,
62,
10698,
198,
6738,
764,
27530,
1330,
14691,
18453,
198,
6738,
764,
29891,
1330,... | 1.9375 | 1,488 |
"""Utilities for interacting with the Jenkins CI API."""
from __future__ import unicode_literals
import json
import logging
from django.utils import six
from django.utils.six.moves.urllib.error import HTTPError
from django.utils.six.moves.urllib.parse import (quote, urlencode)
from django.utils.six.moves.urllib.request import urlopen
try:
# Review Board 4.0
from reviewboard.hostingsvcs.service import HostingServiceHTTPRequest
except ImportError:
# Review Board 3.0
from reviewboard.hostingsvcs.service import URLRequest as \
HostingServiceHTTPRequest
logger = logging.getLogger(__name__)
class JenkinsAPI(object):
"""Object for interacting with the Jenkins CI API."""
def __init__(self, endpoint, job_name, username, password):
"""Initialize the object.
Args:
endpoint (unicode):
Jenkins server endpoint.
job_name (unicode):
Job name on Jenkins.
username (unicode):
Jenkins username.
password (unicode):
Jenkins password.
"""
self.endpoint = endpoint
self.job_name = job_name
self.username = username
self.password = password
self.csrf_protection_enabled = True
self.crumb = None
self.crumb_request_field = None
def test_connection(self):
"""Test the connection to the Jenkins server.
This is used for verifying both the URL and user credentials are
correct.
"""
self._make_request('%s/api/json?pretty=true' % self.endpoint,
method='GET')
def start_build(self, patch_info):
"""Start a build.
Args:
patch_info (dict):
Contains the review ID, review branch, review diff revision
and the status update ID.
Raises:
urllib2.URLError:
The HTTP request failed.
"""
data = {
'parameter': [
{
'name': 'REVIEWBOARD_SERVER',
'value': patch_info['reviewboard_server']
},
{
'name': 'REVIEWBOARD_REVIEW_ID',
'value': patch_info['review_id']
},
{
'name': 'REVIEWBOARD_REVIEW_BRANCH',
'value': patch_info['review_branch']
},
{
'name': 'REVIEWBOARD_DIFF_REVISION',
'value': patch_info['diff_revision']
},
{
'name': 'REVIEWBOARD_STATUS_UPDATE_ID',
'value': patch_info['status_update_id']
}
]
}
# This is not part of the official REST API, but is however listed in
# the Jenkins wiki as the correct way to initiate a remote build.
#
# This method of passing in the build parameters may change in the
# future.
self._make_request(
'%s/job/%s/build' % (self.endpoint,
quote(self.job_name)),
body=urlencode({
'json': json.dumps(data, sort_keys=True)
}),
content_type='application/x-www-form-urlencoded',
method='POST'
)
def _fetch_csrf_token(self):
"""Fetches a CSRF token from the Jenkins server.
This is required for making requests to API endpoints when using basic
authentication. A crumb is no longer required when using API token
authentication to access buildWithParameters.
"""
data = self._make_raw_request('%s/crumbIssuer/api/json'
% self.endpoint)
result = json.loads(data)
self.crumb = result['crumb']
self.crumb_request_field = result['crumbRequestField']
def _make_request(self, url, body=None, method='GET',
content_type=''):
"""Make an HTTP request.
This will first attempt to fetch a CSRF token if we do not currently
have one.
Args:
url (unicode):
The URL to make the request against.
body (unicode or bytes, optional):
The content of the request.
method (unicode, optional):
The request method. If not provided, it defaults to a ``GET``
request.
content_type (unicode, optional):
The type of the content being POSTed.
Returns:
bytes:
The contents of the HTTP response body.
Raises:
urllib2.URLError:
The HTTP request failed.
"""
if self.csrf_protection_enabled and not self.crumb:
try:
self._fetch_csrf_token()
except HTTPError as e:
if e.code == 404:
self.csrf_protection_enabled = False
else:
raise e
return self._make_raw_request(url, body, method, content_type)
def _make_raw_request(self, url, body=None, method='GET',
content_type=''):
"""Make an HTTP request.
Args:
url (unicode):
The URL to make the request against.
body (unicode or bytes, optional):
The content of the request.
method (unicode, optional):
The request method. If not provided, it defaults to a ``GET``
request.
content_type (unicode, optional):
The type of the content being POSTed.
Returns:
bytes:
The contents of the HTTP response body.
Raises:
urllib2.URLError:
The HTTP request failed.
"""
logger.debug('Making request to Jenkins CI %s', url)
headers = {}
if self.crumb:
headers[self.crumb_request_field] = self.crumb
if content_type:
headers['Content-Type'] = content_type
if isinstance(body, six.text_type):
body = body.encode('utf-8')
request = HostingServiceHTTPRequest(
url,
body=body,
method=method,
headers=headers)
request.add_basic_auth(self.username, self.password)
return self._open_request(request)
def _open_request(self, request):
"""Perform an HTTP request.
Args:
request (reviewboard.hostingsvcs.service.
HostingServiceHTTPRequest):
The HTTP request object.
Returns:
bytes:
The response data.
"""
if hasattr(request, 'open'):
# Review Board >= 4.0
response = request.open()
data = response.data
else:
# Review Board 3.x
response = urlopen(request)
data = response.read()
return data
| [
37811,
18274,
2410,
329,
24986,
351,
262,
21835,
14514,
7824,
526,
15931,
198,
198,
6738,
11593,
37443,
834,
1330,
28000,
1098,
62,
17201,
874,
198,
198,
11748,
33918,
198,
11748,
18931,
198,
198,
6738,
42625,
14208,
13,
26791,
1330,
2237... | 2.0332 | 3,494 |
#!/usr/bin/env python
"""
Counter the number of biomes in the world. Works only for Anvil-based world folders.
"""
import locale
import os
import sys
# local module
try:
import nbt
except ImportError:
# nbt not in search path. Let's see if it can be found in the parent folder
extrasearchpath = os.path.realpath(os.path.join(__file__, os.pardir, os.pardir))
if not os.path.exists(os.path.join(extrasearchpath, 'nbt')):
raise
sys.path.append(extrasearchpath)
from nbt.world import AnvilWorldFolder
BIOMES = {
0: "Ocean",
1: "Plains",
2: "Desert",
3: "Mountains",
4: "Forest",
5: "Taiga",
6: "Swamp",
7: "River",
8: "Nether",
9: "Sky",
10: "Frozen Ocean",
11: "Frozen River",
12: "Ice Plains",
13: "Ice Mountains",
14: "Mushroom Island",
15: "Mushroom Shore",
16: "Beach",
17: "Desert Hills",
18: "Forest Hills",
19: "Taiga Hills",
20: "Mountains Edge",
21: "Jungle",
22: "Jungle Hills",
# 255: "Not yet calculated",
}
if __name__ == '__main__':
if (len(sys.argv) == 1):
print("No world folder specified!")
sys.exit(64) # EX_USAGE
world_folder = sys.argv[1]
if (not os.path.exists(world_folder)):
print("No such folder as " + world_folder)
sys.exit(72) # EX_IOERR
sys.exit(main(world_folder))
| [
2,
48443,
14629,
14,
8800,
14,
24330,
21015,
198,
37811,
198,
31694,
262,
1271,
286,
3182,
2586,
287,
262,
995,
13,
10933,
691,
329,
1052,
2991,
12,
3106,
995,
24512,
13,
198,
37811,
198,
11748,
36693,
198,
11748,
28686,
198,
11748,
2... | 2.451677 | 507 |
#!/usr/bin/python
from mininet.net import Mininet
from mininet.node import Controller, OVSKernelAP
from mininet.cli import CLI
from mininet.link import TCLink
from mininet.log import setLogLevel
def topology():
"Create a network."
net = Mininet(controller=Controller, link=TCLink, accessPoint=OVSKernelAP)
print "*** Creating nodes"
m1 = net.addStation('m1', wlans=2)
m2 = net.addStation('m2', wlans=2)
b1 = net.addStation('b1', position='35,142,0')
ap1 = net.addAccessPoint('ap1', ssid='ssid-ap1', mode='g', channel='11', position='115,62,0')
ap2 = net.addAccessPoint('ap2', ssid='ssid-ap2', mode='g', channel='1', position='57,142,0')
c1 = net.addController('c1', controller=Controller)
print "*** Configuring wifi nodes"
net.configureWifiNodes()
m1.setIP('10.0.0.1/8', intf="m1-wlan0")
m2.setIP('10.0.0.2/8', intf="m2-wlan0")
m1.setIP('192.168.10.1/24', intf="m1-wlan1")
m2.setIP('192.168.10.2/24', intf="m2-wlan1")
b1.setIP('192.168.10.3/24', intf="b1-wlan0")
print "*** Creating links"
net.addHoc(m1, ssid='adhocNet', mode='g')
net.addHoc(m2, ssid='adhocNet', mode='g')
net.addLink(ap2, b1)
print "*** Starting network"
net.build()
c1.start()
ap1.start([c1])
ap2.start([c1])
net.plotGraph(max_x=200, max_y=200)
net.startMobility(time=0, AC='ssf') # Association Control = Strongest-Signal-First
net.mobility(m1, 'start', time=1, position='86,188,0')
net.mobility(m2, 'start', time=1, position='78,195,0')
net.mobility(m1, 'stop', time=250, position='86,0,0')
net.mobility(m2, 'stop', time=250, position='78,7,0')
net.stopMobility(time=250)
print "*** Running CLI"
CLI(net)
print "*** Stopping network"
net.stop()
if __name__ == '__main__':
setLogLevel('info')
topology()
| [
2,
48443,
14629,
14,
8800,
14,
29412,
198,
198,
6738,
949,
42504,
13,
3262,
1330,
1855,
42504,
198,
6738,
949,
42504,
13,
17440,
1330,
22741,
11,
440,
53,
18831,
7948,
2969,
198,
6738,
949,
42504,
13,
44506,
1330,
43749,
198,
6738,
94... | 2.256442 | 815 |
import os
from flask import Flask, render_template, request
from flask_bootstrap import Bootstrap
app = Flask (__name__)
Bootstrap(app)
application = app # for beanstalk
questions = [
{
"id": "1",
"question": "What are the maximum read replicas for MySQL, PostGreSQL, and MariaDB RDS?",
"answers": [
"a) 3",
"b) 5",
"c) 10",
"d) 25"
],
"correct": "b) 5"
},
{
"id": "2",
"question": "Which of the following is not a valid type of AWS Load Balancer?",
"answers": [
"a) Application Load Balancer",
"b) Classic Load Balancer",
"c) Internal Load Balancer",
"d) Network Load Balancer"
],
"correct": "c) Internal Load Balancer"
},
{
"id": "3",
"question": "What is the max size for an Elastic Beanstalk Source Bundle?",
"answers": [
"a) 128 mb",
"b) 256 mb",
"c) 512 mb",
"d) 1024 mb"
],
"correct": "c) 512 mb"
}
]
labels = [ 'correct', 'incorrect']
values = [ 3, 1 ]
colors = ["#F7464A", "#46FBD", "#FDB45C", "#FEDCBA"]
@app.route("/", methods=['POST', 'GET'])
if __name__ == "__main__":
# Setting debug to True enables debug output. This line should be
# removed before deploying to production.
app.debug = True
app.run() | [
11748,
28686,
220,
198,
6738,
42903,
1330,
46947,
11,
8543,
62,
28243,
11,
2581,
198,
6738,
220,
42903,
62,
18769,
26418,
1330,
18892,
26418,
198,
1324,
796,
46947,
357,
834,
3672,
834,
8,
198,
36476,
26418,
7,
1324,
8,
198,
31438,
79... | 2.081514 | 687 |
import heapq
import bisect
#def minHeapify()
if __name__ == '__main__':
graph = {0: [(1, 1), (2, 2), (5, 6)], 1: [(3, 2), (0, 1)], 2: [(4, 5), (5, 3), (0, 2)], 3: [(1, 2)], 4: [(2, 5)], 5: [(0, 6), (2, 3)] }
parallel_graph = {0:[(1, 1), (2, 1), (3, 3)], 1: [(3, 2)], 2:[(3, 2),(4, 2)], 3:[(5, 3)], 4:[(5, 3)], 5:[(3, 3), (4, 3)]}
#print(dijkstra(graph, 0, 5))
#print(floyd_warshall(graph))
print(allPossibleShortestPaths(parallel_graph, 0, 5))
| [
11748,
24575,
80,
198,
11748,
47457,
478,
198,
198,
2,
4299,
949,
1544,
499,
1958,
3419,
628,
220,
220,
220,
220,
220,
220,
220,
220,
198,
220,
220,
220,
220,
220,
220,
220,
220,
198,
361,
11593,
3672,
834,
6624,
705,
834,
12417,
... | 1.833333 | 264 |
# Generated by Django 2.1 on 2021-07-19 19:40
import cloudinary.models
from django.db import migrations
| [
2,
2980,
515,
416,
37770,
362,
13,
16,
319,
33448,
12,
2998,
12,
1129,
678,
25,
1821,
198,
198,
11748,
6279,
3219,
13,
27530,
198,
6738,
42625,
14208,
13,
9945,
1330,
15720,
602,
628
] | 3.117647 | 34 |
from .afcm import FCM, TopicManager # pylint: disable=unused-import
| [
6738,
764,
1878,
11215,
1330,
10029,
44,
11,
47373,
13511,
220,
1303,
279,
2645,
600,
25,
15560,
28,
403,
1484,
12,
11748,
198
] | 3 | 23 |
#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
import fuckcheat
import time
import random
if __name__ == '__main__':
main() | [
2,
48443,
14629,
14,
8800,
14,
24330,
21015,
18,
198,
2,
532,
9,
12,
19617,
25,
41002,
12,
23,
532,
9,
12,
198,
198,
11748,
5089,
46799,
198,
11748,
640,
198,
11748,
4738,
628,
198,
361,
11593,
3672,
834,
6624,
705,
834,
12417,
83... | 2.591837 | 49 |
# -*- coding: utf-8 -*-
class PWNAPIError(Exception):
"""
Base exceptions raised when PWN API causes errors
"""
class DjangoPWNError(Exception):
"""
Base exceptions raised when django-pwn application errors occur
"""
| [
2,
532,
9,
12,
19617,
25,
3384,
69,
12,
23,
532,
9,
12,
198,
4871,
350,
29767,
17614,
12331,
7,
16922,
2599,
198,
220,
220,
220,
37227,
198,
220,
220,
220,
7308,
13269,
4376,
618,
350,
29767,
7824,
5640,
8563,
198,
220,
220,
220,
... | 2.963415 | 82 |
import numpy as np
from joblib import Parallel, delayed
import pandas
from itertools import product
from libsvmdata.datasets import fetch_libsvm
from celer import LogisticRegression
from sparse_ho.models import SparseLogreg
from sparse_ho.ho import grad_search, hyperopt_wrapper
from sparse_ho.implicit_forward import ImplicitForward
from sparse_ho.utils_datasets import (clean_dataset, alpha_max_multiclass,
get_splits)
from sparse_ho.utils import Monitor
from sparse_ho.criterion import LogisticMulticlass
from sparse_ho.optimizers import LineSearch
dataset_names = ["rcv1_multiclass"]
# dataset_names = ["mnist", "usps", "sector_scale"]
# dataset_names = ["news20_multiclass"]
# dataset_names = ["sector_scale"]
# dataset_names = ["aloi"]
# dataset_names = ["sector_scale", "aloi"]
# methods = ['implicit_forward_scipy']
# methods = ['grid_search']
# methods = ["implicit_forward", "random", "bayesian"]
methods = ["random", "bayesian"]
# methods = ["bayesian"]
# methods = ["implicit_forward_cdls"]
# methods = ["implicit_forward"]
# methods = ["implicit_forward_cdls", "implicit_forward"]
# methods = ["implicit_forward", "random", "bayesian"]
tols = 1e-7
n_outers = [40]
dict_t_max = {}
dict_t_max["rcv1_multiclass"] = 3600
dict_t_max["real-sim"] = 100
dict_t_max["leukemia"] = 10
dict_t_max["20news"] = 500
dict_t_max["usps"] = 1500
dict_t_max["sensit"] = 3600
dict_t_max["aloi"] = 3600
dict_t_max["sector_scale"] = 3600
dict_t_max["news20_multiclass"] = 3600
dict_t_max["mnist"] = 1200
dict_subsampling = {}
dict_subsampling["mnist"] = (5_000, 1000)
dict_subsampling["rcv1_multiclass"] = (21_000, 20_000)
dict_subsampling["aloi"] = (5_000, 100)
dict_subsampling["aloi"] = (5_000, 100)
dict_subsampling["usps"] = (10_000, 10_000)
dict_subsampling["sensit"] = (100_000, 100)
dict_subsampling["sector_scale"] = (10_000, 30_000)
dict_subsampling["news20_multiclass"] = (10_000, 30_000)
dict_max_eval = {}
dict_max_eval["mnist"] = 50
dict_max_eval["rcv1_multiclass"] = 100
dict_max_eval["aloi"] = 50
dict_max_eval["usps"] = 40
dict_max_eval["sensit"] = 40
dict_max_eval["sector_scale"] = 40
dict_max_eval["news20_multiclass"] = 40
print("enter parallel")
backend = 'loky'
# n_jobs = 1
n_jobs = len(methods) * len(dataset_names)
results = Parallel(n_jobs=n_jobs, verbose=100, backend=backend)(
delayed(parallel_function)(
dataset_name, method, n_outer=n_outer, tol=tols)
for dataset_name, method, n_outer in product(
dataset_names, methods, n_outers))
print('OK finished parallel')
df = pandas.DataFrame(results)
df.columns = [
'dataset', 'method', 'tol', 'n_outer', 'times', 'objs', 'acc_vals',
'acc_tests', 'log_alphas', "log_alpha_max",
"n_subsamples", "n_subfeatures", "n_classes"]
for dataset_name in dataset_names:
for method in methods:
df[(df['dataset'] == dataset_name) & (
df['method'] == method)].to_pickle(
"results/%s_%s.pkl" % (dataset_name, method))
| [
11748,
299,
32152,
355,
45941,
198,
6738,
1693,
8019,
1330,
42945,
11,
11038,
198,
11748,
19798,
292,
198,
6738,
340,
861,
10141,
1330,
1720,
198,
6738,
9195,
82,
14761,
7890,
13,
19608,
292,
1039,
1330,
21207,
62,
8019,
82,
14761,
198,... | 2.514694 | 1,191 |
#!/usr/bin/env python
from auvlib.data_tools import xtf_data, std_data, all_data
from auvlib.bathy_maps import mesh_map
import numpy as np
# # Load centered data
# std_pings_centered = std_data.mbes_ping.read_data("Data/std_pings_centered.cereal")
# # Load raw data .all file
# file_path = "/home/chs/Desktop/Sonar/Data/EM2040/low"
# # read all_mbes_ping from .all data
# all_ping = all_data.all_mbes_ping.parse_folder(file_path)
# # read all_nav_entry from .all data
# nav = all_data.all_nav_entry.parse_folder(file_path)
# # convert .all file to std data
# std_pings = all_data.convert_matched_entries(all_ping, nav)
# for ping in std_pings_centered:
# if std_pings[0].time_stamp_ == ping.time_stamp_:
# delta_pos = std_pings[0].pos_ - ping.pos_
# print("Delta pos =")
# print(delta_pos)
''' After checking, the delta pos is 650461.68011388 6471645.21805158'''
# Load Uncented pings
std_pings = std_data.mbes_ping.read_data("Data/EM2040/mid/pings_outlier_discard.cereal")
std_pings_centered = []
for ping in std_pings:
new_pos = ping.pos_ - np.array([650461.68011388, 6471645.21805158, 0])
ping.pos_ = new_pos
new_beams = []
for beam in ping.beams:
new_beam = beam - [650461.68011388, 6471645.21805158, 0]
new_beams.append(new_beam)
ping.beams = new_beams
std_pings_centered.append(ping)
std_data.write_data(std_pings_centered, 'Data/EM2040/mid/pings_centered.cereal')
print("???")
| [
2,
48443,
14629,
14,
8800,
14,
24330,
21015,
198,
198,
6738,
257,
14795,
8019,
13,
7890,
62,
31391,
1330,
220,
742,
69,
62,
7890,
11,
14367,
62,
7890,
11,
477,
62,
7890,
198,
6738,
257,
14795,
8019,
13,
65,
10036,
62,
31803,
1330,
... | 2.310832 | 637 |
import os
import tempfile
import unittest
import matplotlib.pyplot as plt
import numpy as np
from fastestimator.test.unittest_util import is_equal, sample_system_object
from fastestimator.trace.io import ImageSaver
from fastestimator.util.data import Data
from fastestimator.util.img_data import ImgData
| [
11748,
28686,
198,
11748,
20218,
7753,
198,
11748,
555,
715,
395,
198,
198,
11748,
2603,
29487,
8019,
13,
9078,
29487,
355,
458,
83,
198,
11748,
299,
32152,
355,
45941,
198,
198,
6738,
14162,
320,
1352,
13,
9288,
13,
403,
715,
395,
62... | 3.301075 | 93 |
"""
Multi TranslationDataset
=============================
"""
from .ted_multi import TedMultiTranslationDataset
| [
37811,
198,
198,
29800,
33322,
27354,
292,
316,
198,
4770,
25609,
28,
198,
37811,
198,
198,
6738,
764,
1513,
62,
41684,
1330,
11396,
29800,
48313,
27354,
292,
316,
198
] | 3.965517 | 29 |
'''
ECGR 5101 FINAL PROJECT
12/12/2018
REFERENCES:https://github.com/Mjrova
PROJECT TITLE: EYE MECHANISM FOR INMOOV ROBOT
PROJECT DESCRIPTION:
picam is used for the video and it is being sampled frame by frame. We identify the contour of the object in the frame using
opencv libraries and functionalities. With the help of contour we got the co-ordinates of the center point of the contour. As the object moves
so does the contour and the co-ordinates. With the help of co-ordinates we give the output to the servo motor.
'''
# import the necessary packages
from __future__ import print_function
from imutils.video import VideoStream
import argparse
import imutils
import time
import cv2
import os
import RPi.GPIO as GPIO
#define Servos GPIOs
panServo = 27
tiltServo = 17
#servo position
# position servos to present object at center of the snap
# initialize camera sensor to warmup
print(" camera to warmup...")
video = VideoStream(0).start()
time.sleep(2.0)
# define the lower and upper boundaries of object
colorLower = (24, 100, 100)
colorUpper = (44, 255, 255)
# Initialize angle servos at 110-105 position
global panDegree
panDegree = 110
global tiltDegree
tiltDegree =105
# positioning servos at initial position
posi_servo (panServo, panDegree)
posi_servo (tiltServo, tiltDegree)
# loop over the snaps from the video stream
while True:
# next snap from the video stream
#convert it to the HSV color space
snap = video.read()
snap = imutils.resize(snap, width=500)
snap = imutils.rotate(snap, angle=180)
hsv = cv2.cvtColor(snap, cv2.COLOR_BGR2HSV)
# construct mask for object color
mask = cv2.inRange(hsv, colorLower, colorUpper)
mask = cv2.erode(mask, None, iterations=2)
mask = cv2.dilate(mask, None, iterations=2)
# initialize the current (x, y) center of the object
cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnts = cnts[0] if imutils.is_cv2() else cnts[1]
center = None
# only proceed if at least one contour was found
if len(cnts) > 0:
# find the largest contour in the mask
c = max(cnts, key=cv2.contourArea)
((x, y), rad) = cv2.minEnclosingCircle(c)
M = cv2.moments(c)
center = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"]))
# proceed if the rad meets a minimum size
if rad > 10:
# draw the circle and centroid on snap
cv2.circle(snap, (int(x), int(y)), int(rad),
(0, 255, 255), 2)
cv2.circle(snap, center, 5, (0, 0, 255), -1)
# Servo at center
servo_mapping(int(x), int(y))
# show the snap to our screen
cv2.imshow("snap", snap)
# if [ESC] key is pressed, stop the loop
key = cv2.waitKey(1) & 0xFF
if key == 27:
break
# do cleanup
print("\n cleanup stuff \n")
GPIO.cleanup()
cv2.destroyAllWindows()
video.stop()
| [
7061,
6,
201,
198,
2943,
10761,
6885,
486,
25261,
21965,
23680,
201,
198,
1065,
14,
1065,
14,
7908,
201,
198,
2200,
24302,
24181,
1546,
25,
5450,
1378,
12567,
13,
785,
14,
44,
73,
305,
6862,
201,
198,
31190,
23680,
37977,
2538,
25,
... | 2.34301 | 1,309 |
from __future__ import absolute_import
from __future__ import print_function
from __future__ import division
from six.moves import xrange
import warnings
import logging
import keras.backend as K
from keras.callbacks import Callback, ModelCheckpoint
| [
198,
6738,
11593,
37443,
834,
1330,
4112,
62,
11748,
198,
6738,
11593,
37443,
834,
1330,
3601,
62,
8818,
198,
6738,
11593,
37443,
834,
1330,
7297,
198,
6738,
2237,
13,
76,
5241,
1330,
2124,
9521,
198,
198,
11748,
14601,
198,
11748,
1893... | 3.833333 | 66 |
#!/usr/bin/python2.7
# -*- coding: utf-8 -*-
from bottle import route, run, template
@route('/hello/<name>')
run(host='0.0.0.0', port=80)
| [
2,
48443,
14629,
14,
8800,
14,
29412,
17,
13,
22,
198,
2,
532,
9,
12,
19617,
25,
3384,
69,
12,
23,
532,
9,
12,
198,
6738,
9294,
1330,
6339,
11,
1057,
11,
11055,
198,
31,
38629,
10786,
14,
31373,
14,
27,
3672,
29,
11537,
198,
5... | 2.225806 | 62 |
# -*- coding: utf-8 -*-
import gevent.monkey;gevent.monkey.patch_socket()
from gevent.pool import Pool
import codecs
import requests
from redis import Redis
from rq import Queue
from pyquery import PyQuery as pq
from bs4 import BeautifulSoup
from model import OneIssue
q = Queue(connection=Redis())
# q.enqueue_call(func=OneIssue.create,
# args=(1,[]),
# timeout=30)
# 177 - 432
# url="http://hanhan.qq.com/hanhan/one/one177m.htm"
pool = Pool(50)
pool.map(fetch, xrange(177,432+1))
| [
2,
532,
9,
12,
19617,
25,
3384,
69,
12,
23,
532,
9,
12,
198,
11748,
4903,
1151,
13,
49572,
26,
469,
1151,
13,
49572,
13,
17147,
62,
44971,
3419,
198,
6738,
4903,
1151,
13,
7742,
1330,
19850,
198,
11748,
40481,
82,
198,
11748,
7007... | 2.40553 | 217 |
import time
import cv2 as cv
from misc import utils
from classification.feature_classifier import FeatureClassifier
from misc.color_space import ColorSpace
from misc.model_tester import ModelTester, get_mean_accuracy
from data_io.testdata import TestData
import numpy as np
from math import sqrt
import data_io.settings as Settings
import logging
class HistogramClassifier(FeatureClassifier):
"""Histogram classifier class that uses color information for classification. """
def create_feature_vector(self, image):
""" Creates the feature vector out of histograms."""
# convert image depending on desired color space for the histogram
temp = []
colors = ("b", "g", "r")
try:
if Settings.H_COLOR_SPACE == ColorSpace.HSV:
temp = cv.cvtColor(image, cv.COLOR_BGR2HSV)
colors = ("h", "s", "v")
elif Settings.H_COLOR_SPACE == ColorSpace.RGB:
temp = cv.cvtColor(image, cv.COLOR_BGR2RGB)
colors = ("r", "g", "b")
else:
temp = image
except:
logging.exception("Could not convert image to {0}.".format(Settings.H_COLOR_SPACE))
cv.imshow("Error CV", image)
utils.display_images([image], None, ["Error"], 1, 1)
# split image into x different parts.
imageParts = []
height, width = temp.shape[:2]
partHeight = int(height / self.imageRows)
partWidth = int(width / self.imageCols)
scaleMaxPossibleValue = partWidth * partHeight
# modify height and width in case partHeight and partWidth don't add up to the real width and height.
# in this case the image would be cut into more than x parts because some leftover pixels would be included.
height = int(partHeight * self.imageRows)
width = int(partWidth * self.imageCols)
for y in xrange(0, height, partHeight):
for x in xrange(0, width, partWidth):
imageParts.append(utils.crop_image(temp, x, y, partWidth, partHeight))
histogram = []
for img in imageParts:
for i, color in enumerate(colors):
hist = cv.calcHist([img], [i], None, [Settings.H_BINS], Settings.H_COLOR_RANGE)
if Settings.H_SCALE_HIST:
# max possible value is w * h of imagePart
hist /= scaleMaxPossibleValue
histogram.extend(hist)
return np.array(np.concatenate(histogram))
| [
11748,
640,
201,
198,
11748,
269,
85,
17,
355,
269,
85,
201,
198,
6738,
12747,
1330,
3384,
4487,
201,
198,
6738,
17923,
13,
30053,
62,
4871,
7483,
1330,
27018,
9487,
7483,
201,
198,
6738,
12747,
13,
8043,
62,
13200,
1330,
5315,
14106,... | 2.18263 | 1,232 |
# -*- coding: utf-8 -*-
"""See log bayes factors which led to modality categorization"""
import locale
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
from .names import NEAR_ZERO, NEAR_HALF, NEAR_ONE, BIMODAL, \
NULL_MODEL
darkblue, green, red, purple, yellow, lightblue = sns.color_palette('deep')
MODALITY_ORDER = [NEAR_ZERO, BIMODAL, NEAR_ONE, NEAR_HALF, NULL_MODEL]
MODALITY_TO_COLOR = {NEAR_ZERO: lightblue, NEAR_HALF: yellow, NEAR_ONE: red,
BIMODAL: purple, NULL_MODEL: 'lightgrey'}
MODALITY_PALETTE = [MODALITY_TO_COLOR[m] for m in MODALITY_ORDER]
MODALITY_TO_CMAP = {
NEAR_ZERO: sns.light_palette(MODALITY_TO_COLOR[NEAR_ZERO], as_cmap=True),
NEAR_HALF: sns.light_palette(MODALITY_TO_COLOR[NEAR_HALF], as_cmap=True),
NEAR_ONE: sns.light_palette(MODALITY_TO_COLOR[NEAR_ONE], as_cmap=True),
BIMODAL: sns.light_palette(MODALITY_TO_COLOR[BIMODAL], as_cmap=True),
NULL_MODEL: mpl.cm.Greys}
MODALITY_FACTORPLOT_KWS = dict(hue_order=MODALITY_ORDER,
palette=MODALITY_PALETTE)
def violinplot(x=None, y=None, data=None, bw=0.2, scale='width',
inner=None, ax=None, **kwargs):
"""Wrapper around Seaborn's Violinplot specifically for [0, 1] ranged data
What's different:
- bw = 0.2: Sets bandwidth to be small and the same between datasets
- scale = 'width': Sets the width of all violinplots to be the same
- inner = None: Don't plot a boxplot or points inside the violinplot
"""
if ax is None:
ax = plt.gca()
sns.violinplot(x, y, data=data, bw=bw, scale=scale, inner=inner, ax=ax,
**kwargs)
ax.set(ylim=(0, 1), yticks=(0, 0.5, 1))
return ax
class ModalitiesViz(object):
"""Visualize results of modality assignments"""
modality_order = MODALITY_ORDER
modality_to_color = MODALITY_TO_COLOR
modality_palette = MODALITY_PALETTE
def bar(self, counts, phenotype_to_color=None, ax=None, percentages=True):
"""Draw barplots grouped by modality of modality percentage per group
Parameters
----------
Returns
-------
Raises
------
"""
if percentages:
counts = 100 * (counts.T / counts.T.sum()).T
# with sns.set(style='whitegrid'):
if ax is None:
ax = plt.gca()
full_width = 0.8
width = full_width / counts.shape[0]
for i, (group, series) in enumerate(counts.iterrows()):
left = np.arange(len(self.modality_order)) + i * width
height = [series[i] if i in series else 0
for i in self.modality_order]
color = phenotype_to_color[group]
ax.bar(left, height, width=width, color=color, label=group,
linewidth=.5, edgecolor='k')
ylabel = 'Percentage of events' if percentages else 'Number of events'
ax.set_ylabel(ylabel)
ax.set_xticks(np.arange(len(self.modality_order)) + full_width / 2)
ax.set_xticklabels(self.modality_order)
ax.set_xlabel('Splicing modality')
ax.set_xlim(0, len(self.modality_order))
ax.legend(loc='best')
ax.grid(axis='y', linestyle='-', linewidth=0.5)
sns.despine()
def event_estimation(self, event, logliks, logsumexps, renamed=''):
"""Show the values underlying bayesian modality estimations of an event
Parameters
----------
Returns
-------
Raises
------
"""
plotter = _ModelLoglikPlotter()
plotter.plot(event, logliks, logsumexps, self.modality_to_color,
renamed=renamed)
return plotter
| [
2,
532,
9,
12,
19617,
25,
3384,
69,
12,
23,
532,
9,
12,
198,
37811,
6214,
2604,
15489,
274,
5087,
543,
2957,
284,
953,
1483,
17851,
1634,
37811,
198,
11748,
36693,
198,
198,
11748,
299,
32152,
355,
45941,
198,
11748,
2603,
29487,
80... | 2.168481 | 1,745 |
# -*- coding: utf-8 -*-
"""
Created on Wed Nov 17 13:04:03 2021
@author: Jionghao Fang
"""
import pandas as pd
import numpy as np
import random
from sklearn.preprocessing import StandardScaler
# from imblearn.over_sampling import SMOTE
from sklearn.decomposition import PCA
from sklearn.metrics import mean_squared_error as mse
from sklearn.linear_model import Perceptron
from sklearn.svm import SVC
from sklearn.neural_network import MLPClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import AdaBoostClassifier
from sklearn.semi_supervised import LabelPropagation,LabelSpreading
# from wrapper import SKTSVM
'''read data'''
'''read all-labeled data(vowel-10-1trs)'''
df = pd.read_table("data/SSC_20labeled/vowel/vowel-10-1trs.dat")
df0 = df.iloc[17:,0]
df00 = df0.tolist()
data = []
for i in range(len(df00)):
data.append([])
l = df00[i].split(',')
for j in range(len(l)):
data[i].append(float(l[j]))
feature_all = np.array(data)[:, :-1]
label_all = np.array(data)[:,-1]
'''read 20% labeled data(vowel-10-1tra)'''
df = pd.read_table("data/SSC_20labeled/vowel/vowel-10-1tra.dat")
df0 = df.iloc[17:,0]
df00 = df0.tolist()
#20% labeled data
n = int(len(df00) * 0.2)
ssc_20 = df00[0:n]
data_20 = []
for i in range(len(ssc_20)):
data_20.append([])
l = ssc_20[i].split(',')
for j in range(len(l)):
data_20[i].append(float(l[j]))
feature_20 = np.array(data_20)
feature_20 = feature_20[:,:-1]
label_20 = np.array(data_20)[:,-1]
#80% unlabeled data
ssc_20_unlabeled = df00[n:]
feature = []
for i in range(len(ssc_20_unlabeled)):
feature.append(ssc_20_unlabeled[i][:-11])
feature_80 = []
for i in range(len(feature)):
feature_80.append([])
l = feature[i].split(',')
for j in range(len(l)):
feature_80[i].append(float(l[j]))
feature_80 = np.array(feature_80)
#20% test data
df = pd.read_table("data/SSC_20labeled/vowel/vowel-10-1tst.dat")
df0 = df.iloc[17:,0]
df00 = df0.tolist()
test = []
for i in range(len(df00)):
test.append([])
l = df00[i].split(',')
for j in range(len(l)):
test[i].append(float(l[j]))
feature_test = np.array(data)[:, :-1]
label_test = np.array(data)[:,-1]
'''data preprocessing'''
'''standardize'''
'''PCA'''
# '''Smote'''
# def smote(X, y):
# sm = SMOTE(random_state=42)
# return sm.fit_resample(X, y)
'''baseline'''
'''majority voting'''
# #try 100% labeled data
# label_all = label_all.tolist()
# feature_all = feature_all.tolist()
# y_pred_100 = majority_voting(label_all, feature_all)
# mse_100 = mse(label_all,y_pred_100)
# #try 20% labeled data
# label_20 = label_20.tolist()
# feature_20 = feature_20.tolist()
# y_pred_20 = majority_voting(label_20, feature_20)
# mse_20 = mse(label_20, y_pred_20)
# #try test data
# label_test = label_test.tolist()
# feature_test = feature_test.tolist()
# y_pred_test = majority_voting(label_all, feature_test)
# mse_test = mse(label_test, y_pred_test)
'''random_choice'''
# #try 100% labeled data
# label_all = label_all.tolist()
# feature_all = feature_all.tolist()
# y_pred_100 = random_choice(label_all, feature_all)
# mse_100 = mse(label_all,y_pred_100)
# #try 20% labeled data
# label_20 = label_20.tolist()
# feature_20 = feature_20.tolist()
# y_pred_20 = random_choice(label_20, feature_20)
# mse_20 = mse(label_20, y_pred_20)
# #try test data
# label_test = label_test.tolist()
# feature_test = feature_test.tolist()
# y_pred_test = random_choice(label_all, feature_test)
# mse_test = mse(label_test, y_pred_test)
'''base models'''
'''Perceptron'''
# #try 100% labeled data
# y_pred_100, acc_100 = perceptron(feature_all, label_all, feature_all)
# mse_100 = mse(label_all, y_pred_100)
# #try 20% labeled data
# y_pred_20, acc_20 = perceptron(feature_20,label_20, feature_20, label_20)
# mse_20 = mse(label_20, y_pred_20)
# #try test data(100%)
# y_pred_test_100, acc_test_100 = perceptron(feature_all,label_all, feature_test, label_test)
# mse_test_100 = mse(label_test, y_pred_test_100)
# #try test data(20%)
# y_pred_test_20, acc_test_20 = perceptron(feature_20,label_20, feature_test, label_test)
# mse_test_20 = mse(label_test, y_pred_test_20)
'''SVC(kernel = rbf)'''
# #try 100% labeled data
# y_pred_100, acc_100 = SVC_rbf(feature_all, label_all, feature_all)
# mse_100 = mse(label_all, y_pred_100)
# #try 20% labeled data
# y_pred_20, acc_20 = SVC_rbf(feature_20,label_20, feature_20, label_20)
# mse_20 = mse(label_20, y_pred_20)
# #try test data(100%)
# y_pred_test_100, acc_test_100 = SVC_rbf(feature_all,label_all, feature_test, label_test)
# mse_test_100 = mse(label_test, y_pred_test_100)
# #try test data(20%)
# y_pred_test_20, acc_test_20 = SVC_rbf(feature_20,label_20, feature_test, label_test)
# mse_test_20 = mse(label_test, y_pred_test_20)
'''MLP'''
# #try 100% labeled data
# y_pred_100, acc_100 = mlp(feature_all, label_all, feature_all)
# mse_100 = mse(label_all, y_pred_100)
# #try 20% labeled data
# y_pred_20, acc_20 = mlp(feature_20,label_20, feature_20, label_20)
# mse_20 = mse(label_20, y_pred_20)
# #try test data(100%)
# y_pred_test_100, acc_test_100 = mlp(feature_all,label_all, feature_test, label_test)
# mse_test_100 = mse(label_test, y_pred_test_100)
# #try test data(20%)
# y_pred_test_20, acc_test_20 = mlp(feature_20,label_20, feature_test, label_test)
# mse_test_20 = mse(label_test, y_pred_test_20)
'''random forest'''
# #try 100% labeled data
# y_pred_100, acc_100 = random_forest(feature_all, label_all, feature_all,label_all)
# mse_100 = mse(label_all, y_pred_100)
# #try 20% labeled data
# y_pred_20, acc_20 = random_forest(feature_20,label_20, feature_20, label_20)
# mse_20 = mse(label_20, y_pred_20)
# #try test data(100%)
# y_pred_test_100, acc_test_100 = random_forest(feature_all,label_all, feature_test, label_test)
# mse_test_100 = mse(label_test, y_pred_test_100)
# #try test data(20%)
# y_pred_test_20, acc_test_20 = random_forest(feature_20,label_20, feature_test, label_test)
# mse_test_20 = mse(label_test, y_pred_test_20)
'''adaboost'''
#try 100% labeled data
# y_pred_100, acc_100 = adaboost(feature_all, label_all, feature_all, label_all)
# mse_100 = mse(label_all, y_pred_100)
# #try 20% labeled data
# y_pred_20, acc_20 = adaboost(feature_20,label_20, feature_20, label_20)
# mse_20 = mse(label_20, y_pred_20)
# #try test data(100%)
# y_pred_test_100, acc_test_100 = adaboost(feature_all,label_all, feature_test, label_test)
# mse_test_100 = mse(label_test, y_pred_test_100)
# #try test data(20%)
# y_pred_test_20, acc_test_20 = adaboost(feature_20,label_20, feature_test, label_test)
# mse_test_20 = mse(label_test, y_pred_test_20)
'''Semi-supervised learning'''
'''label propagating'''
# #try test data(20%)
# acc_test_20 = semi_prop(feature_20,label_20, feature_80, feature_test, label_test)
'''label spreading'''
# #try test data(20%)
# acc_test_20 = semi_spread(feature_20,label_20, feature_80, feature_test, label_test)
'''S3VM'''
'''assign unlabeled data with the label -1'''
# def S3VM(fea_l, label_l, fea_u, fea_test, label_test):
# label_u = np.zeros(len(fea_u)) -1
# SSL_label = label_l.tolist() + label_u.tolist()
# SSL_feature = np.vstack((fea_l, fea_u))
# S3VM = SKTSVM(kernel = 'linear', lamU = 1.0)
# S3VM.fit(SSL_feature, SSL_label)
# acc = S3VM.score(fea_test, label_test)
# return acc
# #try test data(20%)
# acc_test_20 = semi_spread(feature_20, label_20, feature_80, feature_test, label_test)
'''K-means'''
'''reference:https://blog.csdn.net/vivian_ll/article/details/103494042'''
def distEclud(vecA, vecB):
'''
输入：向量A和B
输出：A和B间的欧式距离
'''
return np.sqrt(sum(np.power(vecA - vecB, 2)))
def newCent(L):
'''
输入：有标签数据集L
输出：根据L确定初始聚类中心
'''
centroids = []
label_list = np.unique(L[:,-1])
for i in label_list:
L_i = L[(L[:,-1])==i]
cent_i = np.mean(L_i,0)
centroids.append(cent_i[:-1])
return np.array(centroids)
def semi_kMeans(L, U, distMeas=distEclud, initial_centriod=newCent):
'''
输入：有标签数据集L（最后一列为类别标签）、无标签数据集U（无类别标签）
输出：聚类结果
'''
dataSet = np.vstack((L[:,:-1],U))#合并L和U
label_list = np.unique(L[:,-1])
k = len(label_list) #L中类别个数
m = np.shape(dataSet)[0]
clusterAssment = np.zeros(m)#初始化样本的分配
centroids = initial_centriod(L)#确定初始聚类中心
clusterChanged = True
while clusterChanged:
clusterChanged = False
for i in range(m):#将每个样本分配给最近的聚类中心
minDist = np.inf; minIndex = -1
for j in range(k):
distJI = distMeas(centroids[j,:],dataSet[i,:])
if distJI < minDist:
minDist = distJI; minIndex = j
if clusterAssment[i] != minIndex: clusterChanged = True
clusterAssment[i] = minIndex
return clusterAssment
L = np.array(data_20)
U = feature_80
pred_label = semi_kMeans(L,U)
acc = accuracy(label_all, pred_label)
| [
2,
532,
9,
12,
19617,
25,
3384,
69,
12,
23,
532,
9,
12,
201,
198,
37811,
201,
198,
41972,
319,
3300,
5267,
1596,
1511,
25,
3023,
25,
3070,
33448,
201,
198,
201,
198,
31,
9800,
25,
449,
295,
456,
5488,
24468,
201,
198,
37811,
201... | 2.004494 | 4,673 |
import datetime
from django.utils.translation import ugettext as _
| [
11748,
4818,
8079,
198,
198,
6738,
42625,
14208,
13,
26791,
13,
41519,
1330,
334,
1136,
5239,
355,
4808,
198
] | 3.578947 | 19 |
from __future__ import absolute_import
# Event types
from pypapi.papi import * # noqa: flake8 can't deal with Cython
from pypapi.papi import populate_events
populate_events()
del populate_events
| [
6738,
11593,
37443,
834,
1330,
4112,
62,
11748,
198,
198,
2,
8558,
3858,
198,
6738,
279,
4464,
15042,
13,
79,
15042,
1330,
1635,
220,
220,
220,
1303,
645,
20402,
25,
781,
539,
23,
460,
470,
1730,
351,
327,
7535,
198,
198,
6738,
279,... | 3.060606 | 66 |
"""
Desenvolva um programa que leia quatro valores pelo teclado e guarde-os em uma tupla. No final, mostre:
A) Quantas vezes apareceu o valor 9
B) Em que posição foi digitado o primeiro valor 3
C) Quais foram os números pares
"""
num = (int(input('Digite um número: ')), int(input('Digite outro número: ')),int(input('Digite mais um número: ')),
int(input('Digite o último número: ')))
if 9 in num:
print(f'O número 9 apareceu {num.count(9)} vezes!')
else:
print('O número 9 não foi digitado!')
if 3 in num:
print(f'O número três apareceu na {num.index(3) + 1} posição')
else:
print('O número 3 não foi digitado!')
pares = 0
for n in num:
if n % 2 == 0:
pares += 1
if pares > 0:
print('Os número PARES digitados foram: ', end='')
for n in num:
if n % 2 == 0:
print(n, end=' ')
else:
print('Não foram digitados valores pares!')
| [
37811,
198,
5960,
268,
10396,
6862,
23781,
1430,
64,
8358,
443,
544,
627,
47756,
1188,
2850,
16176,
78,
573,
565,
4533,
304,
4860,
68,
12,
418,
795,
334,
2611,
12777,
489,
64,
13,
1400,
2457,
11,
749,
260,
25,
198,
32,
8,
16972,
2... | 2.135392 | 421 |
import enum
import pathlib
import typing as t
import dearpygui.dearpygui as dpg
from dearpygui_ext import themes
from ... import util
from ... import error as e
_ASSET_FOLDER = pathlib.Path(__file__).parent.resolve()
_THEMES_CACHE = {}
| [
11748,
33829,
198,
11748,
3108,
8019,
198,
11748,
19720,
355,
256,
198,
198,
11748,
390,
5117,
88,
48317,
13,
67,
451,
9078,
48317,
355,
288,
6024,
198,
6738,
390,
5117,
88,
48317,
62,
2302,
1330,
13460,
198,
198,
6738,
2644,
1330,
77... | 2.764045 | 89 |
# Generated by Django 2.2 on 2019-05-12 22:23
from django.db import migrations, models
| [
2,
2980,
515,
416,
37770,
362,
13,
17,
319,
13130,
12,
2713,
12,
1065,
2534,
25,
1954,
201,
198,
201,
198,
6738,
42625,
14208,
13,
9945,
1330,
15720,
602,
11,
4981,
201,
198,
201,
198
] | 2.657143 | 35 |
import managers
from flask_redis import FlaskRedis
from flask import Flask
# Instantiate and config flask
flask_app = Flask(__name__)
flask_app.config.update(
CELERY_BROKER_URL=managers.celery_config.CELERY_BROKER_URL,
CELERY_RESULT_BACKEND=managers.celery_config.CELERY_RESULT_BACKEND,
REDIS_URL=managers.celery_config.REDIS_URL
)
# Instantiate and config celery from flask
celery = managers.make_celery(flask_app)
celery.config_from_object(managers.celery_config)
# Instantiate py-redis
redis_store = FlaskRedis(flask_app)
# We need this for task discovery
from app import tasks
| [
11748,
11663,
198,
6738,
42903,
62,
445,
271,
1330,
46947,
7738,
271,
198,
6738,
42903,
1330,
46947,
198,
198,
2,
24470,
9386,
290,
4566,
42903,
198,
2704,
2093,
62,
1324,
796,
46947,
7,
834,
3672,
834,
8,
198,
2704,
2093,
62,
1324,
... | 2.738532 | 218 |
import nose
@nose.tools.nottest
def run_tests(script_path, test_module=None):
"""
Run tests which are contained in `test_module` for script
whose location is specified in `script_path` (typically, is
called as __file__).
"""
params = ['', script_path]
if test_module:
params.append(test_module.__file__)
params.append('--with-doctest')
nose.run(argv=params)
| [
11748,
9686,
628,
198,
31,
77,
577,
13,
31391,
13,
77,
24879,
198,
4299,
1057,
62,
41989,
7,
12048,
62,
6978,
11,
1332,
62,
21412,
28,
14202,
2599,
198,
220,
220,
220,
37227,
198,
220,
220,
220,
5660,
5254,
543,
389,
7763,
287,
46... | 2.640523 | 153 |
# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License").
# You may not use this file except in compliance with the License.
# A copy of the License is located at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# or in the "license" file accompanying this file. This file is distributed
# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
# express or implied. See the License for the specific language governing
# permissions and limitations under the License.
import mxnet as mx
from gluonts.core.component import equals, equals_default_impl, skip_encoding
@equals.register(mx.gluon.ParameterDict)
def equals_parameter_dict(
this: mx.gluon.ParameterDict, that: mx.gluon.ParameterDict
) -> bool:
"""
Structural equality check between two :class:`~mxnet.gluon.ParameterDict`
objects.
Two parameter dictionaries ``this`` and ``that`` are considered
*structurally equal* if the following conditions are satisfied:
1. They contain the same keys (modulo the key prefix which is stripped).
2. The data in the corresponding value pairs is equal, as defined by the
:func:`~mxnet.test_utils.almost_equal` function (in this case we call
the function with ``equal_nan=True``, that is, two aligned ``NaN``
values are always considered equal).
Specializes :func:`equals` for invocations where the first parameter is an
instance of the :class:`~mxnet.gluon.ParameterDict` class.
Parameters
----------
this, that
Objects to compare.
Returns
-------
bool
A boolean value indicating whether ``this`` and ``that`` are
structurally equal.
See Also
--------
equals
Dispatching function.
"""
if type(this) != type(that):
return False
this_param_names_stripped = [
strip_prefix_enumeration(key, this.prefix) for key in this.keys()
]
that_param_names_stripped = [
strip_prefix_enumeration(key, that.prefix) for key in that.keys()
]
if not this_param_names_stripped == that_param_names_stripped:
return False
for this_param_name, that_param_name in zip(this.keys(), that.keys()):
x = this[this_param_name].data().asnumpy()
y = that[that_param_name].data().asnumpy()
if not mx.test_utils.almost_equal(x, y, equal_nan=True):
return False
return True
@equals.register(mx.gluon.HybridBlock)
def equals_representable_block(
this: mx.gluon.HybridBlock, that: mx.gluon.HybridBlock
) -> bool:
"""
Structural equality check between two :class:`~mxnet.gluon.HybridBlock`
objects with :func:`validated` initializers.
Two blocks ``this`` and ``that`` are considered *structurally equal* if all
the conditions of :func:`equals` are met, and in addition their parameter
dictionaries obtained with
:func:`~mxnet.gluon.block.Block.collect_params` are also structurally
equal.
Specializes :func:`equals` for invocations where the first parameter is an
instance of the :class:`~mxnet.gluon.HybridBlock` class.
Parameters
----------
this, that
Objects to compare.
Returns
-------
bool
A boolean value indicating whether ``this`` and ``that`` are
structurally equal.
See Also
--------
equals
Dispatching function.
equals_parameter_dict
Specialization of :func:`equals` for Gluon
:class:`~mxnet.gluon.ParameterDict` input arguments.
"""
if not equals_default_impl(this, that):
return False
if not equals_parameter_dict(this.collect_params(), that.collect_params()):
return False
return True
@skip_encoding.register(mx.gluon.ParameterDict)
| [
2,
15069,
2864,
6186,
13,
785,
11,
3457,
13,
393,
663,
29116,
13,
1439,
6923,
33876,
13,
198,
2,
198,
2,
49962,
739,
262,
24843,
13789,
11,
10628,
362,
13,
15,
357,
1169,
366,
34156,
11074,
198,
2,
921,
743,
407,
779,
428,
2393,
... | 2.801756 | 1,367 |
import point
"""
Embarrasingly rudimentary postscript module
The module gives you 72 pitch drawing surface on an 8 1/2 x 11
portrait type paper. It sets the ULC as x=0m y=0
it gives text, line and arrow drawing primitives
It gives a Courier font class with font metrics.
"""
color_mods = {
'red' : " 1.0 0.0 0.0 setrgbcolor ",
'green' : " 0.0 1.0 0.0 setrgbcolor ",
'blue' : " 0.0 0.0 1.0 setrgbcolor ",
'black' : ""
}
style_mods = {
'solid' : "",
'dash' : " [2] 0 setdash "
}
width_mods = {
1 : " 1 setlinewidth ",
2 : " 2 setlinewidth ",
3 : " 3 setlinewidth ",
4 : " 4 setlinewidth "
}
def_mods = G_mods()
header_text = """
%!PS-Adobe-3.0
%%Creator:pretty-poor-uml drawer
%%Orientation: Portrait
%%Pages: 1
%%DocumentFonts: (atend)
%%EndComments
%%BeginProlog
%%EndProlog
%%Page: 1 1
% move origin to upper left corner
72 0 mul 72 11.00 mul translate
1.0 dup neg scale
"""
text_template = """
%% text
0 setgray
/%s findfont [%d 0 0 -%d 0 0] makefont setfont
gsave
%d %d moveto (%s) show
grestore
"""
line_template = """
%% line
0 setgray
gsave
newpath
%s
%d %d moveto
%d %d lineto
stroke
grestore
"""
arrow_template = """
%% arrow
gsave
%s
%d %d moveto
%f rotate
%d 0 rlineto
currentpoint
160 rotate
20 0 rlineto
-160 rotate
moveto
-160 rotate
20 0 rlineto
160 rotate
stroke
grestore
"""
trailer_template = """
showpage
%%Trailer
%%DocumentFonts: Courier-Bold
%%EOF
"""
if __name__ == "__main__" :
norm = Courier(36)
bold = CourierBold(36)
ital = CourierItalic(36)
boit = CourierBoldItalic(36)
put_header()
norm.draw("normal weight 36 p.t.", point.Point(100,100))
bold.draw("bold weight 36 p.t.", point.Point(100,150))
ital.draw("normal weight, italic 36 p.t.", point.Point(100,200))
boit.draw("bold italic, 36 p.t.", point.Point(100,250))
put_line (point.Point(100,300), point.Point(200, 300))
put_line (point.Point(200,300), point.Point(300, 300),
G_mods(width=2))
put_line (point.Point(300,300), point.Point(400, 300),
G_mods(width=3))
put_line (point.Point(400,300), point.Point(500, 300),
G_mods(width=4))
put_line (point.Point(100,350), point.Point(200, 350))
put_line (point.Point(200,350), point.Point(300, 350),
G_mods(color='red'))
put_line (point.Point(300,350), point.Point(400, 350),
G_mods(color='green'))
put_line (point.Point(400,350), point.Point(500, 350),
G_mods(color='blue'))
put_line (point.Point(100,400), point.Point(200, 400))
put_line (point.Point(200,400), point.Point(300, 400),
G_mods(style='solid'))
put_line (point.Point(300,300), point.Point(400, 300),
G_mods(style='dash'))
put_arrow (point.Point(100,500), point.Point(200, 500))
put_arrow (point.Point(100,600), point.Point(200, 600),
G_mods(color="red", width=4))
put_trailer()
| [
11748,
966,
198,
198,
37811,
220,
198,
197,
31567,
3258,
2313,
306,
47381,
1281,
12048,
8265,
198,
197,
198,
197,
464,
8265,
3607,
345,
7724,
7078,
8263,
4417,
319,
281,
807,
352,
14,
17,
2124,
1367,
220,
198,
197,
634,
12907,
2099,
... | 2.406621 | 1,178 |
import sys
import os
import time
import socket
import pickle
import argparse
import datetime
import signal
sys.path.append('/usr/lib/python2.7/dist-packages/python_sdk_api/')
sys.path.append('/usr/lib/python2.7/site-packages/python_sdk_api/')
sys.path.append('/usr/local/lib/python2.7/dist-packages/python_sdk_api/')
sys.path.append('/usr/local/lib/python2.7/site-packages/python_sdk_api/')
from sx_api import *
g_ptf_host = None
g_log_fp = None
if __name__ == '__main__':
main()
| [
11748,
25064,
198,
11748,
28686,
198,
11748,
640,
198,
11748,
17802,
198,
11748,
2298,
293,
198,
11748,
1822,
29572,
198,
11748,
4818,
8079,
198,
11748,
6737,
198,
198,
17597,
13,
6978,
13,
33295,
10786,
14,
14629,
14,
8019,
14,
29412,
... | 2.538462 | 195 |
import os
import configparser
from datetime import datetime
from pyspark.sql.types import *
from pyspark.sql import SparkSession
from pyspark.sql.functions import udf
def create_spark_session():
"""
Create spark session on AWS
"""
spark = SparkSession \
.builder \
.appName("MusicHub") \
.getOrCreate()
return spark
def process_song_data(spark, input_data, output_data):
"""
Description: This functions is to load the song logs from S3, then processes on EMR or EC2 then store back to S3 for further usage
Parameters:
spark : spark session
input_data : where the song json files located
output_data : where to store the output files after completing process input files
"""
# get filepath to song data file
song_data = input_data + "song_data/*/*/*/*.json"
# read song data file
songs_df = spark.read.json(song_data)
# Create temp view for querying
songs_df.createOrReplaceTempView("songs")
# extract columns to create songs table
songs_table = spark.sql("""
SELECT song_id,
title,
artist_id,
year,
duration
FROM songs
""")
# write songs table to parquet files partitioned by year and artist
songs_table.write.mode("overwrite").partitionBy("year", "artist_id").parquet(output_data + "songs")
# extract columns to create artists table
artists_table = spark.sql("""
SELECT DISTINCT artist_id,
artist_name name,
artist_location location,
artist_latitude latitude,
artist_longitude longitude
FROM songs
""")
# write artists table to parquet files
artists_table.write.mode("overwrite").parquet(output_data + "artists")
def process_log_data(spark, input_data, output_data):
"""
Description: This functions is to load the user logs from S3, then processes on EMR or EC2 then store back to S3 for further usage
Parameters:
spark : spark session
input_data : where the song json files located
output_data : where to store the output files after completing process input files
"""
# get filepath to log data file
log_data = input_data + "log_data/*/*/*.json"
# read log data file
logs_df = spark.read.json(log_data)
# filter by actions for song plays
logs_df = logs_df.filter(logs_df["page"] == "NextSong")
# Create temp view used for SQL query
logs_df.createOrReplaceTempView("logs")
# extract columns for users table
users_table = spark.sql("""
SELECT DISTINCT userId user_id,
firstName first_name,
lastName last_name,
gender,
level
FROM logs
WHERE TRIM(userId) <> ''
""")
# write users table to parquet files
users_table.write.mode("overwrite").parquet(output_data + "users")
# create timestamp column from original timestamp column
get_timestamp = udf(lambda x: datetime.fromtimestamp(x/1000), TimestampType())
logs_df = logs_df.withColumn("timestamp", get_timestamp(logs_df.ts))
# Create temp view for timestamp for query
logs_df.select("timestamp").createOrReplaceTempView("time")
# extract columns to create time table
time_table = spark.sql("""
SELECT DISTINCT timestamp start_time,
HOUR(timestamp) hour,
DAYOFMONTH(timestamp) day,
WEEKOFYEAR(timestamp) week,
MONTH(timestamp) month,
YEAR(timestamp) year,
DAYOFWEEK(timestamp) weekday
FROM time
""")
# write time table to parquet files partitioned by year and month
time_table.write.mode("overwrite").partitionBy("year", "month").parquet(output_data + "time")
# Create temp view used for SQL query, this call is updated with timestamp column
logs_df.createOrReplaceTempView("logs")
# Load songs table
songs_df = spark.read.parquet(output_data + "songs")
songs_df.createOrReplaceTempView("songs")
# Load artists table
artists_df = spark.read.parquet(output_data + "artists")
artists_df.createOrReplaceTempView("artists")
# extract columns from joined song and log datasets to create songplays table
songplays_table = spark.sql("""
SELECT monotonically_increasing_id() songplay_id,
l.timestamp start_time,
l.userId user_id,
s.song_id,
a.artist_id,
l.sessionId session_id,
l.location,
l.userAgent user_agent,
MONTH(l.timestamp) month,
YEAR(l.timestamp) year
FROM logs l
INNER JOIN songs s ON s.title = l.song AND s.duration = l.length
INNER JOIN artists a ON a.artist_id = s.artist_id AND a.name = l.artist
""")
# write songplays table to parquet files partitioned by year and month
songplays_table.write.mode("overwrite").partitionBy("year", "month").parquet(output_data + "songplays")
if __name__ == "__main__":
spark = create_spark_session()
input_data = "/mnt/d/git/learning_spark/data/"
output_data = "/mnt/d/git/learning_spark/data/output/"
process_song_data(spark, input_data, output_data)
process_log_data(spark, input_data, output_data)
| [
11748,
28686,
198,
11748,
4566,
48610,
198,
6738,
4818,
8079,
1330,
4818,
8079,
198,
6738,
279,
893,
20928,
13,
25410,
13,
19199,
1330,
1635,
198,
6738,
279,
893,
20928,
13,
25410,
1330,
17732,
36044,
198,
6738,
279,
893,
20928,
13,
254... | 2.178272 | 2,743 |
"""Constants for the Smartbroker integration."""
DOMAIN = "smartbroker"
| [
37811,
34184,
1187,
329,
262,
10880,
7957,
6122,
11812,
526,
15931,
198,
198,
39170,
29833,
796,
366,
27004,
7957,
6122,
1,
198
] | 3.318182 | 22 |
# democratic_bias = '''The Democratic Party's philosophy of modern liberalism advocates social and economic equality, along with the welfare state. It seeks to provide government regulation in the economy to promote the public interest. Environmental protection, support for organized labor, maintenance and expansion of social programs, affordable college tuition, universal health care, equal opportunity, and consumer protection form the core of the party's economic policy. On social issues, it advocates campaign finance reform, LGBT rights, criminal justice and immigration reform, stricter gun laws, and the legalization of marijuana.'''
democratic_bias = '''Raise Incomes and Restore Economic Security for the Middle Class
Raising Workers’ Wages
Protecting Workers’ Fundamental Rights
Supporting Working Families
Helping More Workers Share in Near-Record Corporate Profits
Expanding Access to Affordable Housing and Homeownership
Protecting and Expanding Social Security
Ensuring a Secure and Dignified Retirement
Revitalizing Our Nation’s Postal Service
Create Good-Paying Jobs
Building 21st Century Infrastructure
Fostering a Manufacturing Renaissance
Creating Good-Paying Clean Energy Jobs
Pursuing Our Innovation Agenda: Science, Research, Education, and Technology
Supporting America’s Small Businesses
Creating Jobs for America’s Young People
Fight for Economic Fairness and Against Inequality
Reining in Wall Street and Fixing our Financial System
Promoting Competition by Stopping Corporate Concentration
Making the Wealthy Pay Their Fair Share of Taxes
Promoting Trade That is Fair and Benefits American Workers
Bring Americans Together and Remove Barriers to Opportunities
Ending Systemic Racism
Closing the Racial Wealth Gap
Reforming our Criminal Justice System
Fixing our Broken Immigration System
Guaranteeing Civil Rights
Guaranteeing Women’s Rights
Guaranteeing Lesbian, Gay, Bisexual, and Transgender Rights
Guaranteeing Rights for People with Disabilities
Investing in Rural America
Ending Poverty and Investing in Communities Left Behind
Building Strong Cities and Metro Areas
Promoting Arts and Culture
Honoring Indigenous Tribal Nations
Fighting for the People of Puerto Rico
Honoring the People of the Territories
Protect Voting Rights, Fix Our Campaign Finance System, and Restore Our Democracy
Protecting Voting Rights
Fixing Our Broken Campaign Finance System
Securing Statehood for Washington, D.C.
Strengthening Management of Federal Government
Combat Climate Change, Build a Clean Energy Economy, and Secure Environmental Justice
Building a Clean Energy Economy
Securing Environmental and Climate Justice
Protecting Our Public Lands and Waters
Provide Quality and Affordable Education
Making Debt-Free College a Reality
Providing Relief from Crushing Student Debt
Supporting Historically Black Colleges and Universities and Minority-Serving Institutions
Cracking Down on Predatory For-Profit Schools
Guaranteeing Universal Preschool and Good Schools for Every Child
Ensure the Health and Safety of All Americans
Securing Universal Health Care
Supporting Community Health Centers
Reducing Prescription Drug Costs
Enabling Cutting-Edge Medical Research
Combating Drug and Alcohol Addiction
Treating Mental Health
Supporting Those Living with Autism and their Families
Securing Reproductive Health, Rights, and Justice
Ensuring Long-Term Care, Services, and Supports
Protecting and Promoting Public Health
Ending Violence Against Women
Preventing Gun Violence
Global Climate Leadership
Women and Girls
Lesbian, Gay, Bisexual, and Transgender People
Trafficking and Modern Slavery
Young People
Religious Minorities
Refugees
Civil Society
Anti-Corruption
Closing Guantánamo Bay
Global Health
HIV and AIDS
International Labor'''
republican_bias = '''The 21st-century Republican Party ideology is American conservatism, which incorporates both economic policies and social values. The GOP supports lower taxes, free market capitalism, restrictions on immigration, increased military spending, gun rights, restrictions on abortion, deregulation and restrictions on labor unions. After the Supreme Court's 1973 decision in Roe v. Wade, the Republican Party opposed abortion in its party platform and grew its support among evangelicals. The GOP was strongly committed to protectionism and tariffs at its founding but grew more supportive of free trade in the 20th century.''' | [
2,
10518,
62,
65,
4448,
796,
705,
7061,
464,
4390,
3615,
338,
8876,
286,
3660,
33108,
11009,
1919,
290,
3034,
10537,
11,
1863,
351,
262,
9490,
1181,
13,
632,
12932,
284,
2148,
1230,
9001,
287,
262,
3773,
284,
7719,
262,
1171,
1393,
... | 4.892222 | 900 |
import os
from flask import Flask, jsonify
from flask_sqlalchemy import SQLAlchemy
from flask_marshmallow import Marshmallow
# Init the app
app = Flask(__name__)
# Config the data base
app.config['SQLALCHEMY_DATABASE_URI'] = os.getenv('DB_URI', 'sqlite://')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
app.config['JSON_SORT_KEYS'] = False
db = SQLAlchemy(app)
ma = Marshmallow(app)
if __name__ == '__main__':
port = os.getenv('PORT', 58913)
# Registering the routes
from routes import *
app.register_blueprint(app_person)
app.register_blueprint(app_yiff)
app.register_blueprint(app_main)
app.run(host='0.0.0.0', port=port, debug=True)
| [
11748,
28686,
198,
6738,
42903,
1330,
46947,
11,
33918,
1958,
198,
6738,
42903,
62,
25410,
282,
26599,
1330,
16363,
2348,
26599,
198,
6738,
42903,
62,
76,
5406,
42725,
1330,
9786,
42725,
628,
198,
2,
44707,
262,
598,
198,
1324,
796,
469... | 2.638132 | 257 |
# Licensed under a 3-clause BSD style license - see LICENSE.rst
import numpy as np
try:
from Ska.Matplotlib import plot_cxctime
except ImportError:
pass
from .base import ModelComponent
from .heat import PrecomputedHeatPower
from . import tmal
class AcisDpaPower6(PrecomputedHeatPower):
"""Heating from ACIS electronics (ACIS config dependent CCDs, FEPs etc)"""
@property
class AcisDpaPowerClipped(PrecomputedHeatPower):
"""Heating from ACIS electronics (ACIS config dependent CCDs, FEPs etc)"""
@property
class SolarHeatSimZ(SolarHeat):
"""Solar heating (pitch and SimZ dependent)"""
@property
| [
2,
49962,
739,
257,
513,
12,
565,
682,
347,
10305,
3918,
5964,
532,
766,
38559,
24290,
13,
81,
301,
198,
11748,
299,
32152,
355,
45941,
198,
198,
28311,
25,
198,
220,
220,
220,
422,
3661,
64,
13,
19044,
29487,
8019,
1330,
7110,
62,
... | 3.009434 | 212 |
from cProfile import label
import numpy as np
import matplotlib.pyplot as plt
if __name__ == '__main__':
# nsf_report()
nsf_grouping_comp()
nsf_selection_comp()
nsf_p_comp()
nsf_gs_comp()
# nsf_gs_cost_comp() | [
198,
6738,
269,
37046,
1330,
6167,
198,
11748,
299,
32152,
355,
45941,
198,
11748,
2603,
29487,
8019,
13,
9078,
29487,
355,
458,
83,
628,
628,
198,
361,
11593,
3672,
834,
6624,
705,
834,
12417,
834,
10354,
198,
220,
220,
220,
1303,
29... | 2.257143 | 105 |
# Generated by Django 2.2.13 on 2020-07-06 10:29
import django.contrib.postgres.fields.jsonb
from django.db import migrations, models
| [
2,
2980,
515,
416,
37770,
362,
13,
17,
13,
1485,
319,
12131,
12,
2998,
12,
3312,
838,
25,
1959,
198,
198,
11748,
42625,
14208,
13,
3642,
822,
13,
7353,
34239,
13,
25747,
13,
17752,
65,
198,
6738,
42625,
14208,
13,
9945,
1330,
15720,... | 2.893617 | 47 |
# Generated by Django 3.1.14 on 2022-01-15 18:42
from django.db import migrations, models
import django.db.models.deletion
| [
2,
2980,
515,
416,
37770,
513,
13,
16,
13,
1415,
319,
33160,
12,
486,
12,
1314,
1248,
25,
3682,
198,
198,
6738,
42625,
14208,
13,
9945,
1330,
15720,
602,
11,
4981,
198,
11748,
42625,
14208,
13,
9945,
13,
27530,
13,
2934,
1616,
295,
... | 2.840909 | 44 |
# 784. Letter Case Permutation
# Runtime: 91 ms, faster than 19.56% of Python3 online submissions for Letter Case Permutation.
# Memory Usage: 15.6 MB, less than 16.05% of Python3 online submissions for Letter Case Permutation.
# Iteration | [
2,
767,
5705,
13,
18121,
8913,
2448,
76,
7094,
198,
198,
2,
43160,
25,
10495,
13845,
11,
5443,
621,
678,
13,
3980,
4,
286,
11361,
18,
2691,
22129,
329,
18121,
8913,
2448,
76,
7094,
13,
198,
198,
2,
14059,
29566,
25,
1315,
13,
21,
... | 3.464789 | 71 |
# Generated by Django 3.1.4 on 2021-08-04 21:40
from django.db import migrations, models
import django.utils.timezone
| [
2,
2980,
515,
416,
37770,
513,
13,
16,
13,
19,
319,
33448,
12,
2919,
12,
3023,
2310,
25,
1821,
198,
198,
6738,
42625,
14208,
13,
9945,
1330,
15720,
602,
11,
4981,
198,
11748,
42625,
14208,
13,
26791,
13,
2435,
11340,
628
] | 2.926829 | 41 |
# This files contains your custom actions which can be used to run
# custom Python code.
#
# See this guide on how to implement these action:
# https://rasa.com/docs/rasa/core/actions/#custom-actions/
# This is a simple example for a custom action which utters "Hello World!"
from typing import Any, Text, Dict, List
from rasa_sdk import Action, Tracker
from rasa_sdk.executor import CollectingDispatcher
from rasa_sdk.forms import FormAction
import re
from typing import Any, Text, Dict, List, Optional
#
#
# class ActionHelloWorld(Action):
#
# def name(self) -> Text:
# return "action_hello_world"
#
# def run(self, dispatcher: CollectingDispatcher,
# tracker: Tracker,
# domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
#
# dispatcher.utter_message("Hello World!")
#
# return []
class ExperienceForm(FormAction):
"""Form action to capture user experience"""
def name(self):
# type: () -> Text
"""Unique identifier of the form"""
return "experience_form"
@staticmethod
def required_slots(tracker):
# type: () -> List[Text]
"""A list of required slots that the form has to fill
this form collect the feedback of the user experience"""
return ["feedback"]
def submit(self, dispatcher, tracker, domain):
# type: (CollectingDispatcher, Tracker, Dict[Text, Any]) -> List[Dict]
"""Define what the form has to do
after all required slots are filled.
Generates sentiment analysis
using the user's feedback"""
return []
def slot_mappings(self):
# type: () -> Dict[Text: Union[Dict, List[Dict]]]
"""A dictionary to map required slots to
- an extracted entity
- intent: value pairs
- a whole message
or a list of them, where a first match will be picked"""
return {"feedback": [self.from_text()]}
class ContactForm(FormAction):
"""Form action to capture contact details"""
def name(self):
# type: () -> Text
"""Unique identifier of the form"""
return "contact_form"
@staticmethod
def required_slots(tracker):
# type: () -> List[Text]
"""A list of required slots that the form has to fill"""
return ["name", "email", "tel"]
def submit(self, dispatcher, tracker, domain):
# type: (CollectingDispatcher, Tracker, Dict[Text, Any]) -> List[Dict]
"""Define what the form has to do
after all required slots are filled"""
dispatcher.utter_template('utter_submit', tracker)
return []
def slot_mappings(self):
# type: () -> Dict[Text: Union[Dict, List[Dict]]]
"""A dictionary to map required slots to
- an extracted entity
- intent: value pairs
- a whole message
or a list of them, where a first match will be picked"""
return {"name": [self.from_entity(entity="PERSON",
intent="self_intro"),
self.from_text()],
"email": [self.from_entity(entity="email"),
self.from_text()],
"tel": [self.from_entity(entity="tel"),
self.from_text()]}
@staticmethod
def is_email(string: Text) -> bool:
"""Check if a string is valid email"""
pattern = re.compile("[\w-]+@([\w-]+\.)+[\w-]+")
return pattern.match(string)
@staticmethod
def is_tel(string: Text) -> bool:
"""Check if a string is valid email"""
pattern_uk = re.compile("(0)([0-9][\s]*){10}")
pattern_world = re.compile("^(00|\+)[\s]*[1-9]{1}([0-9][\s]*){9,16}$")
return pattern_uk.match(string) or pattern_world.match(string)
| [
2,
770,
3696,
4909,
534,
2183,
4028,
543,
460,
307,
973,
284,
1057,
198,
2,
2183,
11361,
2438,
13,
198,
2,
198,
2,
4091,
428,
5698,
319,
703,
284,
3494,
777,
2223,
25,
198,
2,
3740,
1378,
8847,
64,
13,
785,
14,
31628,
14,
8847,
... | 2.374923 | 1,627 |
import os
from d3m import utils
try:
import d3m.__init__ as d3m_info
D3M_API_VERSION = d3m_info.__version__
except Exception:
D3M_API_VERSION = '2019.1.9'
VERSION = "0.2.0"
TAG_NAME = "{git_commit}".format(git_commit=utils.current_git_commit(os.path.dirname(__file__)), )
REPOSITORY = "https://github.com/plai-group/ubc_primitives.git"
PACAKGE_NAME = "ubc_primitives"
D3M_PERFORMER_TEAM = 'UBC'
D3M_CONTACT = "mailto:tonyjos@ubc.cs.ca"
if TAG_NAME:
PACKAGE_URI = "git+" + REPOSITORY + "@" + TAG_NAME
else:
PACKAGE_URI = "git+" + REPOSITORY
PACKAGE_URI = PACKAGE_URI + "#egg=" + PACAKGE_NAME
INSTALLATION_TYPE = 'GIT'
if INSTALLATION_TYPE == 'PYPI':
INSTALLATION = {
"type" : "PIP",
"package": PACAKGE_NAME,
"version": VERSION
}
else:
# INSTALLATION_TYPE == 'GIT'
INSTALLATION = {
"type" : "PIP",
"package_uri": PACKAGE_URI,
}
| [
11748,
28686,
198,
6738,
288,
18,
76,
1330,
3384,
4487,
198,
198,
28311,
25,
198,
220,
220,
220,
1330,
288,
18,
76,
13,
834,
15003,
834,
355,
288,
18,
76,
62,
10951,
198,
220,
220,
220,
360,
18,
44,
62,
17614,
62,
43717,
796,
28... | 2.110855 | 433 |
# MIT License
#
# Copyright (c) 2018-2019 Red Hat, Inc.
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import logging
import click
from pkg_resources import get_distribution
from packit.cli.build import build
from packit.cli.copr_build import copr_build
from packit.cli.create_update import create_update
from packit.cli.generate import generate
from packit.cli.push_updates import push_updates
from packit.cli.srpm import srpm
from packit.cli.status import status
from packit.cli.sync_from_downstream import sync_from_downstream
from packit.cli.update import update
from packit.config import Config, get_context_settings
from packit.utils import set_logging
logger = logging.getLogger("packit")
@click.group("packit", context_settings=get_context_settings())
@click.option("-d", "--debug", is_flag=True, help="Enable debug logs.")
@click.option("--fas-user", help="Fedora Account System username.")
@click.option("-k", "--keytab", help="Path to FAS keytab file.")
@click.option(
"--dry-run",
is_flag=True,
help="Do not perform any remote changes (pull requests or comments).",
)
@click.version_option(
version=get_distribution("packitos").version, message="%(version)s"
)
@click.pass_context
def packit_base(ctx, debug, fas_user, keytab, dry_run):
"""Integrate upstream open source projects into Fedora operating system."""
if debug:
# to be able to logger.debug() also in get_user_config()
set_logging(level=logging.DEBUG)
c = Config.get_user_config()
c.debug = debug or c.debug
c.dry_run = dry_run or c.dry_run
c.fas_user = fas_user or c.fas_user
c.keytab_path = keytab or c.keytab_path
ctx.obj = c
if ctx.obj.debug:
set_logging(level=logging.DEBUG)
set_logging(logger_name="sandcastle", level=logging.DEBUG)
else:
set_logging(level=logging.INFO)
packit_version = get_distribution("packitos").version
logger.info(f"Packit {packit_version} is being used.")
packit_base.add_command(update)
packit_base.add_command(sync_from_downstream)
packit_base.add_command(build)
packit_base.add_command(copr_build)
packit_base.add_command(create_update)
packit_base.add_command(push_updates)
packit_base.add_command(srpm)
packit_base.add_command(status)
packit_base.add_command(generate)
if __name__ == "__main__":
packit_base()
| [
2,
17168,
13789,
198,
2,
198,
2,
15069,
357,
66,
8,
2864,
12,
23344,
2297,
10983,
11,
3457,
13,
198,
198,
2,
2448,
3411,
318,
29376,
7520,
11,
1479,
286,
3877,
11,
284,
597,
1048,
16727,
257,
4866,
198,
2,
286,
428,
3788,
290,
3... | 3.018034 | 1,109 |
#!/usr/bin/env python
from math import pi
from typing import Union
import glm
from glm import dot, cross, vec3, vec2, normalize, rotate, identity, quat
from pygame import Vector3
from game.base.entity import Entity
from game.constants import EPSILON, SCREEN_DIST
class Camera(Entity):
"""
A camera whose position is the center of the screen.
All the coordinates are in pixels.
"""
@property
def update_pos(self, player):
"""Set the camera position to have the player in center"""
self.position = player.position
def distance(self, world_pos):
"""Distance from the camera along the `direction` axis"""
return dot(world_pos - self.position, self.direction)
def world_to_screen(self, world_pos: vec3) -> Union[vec2, None]:
"""
Convert a world 3D position to a screen 2D position.
Returns None if the position is not in the screen
"""
rel = world_pos - self.position
# distance along the screen's z axis
dist = dot(rel, self.direction)
if dist < 10:
return None
absolute_y = dot(rel, self.up)
absolute_x = dot(rel, self.horizontal)
screen_size = vec2(self.screen_size)
pos = (
vec2(
absolute_x / dist * self.screen_dist,
absolute_y / dist * self.screen_dist,
)
+ screen_size / 2
)
pos.y = self.screen_size.y - pos.y
return pos
def rel_to_world(self, rel):
"""
Convert a vector relative to the camera to the world system.
x axis is increase to the right of the screen
y to the top
z increases towards the gamer.
Therefore (0, 0, -100) is 100 pixels in front of the camera
and (10, 10, 100) is 10 pixels up and right from the previous
"""
return (
self.position
+ rel.x * self.horizontal
+ rel.y * self.up
- rel.z * self.direction
)
def rotate_around_direction(self, angle):
"""
Rotates the camera around the center of the screen, changing
which way is up
:param angle: (counterclockwise) rotation in radians
"""
self.up = self._rotate(self.up, angle, self.direction)
def rotate_around_horizontal(self, angle):
"""
Rotates the camera around the horizontal axis, also
know as tilt.
:param angle: (counterclockwise) rotation in radians
"""
horiz = self.horizontal
self.up = self._rotate(self.up, angle, horiz)
self.direction = self._rotate(self.direction, angle, horiz)
def rotate_around_up(self, angle):
"""
Rotates the camera around the center of the screen,
also known as turn left/right
:param angle: (counterclockwise) rotation in radians
"""
self.direction = self._rotate(self.direction, angle, self.up)
@staticmethod
def _rotate(vec, angle, axis):
"""Rotate vec around axis by the given angle in radians."""
# We are using the Pygame's vectors here
# because pyglm documentation is SHIT and
# I can't find a way do do the same SIMPLE thing.
vec = Vector3(vec)
axis = Vector3(axis)
vec.rotate_ip(angle * 180 / pi, axis)
return vec3(*vec)
| [
2,
48443,
14629,
14,
8800,
14,
24330,
21015,
198,
6738,
10688,
1330,
31028,
198,
6738,
19720,
1330,
4479,
198,
198,
11748,
1278,
76,
198,
6738,
1278,
76,
1330,
16605,
11,
3272,
11,
43030,
18,
11,
43030,
17,
11,
3487,
1096,
11,
23064,
... | 2.421165 | 1,408 |
#!/usr/bin/python
import sys
import json
from ansible.module_utils import ntap_util
try:
from NaServer import *
NASERVER_AVAILABLE = True
except ImportError:
NASERVER_AVAILABLE = False
if not NASERVER_AVAILABLE:
module.fail_json(msg="The NetApp Manageability SDK library is not installed")
DOCUMENTATTION = '''
---
module: dns_create
version_added: "1.0"
author: "Jeorry Balasabas (@jeorryb)"
short_description: Set date, time and timezone for NetApp cDOT array.
description:
- Ansible module to create dns server entries for a NetApp CDOT array via the NetApp python SDK.
requirements:
- NetApp Manageability SDK
options:
cluster:
required: True
description:
- "The ip address or hostname of the cluster"
user_name:
required: True
description:
- "Administrator user for the cluster/node"
password:
required: True
description:
- "password for the admin user"
vserver:
required: True
description:
- "vserver that DNS entries are being created on"
domains:
required: True
description:
- "Comma separated list of domains (FQDN) that the servers are responsible for"
dns_servers:
required: True
description:
- "Comma separated list of dns servers"
'''
EXAMPLES = '''
# Create DNS servers for cluster vserver
- name: Create dns servers
dns_create:
cluster: "192.168.0.1"
user_name: "admin"
password: "Password1"
vserver: "atlcdot"
domains: "netapp.com"
dns_servers: "8.8.8.8, 4.2.2.2"
'''
from ansible.module_utils.basic import *
main()
| [
2,
48443,
14629,
14,
8800,
14,
29412,
198,
198,
11748,
25064,
198,
11748,
33918,
198,
6738,
220,
9093,
856,
13,
21412,
62,
26791,
1330,
299,
44335,
62,
22602,
198,
198,
28311,
25,
198,
220,
220,
220,
422,
11013,
10697,
1330,
1635,
198... | 2.672241 | 598 |
# Enter your code here. Read input from STDIN. Print output to STDOUT
from collections import Counter
if __name__ == '__main__':
X = int( input() )
shoe_size_in_warehouse = list( map(int, input().split() ) )
size_dict = Counter(shoe_size_in_warehouse)
N = int( input() )
total_revenue = 0
for _ in range(N):
buf = list( map(int, input().split() ) )
total_revenue += look_up_and_cashier( size_dict, size = buf[0], price = buf[1] )
print( total_revenue ) | [
2,
6062,
534,
2438,
994,
13,
4149,
5128,
422,
48571,
1268,
13,
12578,
5072,
284,
48571,
12425,
198,
6738,
17268,
1330,
15034,
628,
198,
198,
361,
11593,
3672,
834,
6624,
705,
834,
12417,
834,
10354,
628,
220,
220,
220,
1395,
796,
493,... | 2.586735 | 196 |
x_y=('planet' , 'range')
'''planet''', '''range'''
print ('(A) corporations spc by Ayush')
print ('Collecting Data.....')
print ('press enter...')
x = input()
print ('process completed')
print ('Type the name of the planet')
y = input()
if y == ('earth'):
print ('!')
if y == ('mars'):
print ('!')
| [
87,
62,
88,
28,
10786,
47427,
6,
837,
705,
9521,
11537,
201,
198,
7061,
6,
47427,
7061,
3256,
705,
7061,
9521,
7061,
6,
201,
198,
4798,
19203,
7,
32,
8,
10225,
599,
66,
416,
13709,
1530,
11537,
201,
198,
4798,
19203,
31337,
278,
6... | 2.451852 | 135 |
# Authors: Pierre Ablin <pierre.ablin@inria.fr>
#
# License: MIT
import numpy as np
import numba as nb
from numba import njit
from ._utils import cg
from ._densities import Huber, Sigmoid
def solver_incremental(X, max_iter=100, batch_size=100, W_init=None,
density='huber', maxiter_cg=10, greedy=0):
"""
Incremental algorithm for ICA
Parameters
----------
X : array_like, shape (p, n)
The input data to be unmixed.
max_iter : int, optional
Maximum number of iterations
batch_size : int, optional
Mini-batch size
W_init : array_like, shape (p, p), optional
Initial guess for the unmixing matrix.
Defaults to identity
density : 'huber' or 'tanh', optional
The density to use
maxiter_cg : int, optional
The number of iterations of conjuagate gradient to perform
greedy : int, optional
The number of sources to update for each sample, chosen greedily.
If 0, each source is updated.
Returns
-------
W : array_like, shape (p, p)
The estimated unmixing matrix
"""
density = {'huber': Huber(),
'tanh': Sigmoid()}.get(density)
if density is None:
raise ValueError('Density should either be tanh or huber')
N, T = X.shape
if W_init is None:
W = np.eye(N)
else:
W = W_init.copy()
U = np.ones_like(X, dtype=float)
Y = np.zeros_like(X, dtype=float)
C = X.dot(X.T) / T
A = np.stack([C, ] * N)
n_batch = T // batch_size
for n in range(max_iter):
idx_int = n % n_batch
idx = slice(idx_int * batch_size, (idx_int + 1) * batch_size)
x = X[:, idx]
u_old = U[:, idx]
y = np.dot(W, x)
if greedy:
y_old = Y[:, idx]
u_new = density.ustar(y)
if greedy:
gaps = duality_gap(y, y_old, u_old, density)
update_idx = np.argpartition(gaps, -greedy, axis=0)[-greedy:, :]
A += compute_A_idx((u_new - u_old) * batch_size / T, x, update_idx)
replace(U, u_new, update_idx, idx_int * batch_size)
replace(Y, y, update_idx, idx_int * batch_size)
else:
A += compute_A((u_new - u_old) * batch_size / T, x)
U[:, idx] = u_new
W = min_W(W, A, maxiter_cg)
return W
def solver_online(sample_generator, p, W_init=None, density='huber',
maxiter_cg=10, greedy=0, alpha=0.7):
"""
Online algorithm for ICA
Parameters
----------
sample_generator: generator
The sample stream generator. The x in `for x in sample_generator:`
should be a minibatch of size (p, batch_size)
p : int
Number of sources
W_init : array_like, shape (p, p), optional
Initial guess for the unmixing matrix.
Defaults to identity
density : 'huber' or 'tanh', optional
The density to use
maxiter_cg : int, optional
The number of iterations of conjugate gradient to perform
greedy : int, optional
The number of sources to update for each sample, chosen randomly.
If 0, each source is updated.
Returns
-------
W : array_like, shape (p, p)
The estimated unmixing matrix
"""
density = {'huber': Huber(),
'tanh': Sigmoid()}.get(density)
if density is None:
raise ValueError('Density should either be tanh or huber')
if W_init is None:
W = np.eye(p)
else:
W = W_init.copy()
A = np.zeros((p, p, p))
for n, x in enumerate(sample_generator):
_, batch_size = x.shape
y = np.dot(W, x)
u = density.ustar(y)
step = 1. / (n + 1) ** alpha
A *= (1 - step)
if greedy:
u *= step * p / greedy
update_idx = gen_idx(p, greedy, batch_size)
A += compute_A_idx(u, x, update_idx)
else:
u *= step
A += compute_A(u, x)
W = min_W(W, A, maxiter_cg)
return W
@njit(fastmath=True, parallel=True)
@njit(fastmath=True, parallel=True)
@njit(nb.float64[:, :, :](nb.float64[:, :], nb.float64[:, :], nb.int64[:, :]),
fastmath=True, cache=True)
def compute_A_idx(U, X, update_idx):
"""
Params:
U : N x T array
X : N x T array
update_idx : n_greedy x T array
Output:
A : N x N x N array
"""
N, T = X.shape
A = np.zeros((N, N, N))
for t in range(T):
x = X[:, t]
u = U[:, t]
idx = update_idx[:, t]
for i in idx:
ui = u[i]
Ai = A[i]
for j in range(N):
xj = x[j]
for k in range(j + 1):
tmp = ui * xj * x[k]
Ai[j, k] += tmp
for i in range(N):
for j in range(N):
for k in range(j):
A[i, k, j] = A[i, j, k]
return A / T
| [
2,
46665,
25,
21204,
2275,
2815,
1279,
79,
31058,
13,
397,
2815,
31,
259,
7496,
13,
8310,
29,
198,
2,
198,
2,
13789,
25,
17168,
198,
11748,
299,
32152,
355,
45941,
198,
11748,
997,
7012,
355,
299,
65,
198,
6738,
997,
7012,
1330,
2... | 2.026403 | 2,424 |
"""
distribution.py
Author: kyDoleuc04
Credit: tutorials, andrew, matt, chris lee, google
Assignment:
Write and submit a Python program (distribution.py) that computes and displays
the distribution of characters in a given sample of text.
Output of your program should look like this:
Please enter a string of text (the bigger the better): The rain in Spain stays mainly in the plain.
The distribution of characters in "The rain in Spain stays mainly in the plain." is:
iiiiii
nnnnnn
aaaaa
sss
ttt
ee
hh
ll
pp
yy
m
r
Notice about this example:
* The text: 'The rain ... plain' is provided by the user as input to your program.
* Uppercase characters are converted to lowercase
* Spaces and punctuation marks are ignored completely.
* Characters that are more common appear first in the list.
* Where the same number of characters occur, the lines are ordered alphabetically.
For example, in the printout above, the letters e, h, l, p and y both occur twice
in the text and they are listed in the output in alphabetical order.
* Letters that do not occur in the text are not listed in the output at all.
"""
import string
alphabet = ("a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z")
str = input("Please enter a string of text (the bigger the better): ")
print('The distribution of characters in "'+str+'" is: ')
str = str.lower()
letters = []
for a in alphabet:
b = str.count(a)
if not b == 0:
letters.append(a*b)
for c in range(26):
d=0
while d < len(letters)-1:
if len(letters[d]) < len(letters[d+1]):
e = (letters[d])
letters[d] = letters[d+1]
letters[d+1] = e
d+=1
for z in letters:
print(z)
| [
37811,
198,
17080,
3890,
13,
9078,
198,
13838,
25,
479,
88,
35,
2305,
1229,
3023,
198,
23690,
25,
27992,
11,
290,
1809,
11,
23963,
11,
442,
2442,
443,
68,
11,
23645,
198,
198,
8021,
16747,
25,
198,
198,
16594,
290,
9199,
257,
11361,... | 2.915423 | 603 |
from datetime import datetime, timedelta
from collections import defaultdict
import itertools
import pickle
import time
import logging
logger = logging.getLogger("disempower.interval")
CREDITS = defaultdict(int) # per-user bank
INTERVALS = defaultdict(list) # per-user allowable times
BLACKOUTS = defaultdict(list) # per-user forbidden times
CAPS = dict() # per-user max credits
DAILY_BANK = defaultdict(int) # add every day at 00:00
WEEKLY_BANK = defaultdict(int) # add every week at 00:00 on Monday
# last tick time per user; -1 if user is inactive
ACTIVE = defaultdict(int)
LAST_TICK = -1
LAST_TOPOFF = 17990
WEEK = 10080
DAY = 1440
HR = 60
# Daylght savings, from Python TZ example code
DSTSTART = datetime(1, 4, 1, 2)
DSTEND = datetime(1, 10, 25, 1)
# these could be configured for other time zones
OFFSET_DST = -420
OFFSET_ST = -480
def to_minutes(day, hour, minute):
'''week-day, hour, minute to minuts. days are 0-6'''
minute_overage = minute // 60
hour += minute_overage
minute %= 60
hour_overage = hour // 24
day += hour_overage
hour %= 24
day %= 7
return (day * DAY) + (hour * HR) + minute
def from_minutes(mins):
"""
converts a minute value into a day-hour-minute tuple
"""
day = mins // 1440
remainder = mins - (day * 1440)
hour = remainder // 60
minute = remainder - (hour * 60)
return day, hour, minute
def check(user):
"""
returns positive # of minutes remaining,
0 if not in an active interval,
"""
now_minute = tick(user)
remaining = 0
for i_start, i_end in get_intervals(user):
if i_start <= now_minute <= i_end:
remaining = max(remaining, i_end - now_minute)
user_total = CREDITS.get(user, 0)
# FIX: as written this will return a false
# countdown to midnight on Sunday if there
# is a wraparound interval to Monday morning...
return min(remaining, user_total)
if __name__ == '__main__':
# testing time shift
now = datetime.utcnow()
pacific_time_offset = get_time_offset(now)
now_minute = to_minutes(now.weekday() % 7, now.hour, now.minute)
print ("UTC", now)
print ("raw", now_minute)
print ("offset", pacific_time_offset)
now_minute += pacific_time_offset
now_minute %= WEEK
print ("pst", now_minute)
now = datetime.now()
confirm = to_minutes(now.weekday() % 7, now.hour, now.minute)
print ("confirm", confirm)
CAPS['nicky'] = 120
CREDITS['nicky'] = 0
ACTIVE['nicky'] = -1
DAILY_BANK['nicky'] = 10
WEEKLY_BANK['nicky'] = 5
DAILY_BANK['helen'] = 7
add_interval('nicky', (6, 23, 0), (0, 8, 0))
add_interval('nicky', (0, 9, 30), (0, 13, 30))
add_blackout('nicky', (0, 7, 0), (0, 9, 45))
add_blackout('nicky', (0, 11, 0), (0, 12, 00))
add_blackout('nicky', (0, 13, 15), (0, 20, 20))
print (INTERVALS['nicky'])
print (BLACKOUTS['nicky'])
print (get_intervals('nicky'))
print (get_ui_intervals('nicky'))
# save("test_db")
| [
6738,
4818,
8079,
1330,
4818,
8079,
11,
28805,
12514,
201,
198,
6738,
17268,
1330,
4277,
11600,
201,
198,
11748,
340,
861,
10141,
201,
198,
11748,
2298,
293,
201,
198,
11748,
640,
201,
198,
201,
198,
11748,
18931,
201,
198,
6404,
1362,
... | 2.274455 | 1,421 |
from __future__ import division
import scipy.optimize
import numpy as np
import cv2
# -----------------------------------------------------------------------------------------
def parse_wider_gt(dets_file_name, isEllipse=False):
# -----------------------------------------------------------------------------------------
'''
Parse the FDDB-format detection output file:
- first line is image file name
- second line is an integer, for `n` detections in that image
- next `n` lines are detection coordinates
- again, next line is image file name
- detections are [x y width height score]
Returns a dict: {'img_filename': detections as a list of arrays}
'''
fid = open(dets_file_name, 'r')
# Parsing the FDDB-format detection output txt file
img_flag = True
numdet_flag = False
start_det_count = False
det_count = 0
numdet = -1
det_dict = {}
img_file = ''
for line in fid:
line = line.strip()
if img_flag:
# Image filename
img_flag = False
numdet_flag = True
# print 'Img file: ' + line
img_file = line
det_dict[img_file] = [] # init detections list for image
continue
if numdet_flag:
# next line after image filename: number of detections
numdet = int(line)
numdet_flag = False
if numdet > 0:
start_det_count = True # start counting detections
det_count = 0
else:
# no detections in this image
img_flag = True # next line is another image file
numdet = -1
# print 'num det: ' + line
continue
if start_det_count:
# after numdet, lines are detections
detection = [float(x) for x in line.split()] # split on whitespace
det_dict[img_file].append(detection)
# print 'Detection: %s' % line
det_count += 1
if det_count == numdet:
start_det_count = False
det_count = 0
img_flag = True # next line is image file
numdet_flag = False
numdet = -1
return det_dict
# -----------------------------------------------------------------------------------------
def crop_im_bbox(im_file, bbox, dilation_factor=0.0):
# -----------------------------------------------------------------------------------------
'''
Crop a bounding-box region out of an image.
im_file: full path to image file
bbox format: [xmin ymin xmax ymax]
'''
im = cv2.imread(im_file)
im = im[:, :, (2, 1, 0)]
bbox_w = bbox[2]-bbox[0]
bbox_h = bbox[3]-bbox[1]
shift_x = bbox_w * dilation_factor
shift_y = bbox_h * dilation_factor
bbox_dilated = np.array([bbox[0] - shift_x, bbox[1] - shift_y,
bbox[2] + shift_x, bbox[3] + shift_y])
(x1,y1,x2,y2) = [ int(np.rint(x)) for x in bbox_dilated]
# TODO - handle margin overflows
return im[ y1:y2, x1:x2, : ]
# -----------------------------------------------------------------------------------------
# -----------------------------------------------------------------------------------------
# -----------------------------------------------------------------------------------------
def match_bboxes(bbox_gt, bbox_pred, IOU_THRESH=0.5):
# -----------------------------------------------------------------------------------------
'''
Given sets of true and predicted bounding-boxes
determine the best possible match.
Parameters
----------
bbox_gt, bbox_pred : N1x4 and N2x4 np array of bboxes [x1,y1,x2,y2].
The number of bboxes, N1 and N2, need not be the same.
Returns
-------
(idxs_true, idxs_pred, ious, label)
idxs_true, idxs_pred : indices into gt and pred for matches
ious : corresponding IOU value of each match
'''
n_true = bbox_gt.shape[0]
n_pred = bbox_pred.shape[0]
MAX_DIST = 1.0
MIN_IOU = 0.0
# NUM_GT x NUM_PRED
iou_matrix = np.zeros((n_true, n_pred))
for i in range(n_true):
for j in range(n_pred):
iou_matrix[i, j] = bbox_iou(bbox_gt[i,:], bbox_pred[j,:])
if n_pred > n_true:
# there are more predictions than ground-truth - add dummy rows
diff = n_pred - n_true
iou_matrix = np.concatenate( (iou_matrix,
np.full((diff, n_pred), MIN_IOU)),
axis=0)
if n_true > n_pred:
# more ground-truth than predictions - add dummy columns
diff = n_true - n_pred
iou_matrix = np.concatenate( (iou_matrix,
np.full((n_true, diff), MIN_IOU)),
axis=1)
# call the Hungarian matching
idxs_true, idxs_pred = scipy.optimize.linear_sum_assignment(1 - iou_matrix)
if (not idxs_true.size) or (not idxs_pred.size):
ious = np.array([])
else:
ious = iou_matrix[idxs_true, idxs_pred]
# remove dummy assignments
sel_pred = idxs_pred < n_pred
idx_pred_actual = idxs_pred[sel_pred]
idx_gt_actual = idxs_true[sel_pred]
ious_actual = iou_matrix[idx_gt_actual, idx_pred_actual]
sel_valid = (ious_actual > IOU_THRESH)
label = sel_valid.astype(int)
return idx_gt_actual[sel_valid], idx_pred_actual[sel_valid], ious_actual[sel_valid], label
# -----------------------------------------------------------------------------------------
def get_ellipse_rect(x, y, major, minor, angle_deg):
# -----------------------------------------------------------------------------------------
'''
Compute axis-aligned rectangle from FDDB ellipse annotation.
'''
x_values = [x + major * np.cos(t) * np.cos(np.radians(angle_deg)) -
minor * np.sin(t) * np.sin(np.radians(angle_deg)) \
for t in np.linspace(-np.pi, np.pi, 500)]
y_values = [y + minor * np.sin(t) * np.cos(np.radians(angle_deg)) +
major * np.cos(t) * np.sin(np.radians(angle_deg)) \
for t in np.linspace(-np.pi, np.pi, 500)]
return [np.min(x_values), np.min(y_values),
np.max(x_values), np.max(y_values)]
# -----------------------------------------------------------------------------------------
color_dict = {'red': (0,0,225), 'green': (0,255,0), 'yellow': (0,255,255), 'blue': (255,0,0),
'_GREEN':(18, 127, 15), '_GRAY': (218, 227, 218)}
# -----------------------------------------------------------------------------------------
def vis_bbox(img, bbox, thick=2, color='green'):
# -----------------------------------------------------------------------------------------
"""Visualizes a bounding box."""
(x0, y0, x1, y1) = (int(bbox[0]), int(bbox[1]), int(bbox[2]), int(bbox[3]))
cv2.rectangle(img, (x0, y0), (x1, y1), color_dict[color],
thickness=thick)
return img
# -----------------------------------------------------------------------------------------
# -----------------------------------------------------------------------------------------
| [
198,
6738,
11593,
37443,
834,
1330,
7297,
198,
11748,
629,
541,
88,
13,
40085,
1096,
198,
11748,
299,
32152,
355,
45941,
198,
11748,
269,
85,
17,
628,
198,
2,
16529,
22369,
12,
198,
4299,
21136,
62,
86,
1304,
62,
13655,
7,
67,
1039,... | 2.659417 | 2,575 |
from torch.optim.optimizer import Optimizer, required
import numpy as np
import torch
class SGLD(Optimizer):
"""
Barely modified version of pytorch SGD to implement SGLD
"""
def step(self):
"""
Performs a single optimization step.
"""
loss = None
for group in self.param_groups:
weight_decay = group['weight_decay']
for p in group['params']:
if p.grad is None:
continue
d_p = p.grad.data
if weight_decay != 0:
d_p = d_p.add(weight_decay, p.data)
if group['addnoise']:
size = d_p.size()
if group['noise_type'] == 'normal':
langevin_noise = p.data.new(p.data.size()).normal_(mean=0, std=group['noise_std']) / np.sqrt(group['lr'])
elif group['noise_type'] == 'laplace':
langevin_noise = torch.distributions.laplace.Laplace(0, group['noise_std'])
langevin_noise = langevin_noise.sample(p.data.size()).cuda() / np.sqrt(group['lr'])
else:
raise ValueError
p.data.add_(-group['lr'], d_p + langevin_noise)
else:
p.data.add_(-group['lr'], d_p)
return loss
'''
class SGLD(Optimizer):
"""
SGLD optimiser based on pytorch's SGD.
Note that the weight decay is specified in terms of the gaussian prior sigma.
"""
def __init__(self, params, lr=required, norm_sigma=0, noise_std=1.0, addnoise=True):
weight_decay = 1 / (norm_sigma ** 2)
weight_decay = 0
if weight_decay < 0.0:
raise ValueError("Invalid weight_decay value: {}".format(weight_decay))
if lr is not required and lr < 0.0:
raise ValueError("Invalid learning rate: {}".format(lr))
defaults = dict(lr=lr, weight_decay=weight_decay, addnoise=addnoise, noise_std=noise_std)
super(SGLD, self).__init__(params, defaults)
def step(self):
"""
Performs a single optimization step.
"""
loss = None
for group in self.param_groups:
weight_decay = group['weight_decay']
noise_std = group['noise_std']
for p in group['params']:
if p.grad is None:
continue
d_p = p.grad.data
if weight_decay != 0:
d_p.add_(weight_decay, p.data)
if group['addnoise']:
langevin_noise = p.data.new(p.data.size()).normal_(mean=0, std=noise_std) / np.sqrt(group['lr'])
p.data.add_(-group['lr'],
0.5 * d_p + langevin_noise)
else:
p.data.add_(-group['lr'], 0.5 * d_p)
return loss
'''
class SGLDM(Optimizer):
r"""Implements stochastic gradient descent (optionally with momentum).
Nesterov momentum is based on the formula from
`On the importance of initialization and momentum in deep learning`__.
Args:
params (iterable): iterable of parameters to optimize or dicts defining
parameter groups
lr (float): learning rate
momentum (float, optional): momentum factor (default: 0)
weight_decay (float, optional): weight decay (L2 penalty) (default: 0)
dampening (float, optional): dampening for momentum (default: 0)
nesterov (bool, optional): enables Nesterov momentum (default: False)
Example:
>>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
>>> optimizer.zero_grad()
>>> loss_fn(model(input), target).backward()
>>> optimizer.step()
__ http://www.cs.toronto.edu/%7Ehinton/absps/momentum.pdf
.. note::
The implementation of SGD with Momentum/Nesterov subtly differs from
Sutskever et. al. and implementations in some other frameworks.
Considering the specific case of Momentum, the update can be written as
.. math::
v_{t+1} = \mu * v_{t} + g_{t+1} \\
p_{t+1} = p_{t} - lr * v_{t+1}
where p, g, v and :math:`\mu` denote the parameters, gradient,
velocity, and momentum respectively.
This is in contrast to Sutskever et. al. and
other frameworks which employ an update of the form
.. math::
v_{t+1} = \mu * v_{t} + lr * g_{t+1} \\
p_{t+1} = p_{t} - v_{t+1}
The Nesterov version is analogously modified.
"""
def step(self, closure=None):
"""Performs a single optimization step.
Arguments:
closure (callable, optional): A closure that reevaluates the model
and returns the loss.
"""
loss = None
if closure is not None:
loss = closure()
for group in self.param_groups:
weight_decay = group['weight_decay']
momentum = group['momentum']
dampening = group['dampening']
nesterov = group['nesterov']
for p in group['params']:
if p.grad is None:
continue
d_p = p.grad.data
if weight_decay != 0:
d_p = d_p.add(weight_decay, p.data)
if momentum != 0:
param_state = self.state[p]
if 'momentum_buffer' not in param_state:
buf = param_state['momentum_buffer'] = torch.clone(d_p).detach()
else:
buf = param_state['momentum_buffer']
buf.mul_(momentum).add_(1 - dampening, d_p)
if nesterov:
d_p = d_p.add(momentum, buf)
else:
d_p = buf
if group['addnoise']:
if group['noise_type'] == 'normal':
langevin_noise = p.data.new(p.data.size()).normal_(mean=0, std=group['noise_std']) / np.sqrt(group['lr'])
elif group['noise_type'] == 'laplace':
langevin_noise = torch.distributions.laplace.Laplace(0, group['noise_std'])
langevin_noise = langevin_noise.sample(p.data.size()).cuda() / np.sqrt(group['lr'])
else:
raise ValueError
p.data.add_(-group['lr'], d_p + langevin_noise)
else:
p.data.add_(-group['lr'], d_p)
return loss | [
6738,
28034,
13,
40085,
13,
40085,
7509,
1330,
30011,
7509,
11,
2672,
198,
11748,
299,
32152,
355,
45941,
198,
11748,
28034,
628,
198,
4871,
311,
8763,
35,
7,
27871,
320,
7509,
2599,
198,
220,
220,
220,
37227,
198,
220,
220,
220,
3823... | 1.864347 | 3,708 |
from payton.scene import Scene
from payton.scene.geometry import Cube
from payton.scene.gui import info_box
scene = Scene()
cube = Cube()
cube.track_motion = True
scene.add_object("cube", cube)
scene.create_clock("forward", 0.2, move_forward)
scene.create_clock("back", 0.2, step_back_history)
scene.add_object(
"info",
info_box(
left=10,
top=10,
label="Hit SPACE to start animation",
),
)
scene.run()
| [
6738,
1414,
1122,
13,
29734,
1330,
28315,
198,
6738,
1414,
1122,
13,
29734,
13,
469,
15748,
1330,
23315,
198,
6738,
1414,
1122,
13,
29734,
13,
48317,
1330,
7508,
62,
3524,
198,
198,
29734,
796,
28315,
3419,
628,
628,
198,
40296,
796,
... | 2.542857 | 175 |
# 239. Sliding Window Maximum
# Runtime: 2552 ms, faster than 8.82% of Python3 online submissions for Sliding Window Maximum.
# Memory Usage: 30.8 MB, less than 14.24% of Python3 online submissions for Sliding Window Maximum.
# Deque
| [
2,
32817,
13,
3454,
2530,
26580,
22246,
198,
198,
2,
43160,
25,
1679,
4309,
13845,
11,
5443,
621,
807,
13,
6469,
4,
286,
11361,
18,
2691,
22129,
329,
3454,
2530,
26580,
22246,
13,
198,
198,
2,
14059,
29566,
25,
1542,
13,
23,
10771,
... | 3.492754 | 69 |
import gensim
import _init_paths
import utils.zl_utils as zl
from numpy.random import randn
from sklearn.decomposition import sparse_encode
import numpy as np
from sklearn.decomposition import SparseCoder
import pycocotools.coco as coco
import random
import zl_config as C
n = m = 100 # dimensions of our input
input_x = randn(n, m)
#test_coco()
#test_sparse_coder()
#test_word2vec_wiki()
#save_test_words_to_pickle()
#save_ilsvrc_vectors_to_pickle()
# loaded = zl.load('ilsvrc_word2vec')
# print loaded.keys()
| [
11748,
308,
641,
320,
198,
11748,
4808,
15003,
62,
6978,
82,
198,
11748,
3384,
4487,
13,
48274,
62,
26791,
355,
1976,
75,
198,
6738,
299,
32152,
13,
25120,
1330,
43720,
77,
198,
6738,
1341,
35720,
13,
12501,
296,
9150,
1330,
29877,
62... | 2.666667 | 192 |
# -*- coding: utf-8 -*-
# Generated by Django 1.11.9 on 2019-06-13 16:24
from __future__ import unicode_literals
from django.db import migrations, models
| [
2,
532,
9,
12,
19617,
25,
3384,
69,
12,
23,
532,
9,
12,
198,
2,
2980,
515,
416,
37770,
352,
13,
1157,
13,
24,
319,
13130,
12,
3312,
12,
1485,
1467,
25,
1731,
198,
6738,
11593,
37443,
834,
1330,
28000,
1098,
62,
17201,
874,
198,
... | 2.736842 | 57 |
#locationHelper.py
#A part of NonVisual Desktop Access (NVDA)
#This file is covered by the GNU General Public License.
#See the file COPYING for more details.
#Copyright (C) 2017-2018 NV Access Limited, Babbage B.V.
"""Classes and helper functions for working with rectangles and coordinates."""
from collections import namedtuple
from collections.abc import Sequence
import windowUtils
import winUser
from ctypes.wintypes import RECT, POINT, DWORD
import wx
class Point(namedtuple("Point",("x","y"))):
"""Represents a point on the screen."""
@classmethod
def fromFloatCollection(cls, *floats):
"""Creates an instance from float parameters.
The provided parameters will be converted to ints automatically.
@raise TypeError: If one of the input parameters isn't a float.
"""
if not all(isinstance(f, float) for f in floats):
raise TypeError("All input parameters must be of type float")
return cls(*map(int, floats))
@classmethod
def fromCompatibleType(cls, point):
"""Creates an instance from a compatible type.
Compatible types are defined in L{POINT_CLASSES}.
"""
if isinstance(point,POINT_CLASSES):
return cls(point.x, point.y)
raise TypeError("point should be one of %s" % ", ".join(cls.__module__+"."+cls.__name__ for cls in POINT_CLASSES))
@classmethod
def __add__(self,other):
"""Returns a new L{Point} with its coordinates representing the additions of the original x and y coordinates."""
if not isinstance(other,POINT_CLASSES):
return NotImplemented
return Point((self.x+other.x),(self.y+other.y))
def __radd__(self,other):
"""Returns a new L{Point} with x = self.x + other.x and y = self.y + other.y."""
if other == 0:
return self
elif not isinstance(other,POINT_CLASSES):
return NotImplemented
return Point((other.x+self.x),(other.y+self.y))
def yWiseLessThan(self,other):
"""
Returns whether self is less than other, first comparing y, then x coordinates.
For example: (x=4,y=3) < (x=3,y=4) because self.y is less than other.y.
To compare in opposite order (i.e. compare x, then y), use L{xWiseLessThan}
"""
if not isinstance(other,POINT_CLASSES):
return NotImplemented
return (self.y, self.x) < (other.y, other.x)
def xWiseLessThan(self,other):
"""
Returns whether self is less than other, first comparing x, then y coordinates.
For example: (x=3,y=4) < (x=4,y=3) because self.x is less than other.x.
To compare in opposite order (i.e. compare y, then x), use L{yWiseLessThan}
"""
if not isinstance(other,POINT_CLASSES):
return NotImplemented
return (self.x, self.y) < (other.x, other.y)
def yWiseLessOrEq(self,other):
"""
Returns whether self is less than or equal to other, first comparing y, then x coordinates.
For example: (x=4,y=3) <= (x=3,y=4) because self.y is less than or equal to other.y.
To compare in opposite order (i.e. compare x, then y), use L{xWiseLessOrEq}
"""
if not isinstance(other,POINT_CLASSES):
return NotImplemented
return (self.y, self.x) <= (other.y, other.x)
def xWiseLessOrEq(self,other):
"""
Returns whether self is less than or equal to other, first comparing x, then y coordinates.
For example: (x=3,y=4) <= (x=4,y=3) because self.x is less than or equal to other.x.
To compare in opposite order (i.e. compare y, then x), use L{yWiseLessOrEq}
"""
if not isinstance(other,POINT_CLASSES):
return NotImplemented
return (self.x, self.y) <= (other.x, other.y)
def yWiseGreaterThan(self,other):
"""
Returns whether self is greater than other, first comparing y, then x coordinates.
For example: (x=3,y=4) > (x=4,y=3) because self.y is greater than other.y.
To compare in opposite order (i.e. compare x, then y), use L{xWiseGreaterThan}
"""
if not isinstance(other,POINT_CLASSES):
return NotImplemented
return (self.y, self.x) > (other.y, other.x)
def xWiseGreaterThan(self,other):
"""
Returns whether self is greater than other, first comparing x, then y coordinates.
For example: (x=4,y=3) > (x=3,y=4) because self.x is greater than other.x.
To compare in opposite order (i.e. compare y, then x), use L{yWiseGreaterThan}
"""
if not isinstance(other,POINT_CLASSES):
return NotImplemented
return (self.x, self.y) > (other.x, other.y)
def yWiseGreaterOrEq(self,other):
"""
Returns whether self is greater than or equal to other, first comparing y, then x coordinates.
For example: (x=3,y=4) >= (x=4,y=3) because self.y is greater than or equal to other.y.
To compare in opposite order (i.e. compare x, then y), use L{xWiseGreaterOrEq}
"""
if not isinstance(other,POINT_CLASSES):
return NotImplemented
return (self.y, self.x) >= (other.y, other.x)
def xWiseGreaterOrEq(self,other):
"""
Returns whether self is greater than or equal to other, first comparing x, then y coordinates.
For example: (x=4,y=3) >= (x=3,y=4) because self.x is greater than or equal to other.x.
To compare in opposite order (i.e. compare y, then x), use L{yWiseGreaterOrEq}
"""
if not isinstance(other,POINT_CLASSES):
return NotImplemented
return (self.x, self.y) >= (other.x, other.y)
# As __eq__ was defined on this class, we must provide __hash__ to remain hashable.
def toPOINT(self):
"""Converts self to a L{ctypes.wintypes.POINT}"""
return POINT(self.x,self.y)
def toLogical(self, hwnd):
"""Converts self from physical to logical coordinates and returns a new L{Point}."""
return Point(*windowUtils.physicalToLogicalPoint(hwnd, *self))
def toPhysical(self, hwnd):
"""Converts self from logical to physical coordinates and returns a new L{Point}"""
return Point(*windowUtils.logicalToPhysicalPoint(hwnd, *self))
def toClient(self, hwnd):
"""Converts self from screen to client coordinates and returns a new L{Point}"""
return Point(*winUser.ScreenToClient(hwnd, *self))
def toScreen(self, hwnd):
"""Converts self from client to screen coordinates and returns a new L{Point}"""
return Point(*winUser.ClientToScreen(hwnd, *self))
class _RectMixin:
"""Mix-in class for properties shared between RectLTRB and RectLTWH classes"""
@classmethod
def fromFloatCollection(cls, *floats):
"""Creates an instance from float parameters.
The provided parameters will be converted to ints automatically.
@raise TypeError: If one of the input parameters isn't a float.
"""
if not all(isinstance(f, float) for f in floats):
raise TypeError("All input parameters must be of type float")
return cls(*map(int, floats))
@classmethod
def fromCompatibleType(cls, rect):
"""Creates an instance from a compatible type.
Compatible types are defined in L{RECT_CLASSES}.
"""
if isinstance(rect,cls):
return rect
if isinstance(rect,RECT_CLASSES):
if cls is RectLTWH:
return cls(rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top)
elif cls is RectLTRB:
return cls(rect.left, rect.top, rect.right, rect.bottom)
raise TypeError("rect should be one of %s" % ", ".join(cls.__module__+"."+cls.__name__ for cls in RECT_CLASSES))
@classmethod
def fromPoint(cls, point):
"""Creates an instance from a compatible point type with a width and height of 0."""
if isinstance(point,POINT_CLASSES):
if cls is RectLTWH:
return cls(point.x, point.y, 0, 0)
elif cls is RectLTRB:
return cls(point.x, point.y, point.x, point.y)
else:
raise RuntimeError("%s is not known as a valid subclass of _RectMixin" % cls.__name__)
raise TypeError("point should be one of %s" % ", ".join(cls.__module__+"."+cls.__name__ for cls in POINT_CLASSES))
@classmethod
def fromCollection(cls, *items):
"""Creates a bounding rectangle for the provided collection of items.
The highest coordinates found in the collection are considered exclusive.
For example, if you provide Point(x=1,y=1) and point(x=2,y=2),
The resulting rectangle coordinates are left=1,top=1,right=2,bottom=2.
Input could be of mixed types from either L{RECT_CLASSES} or L{POINT_CLASSES}.
"""
if len(items)==0:
raise TypeError("This function takes at least 1 argument (0 given)")
xs=set()
ys=set()
for item in items:
if isinstance(item,RECT_CLASSES):
xs.update((item.left,item.right))
ys.update((item.top,item.bottom))
elif isinstance(item,POINT_CLASSES):
xs.add(item.x)
ys.add(item.y)
else:
raise ValueError("Unexpected parameter %s"%str(item))
left=min(xs)
top=min(ys)
right=max(xs)
bottom=max(ys)
if cls is RectLTWH:
return cls(left, top, right-left, bottom-top)
return cls(left, top, right, bottom)
def toRECT(self):
"""Converts self to a L{ctypes.wintypes.RECT}"""
return RECT(self.left,self.top,self.right,self.bottom)
@property
@property
@property
@property
@property
def __contains__(self,other):
"""Returns whether other is a part of this rectangle."""
if isinstance(other,POINT_CLASSES):
return self.left <= other.x < self.right and self.top <= other.y < self.bottom
if not isinstance(other,RECT_CLASSES):
return NotImplemented
return self.isSuperset(other) and self!=other
def isSubset(self,other):
"""Returns whether this rectangle is a subset of other (i.e. whether all points in this rectangle are contained by other)."""
if not isinstance(other,RECT_CLASSES):
return False
return other.left<=self.left<=self.right<=other.right and other.top<=self.top<=self.bottom<=other.bottom
def isSuperset(self,other):
"""Returns whether this rectangle is a superset of other (i.e. whether all points of other are contained by this rectangle)."""
if not isinstance(other,RECT_CLASSES):
raise TypeError("other should be one of %s" % ", ".join(cls.__module__+"."+cls.__name__ for cls in RECT_CLASSES))
return self.left<=other.left<=other.right<=self.right and self.top<=other.top<=other.bottom<=self.bottom
# As __eq__ was defined on this class, we must provide __hash__ to remain hashable.
def intersection(self,other):
"""Returns the intersection of self and other.
For example, if self = Rect(left=10,top=10,right=25,bottom=25) and other = Rect(left=20,top=20,right=35,bottom=35),
this results in Rect(left=20,top=20,right=25,bottom=25).
No intersect results in a rectangle with zeroed coordinates.
"""
if not isinstance(other,RECT_CLASSES):
raise TypeError("other should be one of %s" % ", ".join(cls.__module__+"."+cls.__name__ for cls in RECT_CLASSES))
left=max(self.left,other.left)
top=max(self.top,other.top)
right=min(self.right,other.right)
bottom=min(self.bottom,other.bottom)
if left>right or top>bottom:
left=top=right=bottom=0
if isinstance(self, RectLTWH):
return RectLTWH(left,top,right-left,bottom-top)
return RectLTRB(left,top,right,bottom)
def expandOrShrink(self, margin):
"""Expands or shrinks the boundaries of the rectangle with the given margin.
For example, if self = Rect(left=10,top=10,right=25,bottom=25) and margin = 10,
this results in Rect(left=0,top=0,right=35,bottom=35).
If self = Rect(left=10,top=10,right=25,bottom=25) and margin = -5,
this results in Rect(left=15,top=15,right=20,bottom=20).
"""
if not isinstance(margin, int):
raise TypeError("Margin should be an integer")
left=self.left-margin
top=self.top-margin
right=self.right+margin
bottom=self.bottom+margin
if left>right or top>bottom:
raise RuntimeError("The provided margin of %d would result in a rectangle with a negative width or height, which is not allowed"%margin)
if isinstance(self, RectLTWH):
return RectLTWH(left,top,right-left,bottom-top)
return RectLTRB(left,top,right,bottom)
class RectLTWH(_RectMixin, namedtuple("RectLTWH",("left","top","width","height"))):
"""
Represents a rectangle on the screen, based on left and top coordinates, width and height.
To represent a rectangle using left, top, right and bottom coordinates, use L{RectLTRB}.
"""
@property
@property
class RectLTRB(_RectMixin, namedtuple("RectLTRB",("left","top","right","bottom"))):
"""Represents a rectangle on the screen.
By convention, the right and bottom edges of the rectangle are normally considered exclusive.
To represent a rectangle based on width and height instead, use L{RectLTWH}.
"""
@property
@property
#: Classes which support conversion to locationHelper Points using their x and y properties.
#: type: tuple
POINT_CLASSES=(Point, POINT, wx.Point)
#: Classes which support conversion to locationHelper RectLTRB/LTWH using their left, top, right and bottom properties.
#: type: tuple
RECT_CLASSES=(RectLTRB, RectLTWH, RECT)
| [
2,
24886,
47429,
13,
9078,
198,
2,
32,
636,
286,
8504,
36259,
27850,
8798,
357,
27159,
5631,
8,
198,
2,
1212,
2393,
318,
5017,
416,
262,
22961,
3611,
5094,
13789,
13,
198,
2,
6214,
262,
2393,
27975,
45761,
329,
517,
3307,
13,
198,
... | 2.804889 | 4,459 |
import torch
class Actor(torch.nn.Module):
"""
this is the policy network
"""
| [
11748,
28034,
198,
198,
4871,
27274,
7,
13165,
354,
13,
20471,
13,
26796,
2599,
628,
197,
37811,
628,
197,
5661,
318,
262,
2450,
3127,
628,
197,
37811,
628,
198
] | 3 | 29 |
import sys
import unittest
import numpy
from pathlib import Path
from typing import Tuple, List
import trueskill
sys.path.insert(0, str(Path(__file__).parent.parent / 'autoleague'))
from bots import BotID
from leaguesettings import LeagueSettings
from match_maker import MatchMaker, TicketSystem
from ranking_system import RankingSystem
RESOURCES_FOLDER = Path(__file__).parent / 'resources'
NUM_ITERATIONS = 100
if __name__ == '__main__':
unittest.main()
| [
11748,
25064,
198,
11748,
555,
715,
395,
198,
11748,
299,
32152,
198,
6738,
3108,
8019,
1330,
10644,
198,
6738,
19720,
1330,
309,
29291,
11,
7343,
198,
198,
11748,
491,
947,
12728,
198,
198,
17597,
13,
6978,
13,
28463,
7,
15,
11,
965,... | 3.175676 | 148 |
# -*- coding: utf-8 -*-
# @version : Python3.6
# @Time : 2017/4/21 15:56
# @Author : Jianyang-Hu
# @contact : jianyang1993@163.com
# @File : stock_csv_0421.py
# @Software: PyCharm
import numpy
from numpy import *
from datetime import datetime
#usecols=(4,5)计数从0开始
c,v = loadtxt("stocks.csv",delimiter=",",usecols=(4,5),unpack=True)
#加权平均价格
vwap = average(c,weights=v)
print("VWAP=",vwap)
#算术平均值
print("mean=",mean(c))
#范围
print("the price span is:",ptp(c))
#价格的中位数
print("the median=",median(c))
#排序并且检查中位数
sorted_close = msort(c)
print("sorted:",sorted_close)
#中位数位置
N = len(c)
# mid = sorted()
print(N)
#求股票收益率
returns = diff(c) / c[:-1]
print("Standard deviation = ", std(returns))
#哪个交易日收益为正
posretindices = where(returns > 0)
print("indices with positive returns",posretindices)
#波动率
logreturns = diff(log(c))
annual_volatility = std(logreturns) / mean(logreturns)
annual_volatility = annual_volatility / sqrt(1./252.)
print("Annual volatility",annual_volatility)
print("Monthly volatility",annual_volatility * sqrt(1./12.))
#处理日期
# def datastr2num(s):
# return datetime.datetime.strptime\
# (s,"%d-%m-%Y").date().weekday()
# datas,c2 = loadtxt("stocks.csv",delimiter=",",usecols=(0,4),converters={1:datastr2num},unpack=True)
# print(datas)
#
# averages = zeros(5)
#
# for i in range(5):
# indices = where(datas == i)
# prices = take(c2,indices)
# avg = mean(prices)
# print("Day",i,"prices",prices,"averag",avg)
# average[i] = avg
# top = max(averages)
# print("Top day of the week",argmax(averages))
#
# bottom = min(averages)
# print("Bottom day of the day",argmin(averages))
| [
2,
532,
9,
12,
19617,
25,
3384,
69,
12,
23,
532,
9,
12,
198,
2,
2488,
9641,
1058,
11361,
18,
13,
21,
198,
2,
2488,
7575,
220,
220,
220,
1058,
2177,
14,
19,
14,
2481,
1315,
25,
3980,
198,
2,
2488,
13838,
220,
1058,
40922,
17859... | 2.01476 | 813 |
#!/usr/bin/env python3
print(("str = %s" % str(str)))
print(("str = %s" % str(dir(str))))
str1 = "bytes"
print(("str1 = %s" % str1))
str2 = str1.encode()
print(("str2 = %s" % str2))
str3 = str2.decode()
print(("str3 = %s" % str3))
if str1 == str3:
print("coverted ok")
else:
print("FAIL did not covert ok")
print(("FAIL str1 = %s" % str1))
print(("FAIL str3 = %s" % str3))
| [
2,
48443,
14629,
14,
8800,
14,
24330,
21015,
18,
198,
198,
4798,
7,
7203,
2536,
796,
4064,
82,
1,
4064,
965,
7,
2536,
22305,
198,
198,
4798,
7,
7203,
2536,
796,
4064,
82,
1,
4064,
965,
7,
15908,
7,
2536,
35514,
198,
198,
2536,
1... | 2.124324 | 185 |
import json
# read from string
json_data = open('./test/test.json').read()
data = json.loads(json_data)
print(data['1']['damage'])
# read from file
json_data_1 = open('./test/test.json')
data2 = json.load(json_data_1)
print(data2['1']['nameArr'])
| [
11748,
33918,
198,
198,
2,
1100,
422,
4731,
198,
17752,
62,
7890,
796,
1280,
7,
4458,
14,
9288,
14,
9288,
13,
17752,
27691,
961,
3419,
198,
7890,
796,
33918,
13,
46030,
7,
17752,
62,
7890,
8,
198,
4798,
7,
7890,
17816,
16,
6,
7131... | 2.460784 | 102 |
#!/usr/bin/env python
# Copyright 2016 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Hook to install the git config for using the clang-format merge driver."""
import os
import subprocess
import sys
_VERSION = 1
if __name__ == '__main__':
sys.exit(main())
| [
2,
48443,
14629,
14,
8800,
14,
24330,
21015,
198,
2,
15069,
1584,
383,
18255,
1505,
46665,
13,
1439,
2489,
10395,
13,
198,
2,
5765,
286,
428,
2723,
2438,
318,
21825,
416,
257,
347,
10305,
12,
7635,
5964,
326,
460,
307,
198,
2,
1043,... | 3.388889 | 108 |
"""Equation definitions for SINDy-BVP."""
# Python Package Imports
from typing import List
# Third party imports
import numpy as np
def sturm_liouville_function(x, y, p, p_x, q, f, alpha=0, nonlinear_exp=2):
"""Second order Sturm-Liouville Function defining y'' for Lu=f.
This form is used because it is expected for Scipy's solve_ivp method.
Keyword arguments:
x -- independent variable
y -- dependent variable
p -- p(x) parameter
p_x -- derivative of p_x wrt x
q -- q(x) parameter
f -- forcing function f(x)
alpha -- nonlinear parameter
nonlinear_exp -- exponent of nonlinear term
"""
y_x = y[1]
y_xx = -1*(p_x/p)*y[1] + (q/p)*y[0] + (q/p)*alpha*y[0]**nonlinear_exp - f/p
return [y_x, y_xx]
def euler_bernoulli_beam(x, y, EI, f):
"""Euler-Bernoulli Beam Theory defining y'''' for Lu=f.
This form is used because it is expected for Scipy's solve_ivp method.
Keyword arguments:
x -- independent variable
y -- dependent variable
EI -- EI(x) parameter
f -- forcing function f(x)
"""
return [y[1], y[2], y[3], -1*f/EI]
def piecewise_p(x, val_a=25, val_b=300, val_c=100):
"""Define piecewise p(x) function.
The p(x) function has three values at different spatial positions.
Keyword arguments:
x -- spatial position to evaluate piecewise p(x)
val_a -- first value, for x>8 and 2<x<4
val_b -- second value, for 6<x<8
val_c -- third value, for 4<x<6 and 0<x<2
Returns:
p -- the value of p at a given position x
"""
if x > 8:
p = val_a
elif x > 6:
p = val_b
elif x > 4:
p = val_c
elif x > 2:
p = val_a
else:
p = val_c
return p
def get_forcings(i_set: List[float] = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7],
j_set: List[float] = [1, 3, 5, 7, 10],
k_set: List[float] = [0.8, 0.9, 1.0, 1.1, 1.2, 1.3]):
"""Generate a collection of sine and cosine forcing functions.
For each i, j, k in i_set, j_set, k_set, add the functions i*cos(j*x)+k and
i*sin(j*x)+k to the list of forcing functions.
Keyword arguments:
i_set, j_set, k_set -- sets of numbers for computing forcing functions
Returns:
forcings -- a list of forcing functions
"""
forcings = []
for i in i_set:
for j in j_set:
for k in k_set:
forcings.append(lambda x, i=i, j=j, k=k: i*np.cos(j*x)+k)
forcings.append(lambda x, i=i, j=j, k=k: i*np.sin(j*x)+k)
return forcings
| [
37811,
23588,
341,
17336,
329,
311,
12115,
88,
12,
33,
8859,
526,
15931,
198,
198,
2,
11361,
15717,
1846,
3742,
198,
6738,
19720,
1330,
7343,
198,
198,
2,
10467,
2151,
17944,
198,
11748,
299,
32152,
355,
45941,
628,
198,
4299,
336,
33... | 2.215398 | 1,156 |
import unittest
import datetime
from data.mongoDB import MongoDB_Context
from data.valheim_player import Player, TotalDeaths, PlayerServerStats
from mongoengine import * | [
11748,
555,
715,
395,
198,
11748,
4818,
8079,
198,
6738,
1366,
13,
76,
25162,
11012,
1330,
42591,
11012,
62,
21947,
198,
6738,
1366,
13,
2100,
9096,
62,
7829,
1330,
7853,
11,
7472,
20148,
82,
11,
7853,
10697,
29668,
198,
6738,
285,
25... | 3.695652 | 46 |
from django.core.urlresolvers import reverse
from django.http import Http404
from django.http import HttpResponse, HttpResponseRedirect
from django.shortcuts import render, get_object_or_404
from problems.forms.export import ExportForm
from problems.models import ExportPackage, ExportPackageCreationTask
from problems.views.generics import RevisionObjectView, ProblemObjectDownloadView
| [
6738,
42625,
14208,
13,
7295,
13,
6371,
411,
349,
690,
1330,
9575,
198,
6738,
42625,
14208,
13,
4023,
1330,
367,
29281,
26429,
198,
6738,
42625,
14208,
13,
4023,
1330,
367,
29281,
31077,
11,
367,
29281,
31077,
7738,
1060,
198,
6738,
426... | 3.949495 | 99 |
import json
import math
import os
import re
import string
from pprint import pprint
from functools import reduce
def modify_for_re(word):
"""在字符串中的(及)前面加上\, 方便转换成正则表达式"""
to_be_removed = ['(', ')', '+', '*', '^', '.', '?', '$', '|']
for signal in to_be_removed:
word = word.replace(signal, '\\' + signal)
return word
def get_ordinary_word(ord_path):
"""常用词词典"""
ord_dic = []
with open(ord_path, 'r', encoding='utf8') as fr:
for line in fr.readlines():
ord_dic.append(line.split()[0])
return ord_dic
def manual_filtration(word, neg_list):
"""作用在 word 上, 若该词为负例则返回 True, 否则返回 False"""
pattern_1 = r',|\.|:|;|"'
pattern_2 = r'行|示|为|较|见|天|音'
pattern_3 = r'切除|标本|摄取|存在|活检|穿刺|开口|引流|胸痛|患者|治疗|不适|受限|疼痛|基本|压缩'
pattern_4 = r'^[A-Za-z0-9_]+$'
remove_word_list = neg_list + ['病理', '癌', '炎', '占位']
tnm_pattern = r'[Tt]\S{1,2}[Nn][xX0123][Mm][01]'
word_no_punc = remove_punctuation(word)
if ((not re.search(pattern_1, word)) and (not re.search(pattern_2, word)) and (not re.search(pattern_3, word))
and (not re.search(pattern_4, word)) and len(word_no_punc) > 1 and (word_no_punc not in remove_word_list)):
if (not re.search(tnm_pattern, word)) and re.search(r'\d', word):
return True
else:
return False
else:
return True
def get_txt_file(txt_path):
""" 从整理好的文本中读取相应内容做成一个列表,
列表的每个元为一个句子. 该结果仅用于提取字典使用,
不能用于后面的任务, 因为所有病人的文本都混到了一起 """
txt_file = []
file_list = os.listdir(txt_path)
for file in file_list:
if file.endswith('json'):
with open(os.path.join(txt_path, file), 'r', encoding='utf8') as txt_fr:
txt_dic = json.load(txt_fr)
for txt_date in txt_dic.keys():
line_list = [line.strip() for line in txt_dic[txt_date].split('。') if line.strip() !='']
txt_file.extend(line_list)
return txt_file
# 利用生成器, 每次使用的时候都要生成, 不知道和上面的列表哪一种方式更快
# def get_txt_file(path):
# """ 从整理好的文本中读取相应内容做成一个列表,
# 列表的每个元为一个句子. 该结果仅用于提取字典使用,
# 不能用于后面的任务, 因为所有病人的文本都混到了一起 """
# file_list = os.listdir(path)
# for file in file_list:
# if os.path.splitext(file)[-1] == '.json':
# with open(os.path.join(path, file), 'r', encoding='utf8') as txt_fr:
# txt_dic = json.load(txt_fr)
# for txt_date in txt_dic.keys():
# for line in (line.strip() for line in txt_dic[txt_date].split('。') if line.strip() !=''):
# yield txt_file
def find_mod(txt_file, word_list):
"""用字典中的词发现文本模式"""
word_count = {}
# 用一个字典保存, key为发现的文本模式, 键值为匹配该模式的词典中的词的数目
mod_list = []
# 文本模式以列表形式保存
word_match = {}
p = 5
q = 5
for line in txt_file:
#line = trans_punctuation(line)
if len(line) > 0:
for word in word_list:
word = modify_for_re(word)
loc_list = [w.start() for w in re.finditer(word, line)]
for loc in loc_list:
for i in range(1, (p + 1)):
for j in range(1, (q + 1)):
if loc - i >= 0 and loc + len(word) + j < len(line):
ext_word = line[loc - i: loc + len(word) + j]
ext_wd = modify_for_re(ext_word)
local_ind = ext_wd.index(word)
try:
# mod = re.compile(ext_wd[:local_ind]+'(\S{%d})'%len(word)+ext_wd[local_ind+len(word):])
mod = (ext_wd[:local_ind], ext_wd[local_ind + len(word):])
except re.error:
print(word + '\t\t' + ext_word + '\n')
if mod not in mod_list:
mod_list.append(mod)
word_match[mod] = {word}
else:
word_match[mod].add(word)
for mod in mod_list:
word_count[mod] = len(word_match[mod])
return mod_list, word_count, word_match
def find_word(txt_file, mod_list, word_list, neg_list):
"""用发现的模式去发现文本中的新词"""
mod_count = {}
# 键为发现的模式, 相应的值为匹配到的词的数目
mod_match = {}
# 键为发现的模式, 相应的值为匹配到的词的集合
mod_match_neg = {}
mod_match_unlabeled = {}
new_word = set()
# 匹配到的新词的集合
for mod in mod_list:
word_set = set()
for line in txt_file:
#line = trans_punctuation(line)
left_index = [w.end() for w in re.finditer(mod[0], line)]
right_index = [w.start() for w in re.finditer(mod[1], line)]
start = 0
i, j = 0, 0
for i in range(len(left_index)):
if start < len(right_index):
for j in range(start, len(right_index)):
if right_index[j] > left_index[i] and (i == len(left_index)-1 or right_index[j] <= left_index[i+1]):
word = line[left_index[i]: right_index[j]]
if len(word) < 15:
# print (word)
# print (file)
word_set.add(word)
start += 1
break
elif i < len(left_index) - 1 and right_index[j] > left_index[i+1]:
break
else:
start += 1
num_extract = len(word_set)
mod_count[mod] = num_extract
mod_match[mod] = word_set
unlabeled_word = word_set.difference(set(word_list))
#neg_word_type1 = unlabeled_word.intersection(set(neg_list))
#unlabeled_word = unlabeled_word.difference(neg_word_type1)
neg_word = set([word for word in unlabeled_word if manual_filtration(word, neg_list) or (remove_punctuation(word) in word_list)])
#neg_word = neg_word_type1.union(neg_word_type2)
unlabeled_word = unlabeled_word.difference(neg_word)
mod_match_neg[mod] = neg_word
mod_match_unlabeled[mod] = unlabeled_word
new_word = new_word.union(unlabeled_word)
# new_word = new_word.difference(set(word_list))
return new_word, mod_count, mod_match, mod_match_neg, mod_match_unlabeled
def score_mod(mod, word_count, mod_count, mod_match_unlabel):
"""计算模式的评分"""
p = word_count[mod]
u = len(mod_match_unlabel[mod])
t = mod_count[mod]
return (p / t) * math.log(u + 1, 2) * math.log(p + 1, 2)
def postmodify_word(word):
"""在一些明显不合理的词前面加上适当的前缀"""
res = []
direc_list = ['左', '右', '双']
if re.search(r'^侧|叶|肺', word) and not re.search(r'[左右]', word):
for direc in direc_list:
res.append(direc + word)
else:
res.append(word)
return res
# 在负例词典中加入手术, 药物和身体部位, 并且身体部位词可以和方位词进行组合
# 方位词主要有: 上下左右半前后
if __name__ == '__main__':
txt_path = 'e:/test/病例特点/'
dic_path = 'C:/Users/yingying.zhu/Documents/dicts'
ord_path = 'C:/Users/yingying.zhu/Documents/现代汉语常用词表.txt'
dic_type = 'tutor'
res = get_user_dict(txt_path, dic_path, ord_path, dic_type)
with open('C:/Users/yingying.zhu/Desktop/user_dic.txt', 'w', encoding='utf8') as fr:
fr.write('\n'.join(list(res)))
| [
11748,
33918,
201,
198,
11748,
10688,
201,
198,
11748,
28686,
201,
198,
11748,
302,
201,
198,
11748,
4731,
201,
198,
201,
198,
6738,
279,
4798,
1330,
279,
4798,
201,
198,
6738,
1257,
310,
10141,
1330,
4646,
201,
198,
201,
198,
201,
19... | 1.518241 | 5,071 |
"""
Label - Name
TextEntry
Labl - Email
TextEntry
Button - Submit
"""
import Tkinter as tk
root = tk.Tk()
tk.Label(root, text="Name:", anchor="w").pack(fill="x")
tk.Entry(root).pack(fill="x")
tk.Label(root,text="Email:", anchor="w").pack(fill="x")
tk.Entry(root).pack(fill="x")
tk.Button(root,text="Submit").pack(fill="x")
root.mainloop()
| [
37811,
198,
33986,
532,
6530,
198,
8206,
30150,
198,
198,
17822,
75,
532,
9570,
198,
8206,
30150,
198,
198,
21864,
532,
39900,
198,
37811,
628,
198,
11748,
309,
74,
3849,
355,
256,
74,
198,
198,
15763,
796,
256,
74,
13,
51,
74,
3419... | 2.475177 | 141 |
# ------------------------------------------------------------------------
# QAHOI
# Copyright (c) 2021 Junwen Chen. All Rights Reserved.
# Licensed under the Apache License, Version 2.0 [see LICENSE for details]
# ------------------------------------------------------------------------
# Copyright (c) Hitachi, Ltd. All Rights Reserved.
# Licensed under the Apache License, Version 2.0 [see LICENSE for details]
# ------------------------------------------------------------------------
import numpy as np
from collections import defaultdict
# Refer to CDN: https://github.com/YueLiao/CDN/blob/main/datasets/hico_eval.py
# Modified from CDN: https://github.com/YueLiao/CDN/blob/main/datasets/hico_eval.py
| [
2,
16529,
982,
198,
2,
1195,
18429,
46,
40,
198,
2,
15069,
357,
66,
8,
33448,
7653,
21006,
12555,
13,
1439,
6923,
33876,
13,
198,
2,
49962,
739,
262,
24843,
13789,
11,
10628,
362,
13,
15,
685,
3826,
38559,
24290,
329,
3307,
60,
19... | 4.073864 | 176 |
# Copyright 2018 Samuel Payne sam_payne@byu.edu
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from .file_download import download, download_pdc_id, list_pdc_datasets
from .pdcbrca import PdcBrca
from .pdcccrcc import PdcCcrcc
from .pdccoad import PdcCoad
from .pdcgbm import PdcGbm
from .pdchnscc import PdcHnscc
from .pdclscc import PdcLscc
from .pdcluad import PdcLuad
from .pdcov import PdcOv
from .pdcpdac import PdcPdac
from .pdcucec import PdcUcec
from .pancanbrca import PancanBrca
from .pancanccrcc import PancanCcrcc
from .pancancoad import PancanCoad
from .pancangbm import PancanGbm
from .pancanhnscc import PancanHnscc
from .pancanlscc import PancanLscc
from .pancanluad import PancanLuad
from .pancanov import PancanOv
from .pancanucec import PancanUcec
from .pancanpdac import PancanPdac
def list_datasets(print_list=True):
"""Print available datasets in the cptac.pancan module.
Parameters:
print_list (bool, optional): Whether to print the list. Default is True. Otherwise, it's returned as a string.
"""
datasets = [
"PancanBrca",
"PancanCcrcc",
"PancanCoad",
"PancanGbm",
"PancanHnscc",
"PancanLscc",
"PancanLuad",
"PancanOv",
"PancanUcec",
"PancanPdac"
]
str_result = "\n".join(datasets)
if print_list:
print(str_result)
else:
return str_result
| [
2,
220,
220,
15069,
2864,
17100,
32788,
6072,
62,
15577,
710,
31,
1525,
84,
13,
15532,
198,
2,
220,
220,
49962,
739,
262,
24843,
13789,
11,
10628,
362,
13,
15,
357,
1169,
366,
34156,
15341,
198,
2,
220,
220,
345,
743,
407,
779,
42... | 2.527009 | 759 |
import pandas as pd
import time
from bs4 import BeautifulSoup
from IPython.display import display_html
from selenium import webdriver
from mysql_service import insert_day
if __name__ == "__main__":
selenium_scraper()
| [
11748,
19798,
292,
355,
279,
67,
198,
11748,
640,
198,
6738,
275,
82,
19,
1330,
23762,
50,
10486,
198,
198,
6738,
6101,
7535,
13,
13812,
1330,
3359,
62,
6494,
198,
6738,
384,
11925,
1505,
1330,
3992,
26230,
198,
6738,
48761,
62,
15271... | 3.214286 | 70 |
import os
import struct
from glob import glob
import pandas as pd
import numpy as np
from pyspectools import ftmw_analysis as fa
def parse_spectrum(filename, threshold=20.0):
""" Function to read in a blackchirp or QtFTM spectrum from file """
dataframe = pd.read_csv(
filename, delimiter="\t", names=["Frequency", "Intensity"], skiprows=1
)
dataframe.dropna(inplace=True)
return dataframe[dataframe["Intensity"] <= threshold]
def parse_ascii(filename, delimiter="\t", names=None, header=None, skiprows=0):
"""
Generic ASCII parser wrapping the pandas read_csv function.
Parameters
----------
filename
delimiter
names
header
skiprows
Returns
-------
"""
dataframe = pd.read_csv(
filename, delimiter=delimiter, names=names, header=header, skiprows=skiprows
)
dataframe.dropna(inplace=True)
return dataframe
def parse_lin(filename):
"""
Function to read in a line file, formatted in the SPFIT
convention.
"""
data = list()
with open(filename) as read_file:
for line in read_file:
line_data = list()
# Get all the delimiting out
split_line = line.split()
split_cols = split_line[-3:]
# Convert frequency, uncertainty, and weight
# into floats
for col in split_cols:
try:
line_data.append(float(col))
except ValueError:
line_data.append(0.0)
# Split up the quantum numbers
# qnos = qnos.split()
# qnos = [int(num) for num in qnos]
line_data.append(",".join(split_line[:-3]))
data.append(line_data)
dataframe = pd.DataFrame(
data=data, columns=["Frequency", "Uncertainty", "Weight", "Quantum numbers"]
)
return dataframe
def parse_cat(simulation_path, low_freq=0.0, high_freq=np.inf, threshold=-np.inf):
"""
Parses a simulation output, and filters the frequency and intensity to give
a specific set of lines.
The only argument that is required is the path to the simulation output. Others
are optional, and will default to effectively not filter.
The quantum numbers are read in assuming hyperfine structure, and thus
might not be accurate descriptions of what they actually are.
"""
cat_df = pd.read_fwf(
simulation_path,
widths=[13, 8, 8, 2, 10, 3, 7, 4, 2, 2, 2, 8, 2, 2],
header=None,
)
cat_df.columns = [
"Frequency",
"Uncertainty",
"Intensity",
"DoF",
"Lower state energy",
"Degeneracy",
"ID",
"Coding",
"N'",
"F'",
"J'",
"N''",
"F''",
"J''",
]
cat_df = cat_df.loc[
(cat_df["Frequency"].astype(float) >= low_freq)
& ( # threshold the simulation output
cat_df["Frequency"].astype(float) <= high_freq
)
& ( # based on user specified values
cat_df["Intensity"].astype(float) >= threshold
) # or lack thereof
]
return cat_df
def parse_blackchirp(dir_path):
"""
Function for reading in a Blackchirp experiment. The required input should point to the directory
containing the Blackchirp files with the correct extensions: .hdr, .tdt, and .fid
Parameters
----------
dir_path - str
Filepath pointing to the directory containing the Blackchirp experiment files.
"""
# Read in header information
hdr_file = glob(os.path.join(dir_path, "*.hdr"))
header = dict()
try:
hdr_file = hdr_file[0]
exp_id = hdr_file.split("/")[-1].split(".")[0]
except IndexError:
raise Exception("Header file is missing!")
with open(hdr_file) as hdr:
for line in hdr:
if not line:
continue
l = line.split("\t")
if not l or len(l) < 3:
continue
key = l[0].strip()
value = l[1].strip()
unit = l[2].strip()
header[key] = {"value": value, "unit": unit}
# Locate all the FIDs
fid_files = glob(os.path.join(dir_path, "*.fid"))
if len(fid_files) < 1:
raise Exception("No FID files present!")
else:
fid_list = list()
for file in fid_files:
with open(file, "rb") as fidfile:
buffer = fidfile.read(4)
ms_len = struct.unpack(">I", buffer)
buffer = fidfile.read(ms_len[0])
magic_string = buffer.decode("ascii")
if not magic_string.startswith("BCFID"):
raise ValueError(
"Could not read magic string from {}".format(fidfile.name)
)
l = magic_string.split("v")
if len(l) < 2:
raise ValueError(
"Could not determine version number from magic string {}".format(
magic_string
)
)
version = l[1]
buffer = fidfile.read(4)
fidlist_size = struct.unpack(">I", buffer)[0]
for i in range(0, fidlist_size):
# Create a BlackChirpFid object
fid_list.append(fa.BlackChirpFid.from_binary(fidfile))
time_data = dict()
tdt_file = glob(os.path.join(dir_path, "*.tdt"))
try:
tdt_file = tdt_file[0]
except IndexError:
raise Exception("Time stamp data is missing!")
with open(tdt_file) as tdt:
look_for_header = True
header_list = []
for line in tdt:
print(line)
if line.strip() == "":
continue
if line.startswith("#") and "PlotData" in line:
look_for_header = True
header_list = []
continue
if line.startswith("#"):
continue
l = line.split("\t")
if len(l) < 1:
continue
if look_for_header is True:
for i in range(0, len(l)):
name = ""
l2 = str(l[i]).split("_")
for j in range(0, len(l2) - 1):
name += str(l2[j]).strip()
time_data[name] = []
header_list.append(name)
look_for_header = False
else:
for i in range(0, len(l)):
time_data[header_list[i]].append(str(l[i]).strip())
return exp_id, header, fid_list, time_data
def read_binary_fid(filepath):
"""
Read in a binary Blackchirp FID file. This is based on the original code by Kyle Crabtree, with some minor
perfomance improvements by Kelvin Lee. The only difference is most of the for loops for reading the points
have been replaced by numpy broadcasts.
Parameters
----------
filepath - str
Filepath to the Blackchirp .fid file
Returns
-------
param_dict - dict
Contains header information about the FID, such as the number of shots, point spacing, etc.
xy_data - 2-tuple of numpy 1D array
Contains two columns; xy_data[0] is the time data in microseconds, and xy_data[1] is the
signal.
raw_data - numpy 1D array
Contains the raw, uncorrected ADC sums. The signal data is converted from this by scaling
it with the multiplication factor v_mult.
"""
with open(filepath) as read_file:
read_str = ">3dqHbI"
d = struct.unpack(read_str, read_file.read(struct.calcsize(read_str)))
spacing = d[0] * 1e6
probe_freq = d[1]
v_mult = d[2]
shots = d[3]
if d[4] == 1:
sideband = -1.0
else:
sideband = 1.0
point_size = d[5]
size = d[6]
param_dict = {
"spacing": spacing,
"probe_freq": probe_freq,
"v_mult": v_mult,
"shots": shots,
"point_size": point_size,
"size": size,
"sideband": sideband,
}
if point_size == 2:
read_string = ">" + str(size) + "h"
dat = struct.unpack(
read_string, read_file.read(struct.calcsize(read_string))
)
elif point_size == 3:
for i in range(0, size):
chunk = read_file.read(3)
dat = struct.unpack(
">i", (b"\0" if chunk[0] < 128 else b"\xff") + chunk
)[0]
elif point_size == 4:
read_string = ">" + str(size) + "i"
dat = struct.unpack(
read_string, read_file.read(struct.calcsize(read_string))
)
elif point_size == 8:
read_string = ">" + str(size) + "q"
dat = struct.unpack(
read_string, read_file.read(struct.calcsize(read_string))
)
else:
raise ValueError("Invalid point size: " + str(point_size))
# Now read in the data with broadcasting
raw_data = np.array(dat[:size])
data = raw_data * v_mult / shots
x_data = np.linspace(0.0, size * spacing, int(size))
xy_data = np.vstack((x_data, data))
return param_dict, xy_data, raw_data
def parse_fit(filepath):
"""
Function to parse the output of an SPFIT .fit file. This version of the code is barebones compared to the
previous iteration, which provides more feedback. This version simply returns a dictionary containing the
obs - calc for each line, the fitted parameters, and the microwave RMS.
Parameters
----------
filepath: str
Filepath to the .fit file to parse.
Returns
-------
fit_dict: dict
Dictionary containing the parsed data.
"""
fit_dict = {"o-c": {}, "parameters": {}, "rms": None}
with open(filepath) as read_file:
lines = read_file.readlines()
for index, line in enumerate(lines):
# Read the obs - calc on individual lines
if "EXP.FREQ." in line:
stop_flag = False
entry_index = 1
line_dict = dict()
while stop_flag is False:
entry = lines[index + entry_index].split()
if entry[0] == "NORMALIZED" or entry[0] == "Fit":
stop_flag = True
elif entry[1] == "NEXT" or entry[1] == "Lines":
entry_index += 1
pass
else:
# Read in the line information
line_dict[entry_index] = {
"o-c": float(entry[-3]),
"qnos": entry[1:-5],
"frequency": entry[-5],
}
entry_index += 1
if "NEW PARAMETER" in line:
stop_flag = False
entry_index = 1
param_dict = dict()
while stop_flag is False:
entry = lines[index + entry_index]
for bracket in ["""(""", """)"""]:
entry = entry.replace(bracket, " ")
entry = entry.split()
if entry[0] != "MICROWAVE":
coding = int(entry[1])
param_dict[coding] = float(entry[-3])
entry_index += 1
else:
stop_flag = True
if "MICROWAVE RMS" in line:
fit_dict["microwave_rms"] = float(line.split()[3])
if "NEW RMS ERROR" in line:
fit_dict["rms"] = float(line.split()[-2])
fit_dict["o-c"] = line_dict
fit_dict["parameters"] = param_dict
return fit_dict
| [
11748,
28686,
198,
11748,
2878,
198,
6738,
15095,
1330,
15095,
198,
198,
11748,
19798,
292,
355,
279,
67,
198,
11748,
299,
32152,
355,
45941,
198,
198,
6738,
279,
893,
806,
10141,
1330,
10117,
76,
86,
62,
20930,
355,
24685,
628,
198,
... | 2.008308 | 5,898 |