diff --git a/.coveragerc b/.coveragerc index 279183f..58f7a9a 100644 --- a/.coveragerc +++ b/.coveragerc @@ -8,5 +8,6 @@ omit = */_version.py exclude_lines = pragma: no cover + -no-cov- def __repr__ raise NotImplementedError diff --git a/.gitignore b/.gitignore index b527366..8e4d4e7 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,7 @@ dask-worker-space # netcdf outputs *nc +.pytest_cache contact_map/version.py cover diff --git a/.travis.yml b/.travis.yml index 59b67c7..9c66969 100644 --- a/.travis.yml +++ b/.travis.yml @@ -42,7 +42,7 @@ install: - pip list script: - - export MPLBACKEND=PS + - export MPLBACKEND=SVG - python -c "import contact_map" - python autorelease_check.py --branch ${TRAVIS_BRANCH} --event ${TRAVIS_EVENT_TYPE} --allow-patch-skip #TODO remove allow-patch-skip - py.test -vv --cov=contact_map --cov-report xml:cov.xml diff --git a/ci/conda-recipe/meta.yaml b/ci/conda-recipe/meta.yaml index d41dd42..51a4275 100644 --- a/ci/conda-recipe/meta.yaml +++ b/ci/conda-recipe/meta.yaml @@ -1,7 +1,7 @@ package: name: contact_map # add ".dev0" for unreleased versions - version: "0.3.3" + version: "0.4.0" source: path: ../../ diff --git a/contact_map/__init__.py b/contact_map/__init__.py index 96a24f9..b46f5b6 100644 --- a/contact_map/__init__.py +++ b/contact_map/__init__.py @@ -13,8 +13,11 @@ from .min_dist import NearestAtoms, MinimumDistanceCounter +from .concurrence import ( + Concurrence, AtomContactConcurrence, ResidueContactConcurrence, + ConcurrencePlotter, plot_concurrence +) + from .dask_runner import DaskContactFrequency from . import plot_utils - -# import concurrence diff --git a/contact_map/concurrence.py b/contact_map/concurrence.py new file mode 100644 index 0000000..d6bba3e --- /dev/null +++ b/contact_map/concurrence.py @@ -0,0 +1,292 @@ +import itertools +import mdtraj as md +import numpy as np + +import contact_map +from .contact_map import ContactObject + +try: + import matplotlib.pyplot as plt +except ImportError: + HAS_MATPLOTLIB = False +else: + HAS_MATPLOTLIB = True + + +class Concurrence(object): + """Superclass for contact concurrence objects. + + Contact concurrences measure what contacts occur simultaneously in a + trajectory. When defining states, one usually wants to characterize + based on multiple contacts that are made simultaneously; contact + concurrences makes it easier to identify those. + + Parameters + ---------- + values : list of list of bool + the whether a contact is present for each contact pair at each + point in time; inner list is length number of frames, outer list + in length number of (included) contacts + labels : list of string + labels for each contact pair + """ + def __init__(self, values, labels=None): + self.values = values + self.labels = labels + + # @property + # def lifetimes(self): + # pass + + def set_labels(self, labels): + """Set the contact labels + + Parameters + ---------- + labels : list of string + labels for each contact pair + """ + self.labels = labels + + def __getitem__(self, label): + idx = self.labels.index(label) + return self.values[idx] + + # temporarily removed until we find a good metric here; this metric did + # not seem optimal and I stopped using it, so remove from code before + # release (can add back in later) + # def coincidence(self, label_list): + # this_list = np.asarray(self[label_list[0]]) + # coincidence_list = this_list + # norm_sq = sum(this_list) + # for label in label_list[1:]: + # this_list = np.asarray(self[label]) + # coincidence_list &= this_list + # norm_sq *= sum(this_list) + + # return sum(coincidence_list) / np.sqrt(norm_sq) + +def _regularize_contact_input(contact_input, atom_or_res): + """Clean input for concurrence objects. + + The allowed inputs are the :class:`.ContactFrequency`, or the + :class:`.ContactObject` coming from the ``.atom_contacts`` or + ``.residue_contacts`` attribute of the contact frequency, or the list + coming from the ``.most_common()`` method for the + :class:`.ContactObject`. + + Parameters + ---------- + contact_input : many possible types; see method description + input to the contact concurrences + atom_or_res : string + whether to treat this as an atom-based or residue-based contact; + allowed values are "atom", "res", and "residue" + + Returns + ------- + list : + list in the format of ``ContactCount.most_common()`` + """ + if isinstance(contact_input, ContactObject): + contact_input = contact_input.contacts[atom_or_res] + + if isinstance(contact_input, contact_map.ContactCount): + contact_input = contact_input.most_common() + + return contact_input + + +class AtomContactConcurrence(Concurrence): + """Contact concurrences for atom contacts. + + Parameters + ---------- + trajectory : :class:`mdtraj.Trajectory` + the trajectory to analyze + atom_contacts : list + output from ``contact_map.atom_contacts.most_common()`` + cutoff : float + cutoff, in nm. Should be the same as used in the contact map. + """ + def __init__(self, trajectory, atom_contacts, cutoff=0.45): + atom_contacts = _regularize_contact_input(atom_contacts, "atom") + atom_pairs = [[contact[0][0].index, contact[0][1].index] + for contact in atom_contacts] + labels = [str(contact[0]) for contact in atom_contacts] + distances = md.compute_distances(trajectory, atom_pairs=atom_pairs) + vector_f = np.vectorize(lambda d: d < cutoff) + # transpose because distances is ndarray shape (n_frames, + # n_contacts); values should be list shape (n_contacts, n_frames) + values = vector_f(distances).T.tolist() + super(AtomContactConcurrence, self).__init__(values=values, + labels=labels) + + +class ResidueContactConcurrence(Concurrence): + """Contact concurrences for residue contacts. + + Parameters + ---------- + trajectory : :class:`mdtraj.Trajectory` + the trajectory to analyze + residue_contacts : list + output from ``contact_map.residue_contacts.most_common()`` + cutoff : float + cutoff, in nm. Should be the same as used in the contact map. + select : string + additional atom selection string for MDTraj; defaults to "and symbol + != 'H'" + """ + def __init__(self, trajectory, residue_contacts, cutoff=0.45, + select="and symbol != 'H'"): + residue_contacts = _regularize_contact_input(residue_contacts, + "residue") + residue_pairs = [[contact[0][0], contact[0][1]] + for contact in residue_contacts] + labels = [str(contact[0]) for contact in residue_contacts] + values = [] + select_residue = lambda idx: trajectory.topology.select( + "resid " + str(idx) + " " + select + ) + for res_A, res_B in residue_pairs: + atoms_A = select_residue(res_A.index) + atoms_B = select_residue(res_B.index) + atom_pairs = itertools.product(atoms_A, atoms_B) + distances = md.compute_distances(trajectory, + atom_pairs=atom_pairs) + min_dists = [min(dists) for dists in distances] + values.append([d < cutoff for d in min_dists]) + + super(ResidueContactConcurrence, self).__init__(values=values, + labels=labels) + + +class ConcurrencePlotter(object): + """Plot manager for contact concurrences. + + Parameters + ---------- + concurrence : :class:`.Concurrence` + concurrence to plot; default None allows to override later + labels : list of string + labels for the contact pairs, default None will use concurrence + labels if available, integers if not + x_values : list of numeric + values to use for the time axis; default None uses integers starting + at 0 (can be used to assign the actual simulation time to the + x-axis) + """ + def __init__(self, concurrence=None, labels=None, x_values=None): + self.concurrence = concurrence + self.labels = self.get_concurrence_labels(concurrence, labels) + self._x_values = x_values + + @staticmethod + def get_concurrence_labels(concurrence, labels=None): + """Extract labels for contact from a concurrence object + + If ``labels`` is given, that is returned. Otherwise, the + ``concurrence`` is checked for labels, and those are used. If those + are also not available, string forms of integers starting with 0 are + returned. + + + Parameters + ---------- + concurrence : :class:`.Concurrence` + concurrence, which may have label information + labels : list of string + labels to use for contacts (optional) + + Returns + ------- + list of string + labels to use for contacts + """ + if labels is None: + if concurrence and concurrence.labels is not None: + labels = concurrence.labels + else: + labels = [str(i) for i in range(len(concurrence.values))] + return labels + + @property + def x_values(self): + """list : values to use for the x-axis (time)""" + x_values = self._x_values + if x_values is None: + x_values = list(range(len(self.concurrence.values[0]))) + return x_values + + @x_values.setter + def x_values(self, x_values): + self._x_values = x_values + + def plot(self, concurrence=None, **kwargs): + """Contact concurrence plot based on matplotlib + + Additional kwargs given here will be passed to the matplotlib + ``Axes.plot()`` method. + + Parameters + ---------- + concurrence : :class:`.Concurrence` + optional; default None uses ``self.concurrence``; this allows + one to override the use of ``self.concurrence`` + + Returns + ------- + fig : :class:`.matplotlib.Figure` + ax : :class:`.matplotlib.Axes` + lgd: :class:`.matplotlib.legend.Legend` + objects for matplotlib-based plot of contact concurrences + """ + if not HAS_MATPLOTLIB: # pragma: no cover + raise ImportError("matplotlib not installed") + if concurrence is None: + concurrence = self.concurrence + labels = self.get_concurrence_labels(concurrence=concurrence) + x_values = self.x_values + + fig = plt.figure(1) + ax = fig.add_subplot(111) + + plot_kwargs = {'markersize': 1} + plot_kwargs.update(kwargs) + + y_val = -1.0 + for label, val_set in zip(labels, concurrence.values): + x_vals = [x for (x, y) in zip(x_values, val_set) if y] + ax.plot(x_vals, [y_val] * len(x_vals), '.', label=label, + **plot_kwargs) + y_val -= 1.0 + + ax.set_ylim(top=0.0) + ax.set_xlim(left=min(x_values), right=max(x_values)) + ax.set_yticks([]) + lgd = ax.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.) + return (fig, ax, lgd) + + +def plot_concurrence(concurrence, labels=None, x_values=None, **kwargs): # -no-cov- + """ + Convenience function for concurrence plots. + + Additional kwargs given here will be passed to the matplotlib + ``Axes.plot()`` method. + + Parameters + ---------- + concurrence : :class:`.Concurrence` + concurrence to be plotted + labels: list of string + labels for contacts (optional) + x_values : list of float or list of int + values to use for the x-axis + + See also + -------- + :class:`.ConcurrencePlotter` + """ + return ConcurrencePlotter(concurrence, labels, x_values).plot(**kwargs) diff --git a/contact_map/contact_count.py b/contact_map/contact_count.py index d0876cf..c9beb2e 100644 --- a/contact_map/contact_count.py +++ b/contact_map/contact_count.py @@ -1,7 +1,7 @@ import scipy import numpy as np import pandas as pd - +import warnings from .plot_utils import ranged_colorbar # matplotlib is technically optional, but required for plotting @@ -13,6 +13,7 @@ else: HAS_MATPLOTLIB = True + def _colorbar(with_colorbar, cmap_f, norm, min_val): if with_colorbar is False: return None @@ -23,6 +24,7 @@ def _colorbar(with_colorbar, cmap_f, norm, min_val): # leave open other inputs to be parsed later (like tuples) return cb + class ContactCount(object): """Return object when dealing with contacts (residue or atom). @@ -98,7 +100,39 @@ def df(self): columns = list(range(self.n_y)) return pd.SparseDataFrame(mtx, index=index, columns=columns) - def plot(self, cmap='seismic', vmin=-1.0, vmax=1.0, with_colorbar=True): + def _check_number_of_pixels(self, figure): + """ + This checks to see if the number of pixels in the figure is high enough + to accuratly represent the the contact map. It raises a RuntimeWarning + if this is not the case. + + Parameters + ---------- + figure: :class:`matplotlib.Figure` + matplotlib figure to compare the amount of pixels from + + """ + # Get dpi, and total pixelswidht and pixelheight + dpi = figure.get_dpi() + figwidth = figure.get_figwidth() + figheight = figure.get_figheight() + xpixels = dpi*figwidth + ypixels = dpi*figheight + + # Check if every value has a pixel + if xpixels/self.n_x < 1 or ypixels/self.n_y < 1: + msg = ("The number of pixels in the figure is insufficient to show" + " all the contacts.\n Please save this as a vector image " + "(such as a PDF) to view the correct result.\n Another " + "option is to increase the 'dpi' (currently: "+str(dpi)+")," + " or the 'figsize' (currently: " + str((figwidth, + figheight)) + + ").\n Recommended minimum amount of pixels = " + + str((self.n_x, self.n_y))+" (width, height).") + warnings.warn(msg, RuntimeWarning) + + def plot(self, cmap='seismic', vmin=-1.0, vmax=1.0, with_colorbar=True, + **kwargs): """ Plot contact matrix (requires matplotlib) @@ -110,7 +144,9 @@ def plot(self, cmap='seismic', vmin=-1.0, vmax=1.0, with_colorbar=True): minimum value for color map interpolation; default -1.0 vmax : float maximum value for color map interpolation; default 1.0 - + **kwargs + All additional keyword arguments to be passed to the + :func:`matplotlib.pyplot.subplots` call Returns ------- fig : :class:`matplotlib.Figure` @@ -123,12 +159,15 @@ def plot(self, cmap='seismic', vmin=-1.0, vmax=1.0, with_colorbar=True): norm = matplotlib.colors.Normalize(vmin=vmin, vmax=vmax) cmap_f = plt.get_cmap(cmap) - fig, ax = plt.subplots() + fig, ax = plt.subplots(**kwargs) ax.axis([0, self.n_x, 0, self.n_y]) ax.set_facecolor(cmap_f(norm(0.0))) min_val = 0.0 + # Check the number of pixels of the figure + self._check_number_of_pixels(fig) + for (pair, value) in self.counter.items(): if value < min_val: min_val = value diff --git a/contact_map/contact_map.py b/contact_map/contact_map.py index c0b66a1..7c145f1 100644 --- a/contact_map/contact_map.py +++ b/contact_map/contact_map.py @@ -21,6 +21,7 @@ # query atom. Doesn't look like anything is doing that now: neighbors # doesn't use voxels, neighborlist doesn't limit the haystack + def residue_neighborhood(residue, n=1): """Find n nearest neighbor residues @@ -42,6 +43,7 @@ def residue_neighborhood(residue, n=1): # good, and it only gets run once per residue return [idx for idx in neighborhood if idx in chain] + def _residue_and_index(residue, topology): res = residue try: @@ -52,6 +54,68 @@ def _residue_and_index(residue, topology): return (res, res_idx) +def _atom_slice(traj, indices): + """Mock MDTraj.atom_slice without rebuilding topology""" + xyz = np.array(traj.xyz[:, indices], order='C') + topology = traj.topology.copy() + if traj._have_unitcell: + unitcell_lengths = traj._unitcell_lengths.copy() + unitcell_angles = traj._unitcell_angles.copy() + time = traj._time.copy() + + # Hackish to make the smart slicing work + topology._atoms = indices + topology._numAtoms = len(indices) + return md.Trajectory(xyz=xyz, topology=topology, time=time, + unitcell_lengths=unitcell_lengths, + unitcell_angles=unitcell_angles) + + +def _residue_for_atom(topology, atom_list): + return set([topology.atom(a).residue for a in atom_list]) + + +def _range_from_object_list(object_list): + """ + Objects must have .index attribute (e.g., MDTraj Residue/Atom) + """ + idxs = [obj.index for obj in object_list] + return (min(idxs), max(idxs) + 1) + + +class ContactsDict(object): + """Dict-like object giving access to atom or residue contacts. + + In some algorithmic situations, either the atom_contacts or the + residue_contacts might be used. Rather than use lots of if-statements, + or build an actual dictionary with the associated time cost of + generating both, this class provides an object that allows dict-like + access to either the atom or residue contacts. + + Atom-based contacts (``contact.atom_contacts``) can be accessed with as + ``contact_dict['atom']`` or ``contact_dict['atoms']``. Residue-based + contacts can be accessed with the keys ``'residue'``, ``'residues'``, or + ``'res'``. + + Parameters + ---------- + contacts : :class:`.ContactObject` + contact object with fundamental data + """ + def __init__(self, contacts): + self.contacts = contacts + + def __getitem__(self, atom_or_res): + if atom_or_res in ["atom", "atoms"]: + contacts = self.contacts.atom_contacts + elif atom_or_res in ["residue", "residues", "res"]: + contacts = self.contacts.residue_contacts + else: + raise RuntimeError("Bad value for atom_or_res: " + + str(atom_or_res)) + return contacts + + class ContactObject(object): """ Generic object for contact map related analysis. Effectively abstract. @@ -59,21 +123,96 @@ class ContactObject(object): Much of what we need to do the contact map analysis is the same for all analyses. It's in here. """ + + # Class default for use atom slice, None tries to be smart + _class_use_atom_slice = None + def __init__(self, topology, query, haystack, cutoff, n_neighbors_ignored): # all inits required: no defaults for abstract class! + self._topology = topology if query is None: query = topology.select("not water and symbol != 'H'") if haystack is None: haystack = topology.select("not water and symbol != 'H'") + # make things private and accessible through read-only properties so # they don't get accidentally changed after analysis self._cutoff = cutoff self._query = set(query) self._haystack = set(haystack) + + # Make tuple for efficient lookupt + all_atoms_set = set(query).union(set(haystack)) + all_atoms_list = list(all_atoms_set) + all_atoms_list.sort() + self._all_atoms = tuple(all_atoms_list) + + self._use_atom_slice = self._set_atom_slice() + + # Set up the conversion dict to go from aton index to sliced indexes + self._idx_to_s_idx_dict = {e: i for + i, e in enumerate(self._all_atoms)} + + # Get the sliced and used haystack indices + self._s_haystack = set(map(self.idx_to_s_idx, self._haystack)) + self._u_haystack = self._set_used_haystack() self._n_neighbors_ignored = n_neighbors_ignored - self._atom_idx_to_residue_idx = {atom.index: atom.residue.index - for atom in self.topology.atoms} + + # Conversion dicts between the real and sliced atoms and their residues + self._r_atom_idx_to_residue_idx = {atom.index: atom.residue.index + for atom in self.topology.atoms} + self._s_atom_idx_to_residue_idx = { + i: self._r_atom_idx_to_residue_idx[e] for + i, e in enumerate(self._all_atoms) + } + self._atom_idx_to_residue_idx = self._set_atom_idx_to_residue_idx() + + def _set_atom_slice(self): + """ Set atom slice logic """ + if (self._class_use_atom_slice is None and + not len(self._all_atoms) < self._topology.n_atoms): + # Don't use if there are no atoms to be sliced + return False + elif self._class_use_atom_slice is None: + # Use if there are atms to be sliced + return True + else: + # Use class default + return self._class_use_atom_slice + + def _set_used_haystack(self): + """set which haystack to use in contact map""" + if self._use_atom_slice: + return self._s_haystack + else: + return self._haystack + + def _set_atom_idx_to_residue_idx(self): + """set which atom index to residue index is used""" + if self._use_atom_slice: + return self._s_atom_idx_to_residue_idx + else: + return self._r_atom_idx_to_residue_idx + + def s_idx_to_idx(self, idx): + """function to convert a sliced atom index back to real index""" + if self._use_atom_slice: + return self._all_atoms[idx] + else: + return idx + + def idx_to_s_idx(self, idx): + """function to convert a real atom index to a sliced one""" + if self._use_atom_slice: + return self._idx_to_s_idx_dict[idx] + else: + return idx + + @property + def contacts(self): + """:class:`.ContactsDict` : contact dict for these contacts""" + return ContactsDict(self) def __hash__(self): return hash((self.cutoff, self.n_neighbors_ignored, @@ -103,13 +242,15 @@ def to_dict(self): 'cutoff': self._cutoff, 'query': list([int(val) for val in self._query]), 'haystack': list([int(val) for val in self._haystack]), + 'all_atoms': tuple( + [int(val) for val in self._all_atoms]), 'n_neighbors_ignored': self._n_neighbors_ignored, 'atom_idx_to_residue_idx': self._atom_idx_to_residue_idx, 'atom_contacts': \ self._serialize_contact_counter(self._atom_contacts), 'residue_contacts': \ - self._serialize_contact_counter(self._residue_contacts) - } + self._serialize_contact_counter(self._residue_contacts), + 'use_atom_slice': self._use_atom_slice} return dct @classmethod @@ -133,6 +274,7 @@ def from_dict(cls, dct): 'residue_contacts': cls._deserialize_contact_counter, 'query': deserialize_set, 'haystack': deserialize_set, + 'all_atoms': deserialize_set, 'atom_idx_to_residue_idx': deserialize_atom_to_residue_dct } for key in deserialization_helpers: @@ -291,6 +433,11 @@ def haystack(self): """list of int : indices of atoms to include as haystack""" return list(self._haystack) + @property + def all_atoms(self): + """list of int: all atom indices used in the contact map""" + return list(self._all_atoms) + @property def topology(self): """ @@ -303,22 +450,27 @@ def topology(self): """ return self._topology + @property + def use_atom_slice(self): + """bool : Indicates if `mdtraj.atom_slice()` is used before calculating + the contact map""" + return self._use_atom_slice + @property def residue_query_atom_idxs(self): """dict : maps query residue index to atom indices in query""" - result = {} + result = collections.defaultdict(list) for atom_idx in self._query: - residue_idx = self.topology.atom(atom_idx).residue.index - try: - result[residue_idx] += [atom_idx] - except KeyError: - result[residue_idx] = [atom_idx] + residue_idx = self._r_atom_idx_to_residue_idx[atom_idx] + if self.use_atom_slice: + atom_idx = self._idx_to_s_idx_dict[atom_idx] + result[residue_idx].append(atom_idx) return result - @property def residue_ignore_atom_idxs(self): """dict : maps query residue index to atom indices to ignore""" + all_atoms_set = set(self._all_atoms) result = {} for residue_idx in self.residue_query_atom_idxs.keys(): residue = self.topology.residue(residue_idx) @@ -331,10 +483,38 @@ def residue_ignore_atom_idxs(self): for idx in ignore_residue_idxs] ignore_atoms = sum([list(res.atoms) for res in ignore_residues], []) - ignore_atom_idxs = set([atom.index for atom in ignore_atoms]) + ignore_atom_idxs = self._ignore_atom_idx(ignore_atoms, + all_atoms_set) result[residue_idx] = ignore_atom_idxs return result + def _ignore_atom_idx(self, atoms, all_atoms_set): + result = set([atom.index for atom in atoms]) + if self._use_atom_slice: + result &= all_atoms_set + result = set(map(self.idx_to_s_idx, result)) + return result + + @property + def haystack_residues(self): + """list : residues for atoms in the haystack""" + return _residue_for_atom(self.topology, self.haystack) + + @property + def query_residues(self): + """list : residues for atoms in the query""" + return _residue_for_atom(self.topology, self.query) + + @property + def haystack_residue_range(self): + """(int, int): min and (max + 1) of haystack residue indices""" + return _range_from_object_list(self.haystack_residues) + + @property + def query_residue_range(self): + """(int, int): min and (max + 1) of query residue indices""" + return _range_from_object_list(self.query_residues) + def most_common_atoms_for_residue(self, residue): """ Most common atom contact pairs for contacts with the given residue @@ -398,6 +578,16 @@ def most_common_atoms_for_contact(self, contact_pair): if frozenset(contact[0]) in all_atom_pairs] return result + def slice_trajectory(self, trajectory): + # Prevent (memory) expensive atom slicing if not needed. + # This check is also needed here because ContactFrequency slices the + # whole trajectory before calling this function. + if self.use_atom_slice and (len(self._all_atoms) < + trajectory.topology.n_atoms): + sliced_trajectory = _atom_slice(trajectory, self._all_atoms) + else: + sliced_trajectory = trajectory + return sliced_trajectory def contact_map(self, trajectory, frame_number, residue_query_atom_idxs, residue_ignore_atom_idxs): @@ -416,8 +606,11 @@ def contact_map(self, trajectory, frame_number, residue_query_atom_idxs, atom_contacts : collections.Counter residue_contact : collections.Counter """ - neighborlist = md.compute_neighborlist(trajectory, self.cutoff, + used_trajectory = self.slice_trajectory(trajectory) + + neighborlist = md.compute_neighborlist(used_trajectory, self.cutoff, frame_number) + contact_pairs = set([]) residue_pairs = set([]) for residue_idx in residue_query_atom_idxs: @@ -428,7 +621,7 @@ def contact_map(self, trajectory, frame_number, residue_query_atom_idxs, # should be small and s-t is avg cost len(s) neighbor_idxs = set(neighborlist[atom_idx]) contact_neighbors = neighbor_idxs - ignore_atom_idxs - contact_neighbors = contact_neighbors & self._haystack + contact_neighbors = contact_neighbors & self._u_haystack # frozenset is unique key independent of order # local_pairs = set(frozenset((atom_idx, neighb)) # for neighb in contact_neighbors) @@ -455,6 +648,14 @@ def contact_map(self, trajectory, frame_number, residue_query_atom_idxs, residue_contacts = collections.Counter(residue_pairs) return (atom_contacts, residue_contacts) + def convert_atom_contacts(self, atom_contacts): + if self._use_atom_slice: + result = {frozenset(tuple(map(self.s_idx_to_idx, key))): value + for key, value in atom_contacts.items()} + return collections.Counter(result) + else: + return atom_contacts + @property def atom_contacts(self): n_atoms = self.topology.n_atoms @@ -472,15 +673,21 @@ class ContactMap(ContactObject): """ Contact map (atomic and residue) for a single frame. """ + # Default for use_atom_slice, None tries to be smart + _class_use_atom_slice = None + def __init__(self, frame, query=None, haystack=None, cutoff=0.45, n_neighbors_ignored=2): + self._frame = frame # TODO: remove this? super(ContactMap, self).__init__(frame.topology, query, haystack, cutoff, n_neighbors_ignored) + contact_maps = self.contact_map(frame, 0, self.residue_query_atom_idxs, self.residue_ignore_atom_idxs) - (self._atom_contacts, self._residue_contacts) = contact_maps + (atom_contacts, self._residue_contacts) = contact_maps + self._atom_contacts = self.convert_atom_contacts(atom_contacts) def __hash__(self): return hash((super(ContactMap, self).__hash__(), @@ -518,7 +725,12 @@ class ContactFrequency(ContactObject): n_neighbors_ignored : int Number of neighboring residues (in the same chain) to ignore. Default 2. + frames : list of int + The indices of the frames to use from the trajectory. Default all """ + # Default for use_atom_slice, None tries to be smart + _class_use_atom_slice = None + def __init__(self, trajectory, query=None, haystack=None, cutoff=0.45, n_neighbors_ignored=2, frames=None): if frames is None: @@ -563,8 +775,10 @@ def _build_contact_map(self, trajectory): # (namely, which atom indices matter for each residue) residue_ignore_atom_idxs = self.residue_ignore_atom_idxs residue_query_atom_idxs = self.residue_query_atom_idxs + + used_trajectory = self.slice_trajectory(trajectory) for frame_num in self.frames: - frame_contacts = self.contact_map(trajectory, frame_num, + frame_contacts = self.contact_map(used_trajectory, frame_num, residue_query_atom_idxs, residue_ignore_atom_idxs) frame_atom_contacts = frame_contacts[0] @@ -572,7 +786,7 @@ def _build_contact_map(self, trajectory): # self._atom_contacts_count += frame_atom_contacts atom_contacts_count.update(frame_atom_contacts) residue_contacts_count += frame_residue_contacts - + atom_contacts_count = self.convert_atom_contacts(atom_contacts_count) return (atom_contacts_count, residue_contacts_count) @property @@ -594,7 +808,6 @@ def add_contact_frequency(self, other): self._residue_contacts += other._residue_contacts self._n_frames += other._n_frames - def subtract_contact_frequency(self, other): """Subtracts results from `other` from internal counter. diff --git a/contact_map/dask_runner.py b/contact_map/dask_runner.py index 8fbd777..66fd473 100644 --- a/contact_map/dask_runner.py +++ b/contact_map/dask_runner.py @@ -39,6 +39,7 @@ def dask_run(trajectory, client, run_info): return freq.result() + class DaskContactFrequency(ContactFrequency): """Dask-based parallelization of contact frequency. @@ -87,7 +88,7 @@ def __init__(self, client, filename, query=None, haystack=None, self.kwargs = kwargs super(DaskContactFrequency, self).__init__( - trajectory, query, haystack, cutoff, n_neighbors_ignored + trajectory, query, haystack, cutoff, n_neighbors_ignored, ) def _build_contact_map(self, trajectory): @@ -107,5 +108,3 @@ def run_info(self): return {'parameters': self.parameters, 'trajectory_file': self.filename, 'load_kwargs': self.kwargs} - - diff --git a/contact_map/tests/concurrence.pdb b/contact_map/tests/concurrence.pdb new file mode 100644 index 0000000..e13a682 --- /dev/null +++ b/contact_map/tests/concurrence.pdb @@ -0,0 +1,67 @@ +REMARK 225 HAND-WRITTEN TEST TRAJECTORY +REMARK 225 COMMENTS HERE COUNT FROM 1 (CODE COUNTS FROM 0, PDB FROM 1) +REMARK 225 SYSTEM CONSISTS OF TWO CHAINS: A TWO-RESIDUE "PROTEIN" (CHAIN A) +REMARK 225 AND A "LIGAND" (CHAIN B). +REMARK 225 IN FRAMES 1, 2 AND 5, THE PROTEIN IS IN THE SAME CONFIGURATION +REMARK 225 * FRAME 1 +REMARK 225 * FRAME 2 +REMARK 225 * FRAME 3 +REMARK 225 * FRAME 4 +REMARK 225 * FRAME 5 +REMARK 225 +CRYST1 25.000 25.000 25.000 90.00 90.00 90.00 P 1 1 +HETATM 1 C1 AAA A 1 0.250 2.250 0.000 1.00 0.00 C +HETATM 2 C2 AAA A 1 0.250 1.750 0.000 1.00 0.00 C +HETATM 3 H AAA A 1 0.250 2.750 0.000 1.00 0.00 H +HETATM 4 C1 BBB A 2 0.250 0.750 0.000 1.00 0.00 C +HETATM 5 C2 BBB A 2 0.250 1.250 0.000 1.00 0.00 C +HETATM 6 H BBB A 2 0.250 0.250 0.000 1.00 0.00 H +HETATM 7 C1 LLL B 3 0.750 1.750 0.000 1.00 0.00 C +HETATM 8 C2 LLL B 3 0.750 1.250 0.000 1.00 0.00 C +HETATM 9 H LLL B 3 1.250 1.750 0.000 1.00 0.00 H +ENDMDL +CRYST1 25.000 25.000 25.000 90.00 90.00 90.00 P 1 1 +HETATM 1 C1 AAA A 1 0.250 2.250 0.000 1.00 0.00 C +HETATM 2 C2 AAA A 1 0.250 1.750 0.000 1.00 0.00 C +HETATM 3 H AAA A 1 0.250 2.750 0.000 1.00 0.00 H +HETATM 4 C1 BBB A 2 0.250 0.750 0.000 1.00 0.00 C +HETATM 5 C2 BBB A 2 0.250 1.250 0.000 1.00 0.00 C +HETATM 6 H BBB A 2 0.250 0.250 0.000 1.00 0.00 H +HETATM 7 C1 LLL B 3 0.750 2.250 0.000 1.00 0.00 C +HETATM 8 C2 LLL B 3 0.750 1.750 0.000 1.00 0.00 C +HETATM 9 H LLL B 3 1.250 2.250 0.000 1.00 0.00 H +ENDMDL +CRYST1 25.000 25.000 25.000 90.00 90.00 90.00 P 1 1 +HETATM 1 C1 AAA A 1 0.250 2.250 0.000 1.00 0.00 C +HETATM 2 C2 AAA A 1 0.250 1.750 0.000 1.00 0.00 C +HETATM 3 H AAA A 1 0.750 2.250 0.000 1.00 0.00 H +HETATM 4 C1 BBB A 2 0.250 0.750 0.000 1.00 0.00 C +HETATM 5 C2 BBB A 2 0.250 1.250 0.000 1.00 0.00 C +HETATM 6 H BBB A 2 0.250 0.250 0.000 1.00 0.00 H +HETATM 7 C1 LLL B 3 1.750 2.250 0.000 1.00 0.00 C +HETATM 8 C2 LLL B 3 1.750 1.750 0.000 1.00 0.00 C +HETATM 9 H LLL B 3 1.250 2.250 0.000 1.00 0.00 H +ENDMDL +CRYST1 25.000 25.000 25.000 90.00 90.00 90.00 P 1 1 +HETATM 1 C1 AAA A 1 0.250 2.250 0.000 1.00 0.00 C +HETATM 2 C2 AAA A 1 0.250 1.750 0.000 1.00 0.00 C +HETATM 3 H AAA A 1 0.750 2.250 0.000 1.00 0.00 H +HETATM 4 C1 BBB A 2 1.250 1.250 0.000 1.00 0.00 C +HETATM 5 C2 BBB A 2 0.750 1.250 0.000 1.00 0.00 C +HETATM 6 H BBB A 2 1.750 1.250 0.000 1.00 0.00 H +HETATM 7 C1 LLL B 3 1.750 2.250 0.000 1.00 0.00 C +HETATM 8 C2 LLL B 3 1.750 1.750 0.000 1.00 0.00 C +HETATM 9 H LLL B 3 1.250 2.250 0.000 1.00 0.00 H +ENDMDL +CRYST1 25.000 25.000 25.000 90.00 90.00 90.00 P 1 1 +HETATM 1 C1 AAA A 1 0.250 2.250 0.000 1.00 0.00 C +HETATM 2 C2 AAA A 1 0.250 1.750 0.000 1.00 0.00 C +HETATM 3 H AAA A 1 0.250 2.750 0.000 1.00 0.00 H +HETATM 4 C1 BBB A 2 0.250 0.750 0.000 1.00 0.00 C +HETATM 5 C2 BBB A 2 0.250 1.250 0.000 1.00 0.00 C +HETATM 6 H BBB A 2 0.250 0.250 0.000 1.00 0.00 H +HETATM 7 C1 LLL B 3 1.250 2.250 0.000 1.00 0.00 C +HETATM 8 C2 LLL B 3 1.250 1.750 0.000 1.00 0.00 C +HETATM 9 H LLL B 3 1.250 2.750 0.000 1.00 0.00 H +ENDMDL +END diff --git a/contact_map/tests/test_concurrence.py b/contact_map/tests/test_concurrence.py new file mode 100644 index 0000000..0347b5d --- /dev/null +++ b/contact_map/tests/test_concurrence.py @@ -0,0 +1,193 @@ +# pylint: disable=wildcard-import, missing-docstring, protected-access +# pylint: disable=attribute-defined-outside-init, invalid-name, no-self-use +# pylint: disable=wrong-import-order, unused-wildcard-import + +from .utils import * + +from contact_map.concurrence import * +from contact_map import ContactFrequency + +# pylint: disable=wildcard-import, missing-docstring, protected-access +# pylint: disable=attribute-defined-outside-init, invalid-name, no-self-use +# pylint: disable=wrong-import-order, unused-wildcard-import +def setup_module(): + global traj, contacts + traj = md.load(find_testfile("concurrence.pdb")) + query = traj.topology.select("resSeq 3") + haystack = traj.topology.select("resSeq 1 to 2") + # note that this includes *all* atoms + contacts = ContactFrequency(traj, query, haystack, cutoff=0.051, + n_neighbors_ignored=0) + + +@pytest.mark.parametrize("contact_type", ('atoms', 'residues')) +def test_regularize_contact_input(contact_type): + from contact_map.concurrence import _regularize_contact_input \ + as regularize + most_common = { + 'atoms': contacts.atom_contacts.most_common(), + 'residues': contacts.residue_contacts.most_common() + }[contact_type] + contact_count = { + 'atoms': contacts.atom_contacts, + 'residues': contacts.residue_contacts + }[contact_type] + assert regularize(most_common, contact_type) == most_common + assert regularize(contact_count, contact_type) == most_common + assert regularize(contacts, contact_type) == most_common + +def test_regularize_contact_input_bad_type(): + from contact_map.concurrence import _regularize_contact_input \ + as regularize + with pytest.raises(RuntimeError): + regularize(contacts, "foo") + + +class ContactConcurrenceTester(object): + def _test_default_labels(self, concurrence): + assert len(concurrence.labels) == len(self.labels) / 2 + for label in concurrence.labels: + assert label in self.labels + + def _test_set_labels(self, concurrence, expected): + new_labels = [self.label_to_pair[label] + for label in concurrence.labels] + concurrence.set_labels(new_labels) + for label in new_labels: + assert concurrence[label] == expected[label] + + def _test_getitem(self, concurrence, pair_to_expected): + for label in concurrence.labels: + values = concurrence[label] + pair = self.label_to_pair[label] + expected_values = pair_to_expected[pair] + assert values == expected_values + + +class TestAtomContactConcurrence(ContactConcurrenceTester): + def setup(self): + self.concurrence = AtomContactConcurrence( + trajectory=traj, + atom_contacts=contacts.atom_contacts.most_common(), + cutoff=0.051 + ) + # dupes each direction until we have better way to handle frozensets + self.label_to_pair = {'[AAA1-H, LLL3-H]': 'AH-LH', + '[LLL3-H, AAA1-H]': 'AH-LH', + '[AAA1-C1, LLL3-C1]': 'AC1-LC1', + '[LLL3-C1, AAA1-C1]': 'AC1-LC1', + '[BBB2-H, LLL3-C2]': 'BH-LC2', + '[LLL3-C2, BBB2-H]': 'BH-LC2', + '[AAA1-C2, LLL3-C2]': 'AC2-LC2', + '[LLL3-C2, AAA1-C2]': 'AC2-LC2', + '[AAA1-C2, LLL3-C1]': 'AC2-LC1', + '[LLL3-C1, AAA1-C2]': 'AC2-LC1', + '[BBB2-C2, LLL3-C2]': 'BC2-LC2', + '[LLL3-C2, BBB2-C2]': 'BC2-LC2'} + self.labels = list(self.label_to_pair.keys()) + self.pair_to_expected = { + 'AH-LH': [False, False, True, True, False], + 'AC1-LC1': [False, True, False, False, False], + 'BH-LC2': [False, False, False, True, False], + 'AC2-LC2': [False, True, False, False, False], + 'AC2-LC1': [True, False, False, False, False], + 'BC2-LC2': [True, False, False, False, False] + } + + def test_default_labels(self): + self._test_default_labels(self.concurrence) + + def test_getitem(self): + self._test_getitem(self.concurrence, self.pair_to_expected) + + def test_set_labels(self): + self._test_set_labels(self.concurrence, self.pair_to_expected) + + +class TestResidueContactConcurrence(ContactConcurrenceTester): + def setup(self): + self.heavy_contact_concurrence = ResidueContactConcurrence( + trajectory=traj, + residue_contacts=contacts.residue_contacts.most_common(), + cutoff=0.051 + ) + self.all_contact_concurrence = ResidueContactConcurrence( + trajectory=traj, + residue_contacts=contacts.residue_contacts.most_common(), + cutoff=0.051, + select="" + ) + self.label_to_pair = {'[AAA1, LLL3]': 'AL', + '[LLL3, AAA1]': 'AL', + '[BBB2, LLL3]': 'BL', + '[LLL3, BBB2]': 'BL'} + self.labels = list(self.label_to_pair.keys()) + self.pair_to_expected = { + 'heavy': { + 'AL': [True, True, False, False, False], + 'BL': [True, False, False, False, False] + }, + 'all': { + 'AL': [True, True, True, True, False], + 'BL': [True, False, False, True, False] + } + } + + def _get_concurrence(self, conc_type): + return {'heavy': self.heavy_contact_concurrence, + 'all': self.all_contact_concurrence}[conc_type] + + + @pytest.mark.parametrize('conc_type', ('heavy', 'all')) + def test_default_labels(self, conc_type): + concurrence = self._get_concurrence(conc_type) + self._test_default_labels(concurrence) + + def test_set_labels(self): + # only run this for the heavy atom concurrence + concurrence = self.heavy_contact_concurrence + expected = self.pair_to_expected['heavy'] + self._test_set_labels(concurrence, expected) + + @pytest.mark.parametrize('conc_type', ('heavy', 'all')) + def test_getitem(self, conc_type): + concurrence = self._get_concurrence(conc_type) + pair_to_expected = self.pair_to_expected[conc_type] + self._test_getitem(concurrence, pair_to_expected) + + +class TestConcurrencePlotter(object): + def setup(self): + self.concurrence = ResidueContactConcurrence( + trajectory=traj, + residue_contacts=contacts.residue_contacts.most_common(), + cutoff=0.051 + ) + self.plotter = ConcurrencePlotter(self.concurrence) + + def test_x_values(self): + time_values = [0.3, 0.4, 0.5, 0.6, 0.7] + assert self.plotter.x_values == [0, 1, 2, 3, 4] + self.plotter.x_values = time_values + assert self.plotter.x_values == time_values + + def test_get_concurrence_labels_given(self): + alpha_labels = ['a', 'b'] + labels = self.plotter.get_concurrence_labels(self.concurrence, + labels=alpha_labels) + assert labels == alpha_labels + + def test_get_concurrence_labels_default(self): + labels = self.plotter.get_concurrence_labels(self.concurrence) + assert labels == self.concurrence.labels + + def test_get_concurrence_label_none_in_concurrence(self): + numeric_labels = ['0', '1'] + self.concurrence.labels = None + labels = self.plotter.get_concurrence_labels(self.concurrence) + assert labels == numeric_labels + + def test_plot(self): + # SMOKE TEST ONLY + pytest.importorskip('matplotlib.pyplot') + self.plotter.plot() diff --git a/contact_map/tests/test_contact_count.py b/contact_map/tests/test_contact_count.py index 12d75cb..ef91eb3 100644 --- a/contact_map/tests/test_contact_count.py +++ b/contact_map/tests/test_contact_count.py @@ -51,6 +51,27 @@ def test_plot(self): self.atom_contacts.plot() self.residue_contacts.plot(with_colorbar=False) + @pytest.mark.skipif(not HAS_MATPLOTLIB, reason="Missing matplotlib") + def test_plot_kwargs(self): + fig, _ = self.residue_contacts.plot(figsize=(12, 13), dpi=192) + # Assert that the kwargs have been passed through + assert fig.get_dpi() == 192 + assert fig.get_figwidth() == 12 + assert fig.get_figheight() == 13 + + @pytest.mark.skipif(not HAS_MATPLOTLIB, reason="Missing matplotlib") + def test_pixel_warning(self): + # This should not raise a warning (5*2>=10) + with pytest.warns(None) as record: + self.atom_contacts.plot(figsize=(5, 5), dpi=2) + # See if no warning was raised + assert len(record) == 0 + + # Now raise the warning as 4*2 < 10 + with pytest.warns(RuntimeWarning) as record: + self.atom_contacts.plot(figsize=(4, 4), dpi=2) + assert len(record) == 1 + def test_initialization(self): assert self.atom_contacts._object_f == self.topology.atom assert self.atom_contacts.n_x == self.topology.n_atoms @@ -71,9 +92,9 @@ def test_df(self): assert isinstance(atom_df, pd.SparseDataFrame) assert isinstance(residue_df, pd.SparseDataFrame) - assert_array_equal(atom_df.to_dense().as_matrix(), + assert_array_equal(atom_df.to_dense().values, zero_to_nan(self.atom_matrix)) - assert_array_equal(residue_df.to_dense().as_matrix(), + assert_array_equal(residue_df.to_dense().values, zero_to_nan(self.residue_matrix)) @pytest.mark.parametrize("obj_type", ['atom', 'res']) diff --git a/contact_map/tests/test_contact_map.py b/contact_map/tests/test_contact_map.py index 3a3eece..26f1b2b 100644 --- a/contact_map/tests/test_contact_map.py +++ b/contact_map/tests/test_contact_map.py @@ -63,6 +63,12 @@ def check_most_common_order(most_common): for i in range(len(most_common) - 1): assert most_common[i][1] >= most_common[i+1][1] +def check_use_atom_slice(m, use_atom_slice, expected): + if use_atom_slice is not None: + assert m._use_atom_slice == use_atom_slice + else: + assert m._use_atom_slice == expected[m] + def _contact_object_compare(m, m2): """Compare two contact objects (with asserts). @@ -79,6 +85,16 @@ def _contact_object_compare(m, m2): if hasattr(m, '_residue_contacts') or hasattr(m2, '_residue_contacts'): assert m._residue_contacts == m2._residue_contacts + +def _check_contacts_dict_names(contact_object): + aliases = { + contact_object.residue_contacts: ['residue', 'residues', 'res'], + contact_object.atom_contacts: ['atom', 'atoms'] + } + for (contacts, names) in aliases.items(): + for name in names: + assert contacts.counter == contact_object.contacts[name].counter + def test_residue_neighborhood(): top = traj.topology residues = list(top.residues) @@ -114,6 +130,11 @@ def test_initialization(self, idx): m = self.maps[idx] assert set(m.query) == set(range(10)) assert set(m.haystack) == set(range(10)) + assert set(m.all_atoms) == set(range(10)) + assert set(r.index for r in m.query_residues) == set(range(5)) + assert set(r.index for r in m.haystack_residues) == set(range(5)) + assert m.haystack_residue_range == (0, 5) + assert m.query_residue_range == (0, 5) assert m.n_neighbors_ignored == 0 assert m.topology == self.topology for res in m.topology.residues: @@ -137,6 +158,7 @@ def test_to_dict(self, idx): assert dct['cutoff'] == 0.075 assert dct['query'] == list(range(10)) assert dct['haystack'] == list(range(10)) + assert dct['all_atoms'] == tuple(range(10)) assert dct['n_neighbors_ignored'] == 0 assert dct['atom_idx_to_residue_idx'] == {i: i // 2 for i in range(10)} @@ -238,11 +260,59 @@ def test_saving(self, idx): assert m.atom_contacts.counter == m2.atom_contacts.counter os.remove(test_file) - # TODO: add tests for ContactObject._check_consistency + @pytest.mark.parametrize("use_atom_slice", [True, False, None]) + def test_atom_slice(self, idx, use_atom_slice): + #Set class variable before init + class_default = ContactMap._class_use_atom_slice + ContactMap._class_use_atom_slice = use_atom_slice + map0q = ContactMap(traj[0], query=[1, 4, 5, 6], cutoff=0.075, + n_neighbors_ignored=0) + map0h = ContactMap(traj[0], haystack=[1, 4, 5, 6], + cutoff=0.075, n_neighbors_ignored=0) + map0b = ContactMap(traj[0], query=[1, 4, 5, 6], haystack=[1,4,5,6], + cutoff=0.075, n_neighbors_ignored=0) + maps = [map0q, map0h, map0b] + atoms = {map0q: list(range(10)), + map0h: list(range(10)), + map0b: [1, 4, 5, 6]} + expected_atom_slice = {map0q: False, + map0h: False, + map0b: True} + # Only test for map 0 for now + m0 = self.maps[0] + + # Test init + for m in maps: + assert m.all_atoms == atoms[m] + check_use_atom_slice(m, use_atom_slice, expected_atom_slice) + + # Test results compared to m0 + expected = counter_of_inner_list(self.expected_atom_contacts[m0]) + assert m._atom_contacts == expected + assert m.atom_contacts.counter == expected + expected_residue_contacts = self.expected_residue_contacts[m0] + expected = counter_of_inner_list(expected_residue_contacts) + assert m._residue_contacts == expected + assert m.residue_contacts.counter == expected + + # Test sliced indices + sliced_idx = [0, 1, 2, 3] + real_idx = [map0b.s_idx_to_idx(i) for i in sliced_idx] + if map0b._use_atom_slice: + assert real_idx == [1, 4, 5, 6] + else: + assert real_idx == sliced_idx + # Reset class variable (as imports are not redone between function + # calls) + ContactMap._class_use_atom_slice = class_default + def test_contacts_dict(self, idx): + _check_contacts_dict_names(self.maps[idx]) + # TODO: add tests for ContactObject._check_consistency class TestContactFrequency(object): def setup(self): + self.atoms = [0, 1, 4, 5, 6, 7, 8, 9] self.map = ContactFrequency(trajectory=traj, cutoff=0.075, n_neighbors_ignored=0) @@ -255,6 +325,7 @@ def test_initialization(self): assert self.map.topology == traj.topology assert set(self.map.query) == set(range(10)) assert set(self.map.haystack) == set(range(10)) + assert set(self.map.all_atoms) == set(range(10)) assert self.map.n_neighbors_ignored == 0 for res in self.map.topology.residues: ignored_atoms = self.map.residue_ignore_atom_idxs[res.index] @@ -277,6 +348,9 @@ def test_counters(self): } assert residue_contacts.counter == expected_residue_contacts + def test_contacts_dict(self): + _check_contacts_dict_names(self.map) + def test_check_compatibility_true(self): map2 = ContactFrequency(trajectory=traj[0:2], cutoff=0.075, @@ -462,6 +536,44 @@ def test_subtract_contact_frequency(self): assert test_subject.residue_contacts.counter == \ last_frame.residue_contacts.counter + @pytest.mark.parametrize("use_atom_slice", [True, False, None]) + def test_use_atom_slice(self, use_atom_slice): + #Set class default before init + class_default = ContactFrequency._class_use_atom_slice + ContactFrequency._class_use_atom_slice = use_atom_slice + mapq = ContactFrequency(trajectory=traj, cutoff=0.075, + n_neighbors_ignored=0, query=self.atoms) + + maph = ContactFrequency(trajectory=traj, cutoff=0.075, + n_neighbors_ignored=0, haystack=self.atoms) + + mapb = ContactFrequency(trajectory=traj, cutoff=0.075, + n_neighbors_ignored=0, query=self.atoms, + haystack=self.atoms) + + maps = [mapq, maph, mapb] + atoms = {mapq: list(range(10)), + maph: list(range(10)), + mapb: self.atoms} + expected_atom_slice = {mapq: False, + maph: False, + mapb: True} + # Test init + for m in maps: + self.map = m + assert m.all_atoms == atoms[m] + atom_list = [traj.topology.atom(i) for i in m.all_atoms] + check_use_atom_slice(m, use_atom_slice, expected_atom_slice) + sliced_traj = m.slice_trajectory(traj) + if m.use_atom_slice: + assert sliced_traj.topology.n_atoms == len(m.all_atoms) + else: + assert sliced_traj is traj + + # Test counters + self.test_counters() + # Reset class default as pytest does not re-import + ContactFrequency._class_use_atom_slice = class_default class TestContactDifference(object): def test_diff_traj_frame(self): @@ -546,6 +658,12 @@ def test_diff_frame_frame(self): for (k, v) in expected_residues_1.items()} assert diff_2.residue_contacts.counter == expected_residues_2 + def test_contacts_dict(self): + ttraj = ContactFrequency(traj[0:4], cutoff=0.075, + n_neighbors_ignored=0) + frame = ContactMap(traj[4], cutoff=0.075, n_neighbors_ignored=0) + _check_contacts_dict_names(ttraj - frame) + def test_diff_traj_traj(self): traj_1 = ContactFrequency(trajectory=traj[0:2], cutoff=0.075, diff --git a/contact_map/tests/test_dask_runner.py b/contact_map/tests/test_dask_runner.py index d72cb18..3776812 100644 --- a/contact_map/tests/test_dask_runner.py +++ b/contact_map/tests/test_dask_runner.py @@ -1,21 +1,69 @@ - # pylint: disable=wildcard-import, missing-docstring, protected-access # pylint: disable=attribute-defined-outside-init, invalid-name, no-self-use # pylint: disable=wrong-import-order, unused-wildcard-import from .utils import * from contact_map.dask_runner import * +from contact_map import ContactFrequency + +def dask_setup_test_cluster(distributed, n_workers=4, n_attempts=3): + """Set up a test cluster using dask.distributed. Try up to n_attempts + times, and skip the test if all attempts fail. + """ + cluster = None + for _ in range(n_attempts): + try: + cluster = distributed.LocalCluster(n_workers=n_workers) + except AttributeError: + # should never get here, because should have already skipped + pytest.skip("dask.distributed not installed") + except distributed.TimeoutError: + continue + else: + return cluster + # only get here if all retries fail + pytest.skip("Failed to set up distributed LocalCluster") + class TestDaskContactFrequency(object): def test_dask_integration(self): # this is an integration test to check that dask works dask = pytest.importorskip('dask') # pylint: disable=W0612 distributed = pytest.importorskip('dask.distributed') - - client = distributed.Client() + # Explicitly set only 4 workers on Travis instead of 31 + # Fix copied from https://github.com/spencerahill/aospy/pull/220/files + cluster = dask_setup_test_cluster(distributed, n_workers=4) + client = distributed.Client(cluster) filename = find_testfile("trajectory.pdb") dask_freq = DaskContactFrequency(client, filename, cutoff=0.075, n_neighbors_ignored=0) client.close() assert dask_freq.n_frames == 5 + + def test_dask_atom_slice(self): + # This is an integration test to check that dask works with atom_slice + dask = pytest.importorskip('dask') # pylint: disable=W0612 + distributed = pytest.importorskip('dask.distributed') + # Explicitly set only 4 workers on Travis instead of 31 + # Fix copied from https://github.com/spencerahill/aospy/pull/220/files + cluster = dask_setup_test_cluster(distributed, n_workers=4) + client = distributed.Client(cluster) + filename = find_testfile("trajectory.pdb") + + dask_freq0 = DaskContactFrequency(client, filename, query=[3, 4], + haystack=[6, 7], cutoff=0.075, + n_neighbors_ignored=0) + client.close() + assert dask_freq0.n_frames == 5 + client = distributed.Client(cluster) + # Set the slicing of contact frequency (used in the frqeuency task) + # to False + ContactFrequency._class_use_atom_slice = False + dask_freq1 = DaskContactFrequency(client, filename, query=[3, 4], + haystack=[6, 7], cutoff=0.075, + n_neighbors_ignored=0) + client.close() + assert dask_freq0._use_atom_slice is True + assert dask_freq1._use_atom_slice is False + assert dask_freq0 == dask_freq1 diff --git a/docs/api.rst b/docs/api.rst index 61376fb..57e8502 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -18,6 +18,18 @@ Contact maps ContactFrequency ContactDifference +Contact Concurrences +-------------------- +.. autosummary:: + :toctree: api/generated/ + + Concurrence + AtomContactConcurrence + ResidueContactConcurrence + ConcurrencePlotter + plot_concurrence + + Minimum Distance (and related) ------------------------------ diff --git a/docs/environment.yml b/docs/environment.yml index 1df86c7..b72cdaf 100644 --- a/docs/environment.yml +++ b/docs/environment.yml @@ -1,15 +1,13 @@ name: test channels: - - omnia - - defaults - conda-forge dependencies: - - python - - mdtraj - - numpy - - scipy - - pandas - - packaging + - python=3.7 + - mdtraj=1.9.2 + - numpy=1.16.2 + - scipy=1.2.1 + - pandas=0.24.2 + - packaging=19.0 - nbsphinx - pandoc - jupyter diff --git a/docs/examples/index.rst b/docs/examples/index.rst index a89ccb4..4c7b5d8 100644 --- a/docs/examples/index.rst +++ b/docs/examples/index.rst @@ -1,8 +1,10 @@ Examples ======== -So far, we only have one major example. We will add others here as they -are written. +We have several examples to illustrate various features of the code. These +notebooks have been rendered here for the web, but the originals are +found in the ``examples/`` directory of the package, and you can run them +yourself! .. toctree:: :maxdepth: 1 diff --git a/docs/installing.rst b/docs/installing.rst index 632beb2..07aaab9 100644 --- a/docs/installing.rst +++ b/docs/installing.rst @@ -97,6 +97,19 @@ This is a three-step process: interpreted uses) and the ``.`` tells it to find ``setup.py`` in the current directory. +Additional functionality +======================== + +Installing some additional packages will immediately enable additional +features in ``contact_map``. To get all the functionality, install the +packages in ``optional_installs.txt``, either with ``pip install -r +optional_installs.txt`` or ``conda install -y --file +optional_installs.txt``. + +Specific extra functionality that can be enabled: + +* plotting tools (install ``matplotlib``) +* parallelization (install ``dask``, ``distributed``) Testing your installation ========================= diff --git a/docs/requirements.txt b/docs/requirements.txt new file mode 100644 index 0000000..bbf2620 --- /dev/null +++ b/docs/requirements.txt @@ -0,0 +1,4 @@ +packaging +nbsphinx +pandoc +jupyter diff --git a/docs/rtd_requirements.txt b/docs/rtd_requirements.txt new file mode 100644 index 0000000..7933e57 --- /dev/null +++ b/docs/rtd_requirements.txt @@ -0,0 +1,2 @@ +cython +numpy diff --git a/examples/concurrences.ipynb b/examples/concurrences.ipynb new file mode 100644 index 0000000..71c1e2f --- /dev/null +++ b/examples/concurrences.ipynb @@ -0,0 +1,232 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Concurrences\n", + "\n", + "One of the tools in `contact_map` is the ability to look at simultaneous contacts. The idea is that you might have a set of contacts that is likely to happen concurrently, and that this set of contacts might help you define a stable state. This is managed in `contact_map` by what we call contact concurrences.\n", + "\n", + "To start, we'll look at a trajectory of a specific inhibitor during its binding process to GSK3B." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "from __future__ import print_function\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from contact_map import ContactFrequency, ResidueContactConcurrence, plot_concurrence\n", + "import mdtraj as md\n", + "traj = md.load(\"data/gsk3b_example.h5\")\n", + "print(traj) # to see number of frames; size of system" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we'll use MDTraj's [atom selection language](http://mdtraj.org/latest/atom_selection.html) to split out the protein and the ligand, which has residue name YYG in the input files. We're only interested in contacts between the protein and the ligand (not contacts within the protein). We'll also only look at heavy atom contacts." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "topology = traj.topology\n", + "yyg = topology.select('resname YYG and element != \"H\"')\n", + "protein = topology.select('protein and element != \"H\"')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we'll make a list of all the residue contacts that are made, keeping only those that occur more than 20% of the time. We'll put that into a `ResidueContactConcurrence` object, and plot it!" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 4.11 s, sys: 54.1 ms, total: 4.16 s\n", + "Wall time: 4.02 s\n" + ] + } + ], + "source": [ + "%%time\n", + "contacts = ContactFrequency(traj, query=yyg, haystack=protein)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "contact_list = [(contact_pair, freq)\n", + " for contact_pair, freq in contacts.residue_contacts.most_common()\n", + " if freq >= 0.2]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 352 ms, sys: 4.91 ms, total: 357 ms\n", + "Wall time: 359 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "concurrence = ResidueContactConcurrence(traj, contact_list, select=\"\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "# optionally, create x-values... since we know that we have 1 ns/frame\n", + "times = [1.0*(i+1) for i in range(len(traj))]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "(fig, ax, lgd) = plot_concurrence(concurrence, x_values=times)\n", + "plt.xlabel(\"Time (ns)\")\n", + "plt.savefig(\"concurrences.pdf\", bbox_extra_artists=(lgd,), bbox_inches='tight')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This plot shows when each contact occurred. The x-axis is time. Each dot represents that a specific contact pair is present at that time. The contact pairs are separated along the vertical axis, listed in the order from `contact_list` (here, decreasing order of frequency of the contact). The contacts are also listed in that order in the legend, to the right.\n", + "\n", + "This trajectory shows two groups of stable contacts between the protein and the ligand; i.e. there is a change in the stable state. This allows us to visually identify the contacts involved in each state. Both states involve the ligand being in contact with Phe33, but the earlier state includes contacts with Ile28, Gly29, etc., while the later state includes contacts with Ser32 and Gly168.\n", + "\n", + "This change occurs around 60ns (which is also frame 60), and is evident when viewing the MD trajectory. If you have [NGLView](https://github.com/arose/nglview/) installed, visualize the trajectory with the following:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# for visualization, we need to clean up the trajectory:\n", + "traj.topology.create_standard_bonds() # required for image_molecules\n", + "traj = traj.image_molecules().superpose(traj)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3782c8b836f343daa9d661c363aa4a9a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "NGLWidget(count=100, frame=60)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import nglview as nv\n", + "view = nv.show_mdtraj(traj)\n", + "view.remove_cartoon()\n", + "view.add_cartoon('protein', color='#0000BB', opacity=0.3)\n", + "view.add_ball_and_stick(\"YYG\")\n", + "\n", + "# update to my recommeded camera orientation\n", + "camera_orientation = [-100, 45, -30, 0,\n", + " 50, 90, -45, 0,\n", + " 0, -45,-100, 0,\n", + " -50, -45, -45, 1]\n", + "view._set_camera_orientation(camera_orientation)\n", + "\n", + "# start trajectory at frame 60: you can scrub forward or backward\n", + "view.frame = 60\n", + "view" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/contact_map.ipynb b/examples/contact_map.ipynb index b43cf87..8130622 100644 --- a/examples/contact_map.ipynb +++ b/examples/contact_map.ipynb @@ -53,8 +53,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 137 ms, sys: 6.93 ms, total: 144 ms\n", - "Wall time: 145 ms\n" + "CPU times: user 266 ms, sys: 3.72 ms, total: 270 ms\n", + "Wall time: 75.7 ms\n" ] } ], @@ -81,18 +81,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 1.09 s, sys: 34.6 ms, total: 1.13 s\n", - "Wall time: 1.15 s\n" + "CPU times: user 493 ms, sys: 8.42 ms, total: 501 ms\n", + "Wall time: 495 ms\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEKCAYAAAACS67iAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nM+sJB3Qzs55wQDcz6wkHdDOznvj/npnUcRTsjvYAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -117,19 +119,30 @@ "execution_count": 5, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/sander/github_files/contact_map/contact_map/contact_count.py:131: RuntimeWarning: The number of pixels in the figure is insufficient to show all the contacts.\n", + " Please save this as a vector image (such as a PDF) to view the correct result.\n", + " Another option is to increase the 'dpi' (currently: 72.0), or the 'figsize' (curently: (6.0, 4.0)).\n", + " Adviced minimum amount of pixels = (2722, 2722) (width, height).\n", + " warnings.warn(msg, RuntimeWarning)\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 5.46 s, sys: 102 ms, total: 5.56 s\n", - "Wall time: 5.6 s\n" + "CPU times: user 2.82 s, sys: 187 ms, total: 3.01 s\n", + "Wall time: 2.83 s\n" ] }, { "data": { "text/plain": [ - "(,\n", - " )" + "(
,\n", + " )" ] }, "execution_count": 5, @@ -138,12 +151,14 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWwAAAD8CAYAAABTjp5OAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nrGkJ3VUAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -156,7 +171,29 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "You'll notice that you don't see many points here. That is because the points are typically smaller than a single pixel at this resolution. To fix that, increase the figure's size or dpi. (Future updates to `contact_map` may provide an option to require that each point be at least one pixel in size)" + "You'll notice that you don't see many points here. As the warning states: That is because the points are smaller than a single pixel at this resolution. To fix that, output or save this figure as a vector image (like PDF), increase the figure's size (by using the `figsize` parameter) or dpi (by using the `dpi` parameter), or both. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# If you want Jupyter to output pdf, instead of png:\n", + "# from IPython.display import set_matplotlib_formats\n", + "# set_matplotlib_formats('pdf')\n", + "# frame_contacts.atom_contacts.plot(cmap='seismic', vmin=-1, vmax=1);\n", + "\n", + "# If you want to save as a vector image:\n", + "# frame_contacts.atom_contacts.plot(cmap='seismic', vmin=-1, vmax=1);\n", + "# plt.savefig('atom_contacts.pdf')\n", + "\n", + "# If you want to increase the figure size:\n", + "# frame_contacts.atom_contacts.plot(cmap='seismic', vmin=-1, vmax=1, figsize=(38, 38));\n", + "\n", + "# If you want to increase the dpi (and make the image square):\n", + "# frame_contacts.atom_contacts.plot(cmap='seismic', vmin=-1, vmax=1, figsize=(6, 6), dpi=454);" ] }, { @@ -170,15 +207,15 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 6.02 s, sys: 28 ms, total: 6.05 s\n", - "Wall time: 6.08 s\n" + "CPU times: user 20.6 s, sys: 137 ms, total: 20.8 s\n", + "Wall time: 3.22 s\n" ] } ], @@ -189,7 +226,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -200,25 +237,27 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 3.25 s, sys: 43.1 ms, total: 3.3 s\n", - "Wall time: 3.32 s\n" + "CPU times: user 1.75 s, sys: 13.1 ms, total: 1.76 s\n", + "Wall time: 1.76 s\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWYAAAD8CAYAAABErA6HAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nHnI8AAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -240,15 +279,15 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 14.2 ms, sys: 4.48 ms, total: 18.7 ms\n", - "Wall time: 14.8 ms\n" + "CPU times: user 59.6 ms, sys: 52.3 ms, total: 112 ms\n", + "Wall time: 37.1 ms\n" ] } ], @@ -266,36 +305,38 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 3.3 s, sys: 49.9 ms, total: 3.35 s\n", - "Wall time: 3.36 s\n" + "CPU times: user 1.65 s, sys: 69.6 ms, total: 1.72 s\n", + "Wall time: 1.64 s\n" ] }, { "data": { "text/plain": [ - "(,\n", - " )" + "(
,\n", + " )" ] }, - "execution_count": 10, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXUAAAD8CAYAAACINTRsAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nsVj6iP8LRtzz+wzT/n4AAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -332,15 +373,15 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 7.53 ms, sys: 1.97 ms, total: 9.5 ms\n", - "Wall time: 8.1 ms\n" + "CPU times: user 3.73 ms, sys: 3.52 ms, total: 7.25 ms\n", + "Wall time: 2.43 ms\n" ] }, { @@ -348,17 +389,17 @@ "text/plain": [ "[([ALA146, GLN22], 0.9900990099009901),\n", " ([PHE82, PHE141], 0.9801980198019802),\n", - " ([ALA83, LYS117], 0.9702970297029703),\n", " ([ILE84, GLU143], 0.9702970297029703),\n", + " ([ALA83, LYS117], 0.9702970297029703),\n", " ([PHE90, ALA130], 0.9702970297029703),\n", " ([ALA146, ASN116], 0.9702970297029703),\n", - " ([ALA155, VAL152], 0.9504950495049505),\n", " ([LEU113, ILE139], 0.9504950495049505),\n", + " ([ALA155, VAL152], 0.9504950495049505),\n", " ([LEU19, LEU79], 0.9405940594059405),\n", " ([VAL81, ILE93], 0.9405940594059405)]" ] }, - "execution_count": 11, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -371,25 +412,25 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[([NA6828, THR87], -0.9900990099009901),\n", + "[([THR50, CL6865], -0.9900990099009901),\n", + " ([NA6824, CL6860], -0.9900990099009901),\n", + " ([TYR40, TYR32], -0.9900990099009901),\n", + " ([NA6828, THR87], -0.9900990099009901),\n", " ([CL6849, NA6842], -0.9900990099009901),\n", " ([NA6834, SER39], -0.9900990099009901),\n", - " ([PRO34, ASP38], -0.9900990099009901),\n", " ([ALA59, GLU37], -0.9900990099009901),\n", + " ([PRO34, ASP38], -0.9900990099009901),\n", " ([GLN25, ASP30], -0.9900990099009901),\n", - " ([NA6842, GLY13], -0.9900990099009901),\n", - " ([CL6865, GLN43], -0.9900990099009901),\n", - " ([TYR40, TYR32], -0.9900990099009901),\n", - " ([SER65, GLU37], -0.9900990099009901)]" + " ([NA6842, GLY13], -0.9900990099009901)]" ] }, - "execution_count": 12, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -416,7 +457,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -431,7 +472,7 @@ "val81 = topology.residue(80)\n", "asn116 = topology.residue(115)\n", "gtp201 = topology.residue(166)\n", - "print val81, asn116, gtp201" + "print(val81, asn116, gtp201)" ] }, { @@ -443,7 +484,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -453,18 +494,18 @@ "([GTP201, LEU120], 0.6435643564356436)\n", "([GTP201, ASP119], 0.6237623762376238)\n", "([LYS147, GTP201], 0.6138613861386139)\n", - "([ALA146, GTP201], 0.594059405940594)\n", "([SER145, GTP201], 0.594059405940594)\n", + "([ALA146, GTP201], 0.594059405940594)\n", "([LYS117, GTP201], 0.594059405940594)\n", "([ASP33, GTP201], 0.5742574257425742)\n", "([GLY12, GTP201], 0.5643564356435643)\n", "([GLY13, GTP201], 0.5544554455445545)\n", "([VAL14, GTP201], 0.5346534653465347)\n", "([ALA11, GTP201], 0.5346534653465347)\n", + "([ALA18, GTP201], 0.5247524752475248)\n", "([GTP201, GLY15], 0.5247524752475248)\n", - "([GTP201, LYS16], 0.5247524752475248)\n", "([SER17, GTP201], 0.5247524752475248)\n", - "([ALA18, GTP201], 0.5247524752475248)\n", + "([GTP201, LYS16], 0.5247524752475248)\n", "([ASN116, GTP201], 0.4752475247524752)\n", "([ASP57, GTP201], 0.40594059405940597)\n", "([GTP201, GLU63], 0.39603960396039606)\n", @@ -481,7 +522,7 @@ "source": [ "for contact in trajectory_contacts.residue_contacts.most_common(gtp201):\n", " if contact[1] > 0.1:\n", - " print contact" + " print(contact)" ] }, { @@ -493,14 +534,14 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[([GTP201-C6, LYS117-CB], 0.5346534653465347),\n", - " ([LYS117-CA, GTP201-O6], 0.5247524752475248),\n", + " ([GTP201-O6, LYS117-CA], 0.5247524752475248),\n", " ([GTP201-C6, LYS117-CA], 0.5247524752475248),\n", " ([GTP201-C8, GLY15-CA], 0.5148514851485149),\n", " ([GTP201-N7, GLY15-CA], 0.5148514851485149),\n", @@ -510,13 +551,13 @@ " ([GTP201-C2, LYS147-CB], 0.49504950495049505),\n", " ([GTP201-O3A, GLY13-C], 0.48514851485148514),\n", " ([GTP201-O2', ASP33-OD2], 0.48514851485148514),\n", - " ([ASN116-OD1, GTP201-O6], 0.4752475247524752),\n", + " ([GTP201-O6, ASN116-OD1], 0.4752475247524752),\n", + " ([GTP201-N7, ASN116-ND2], 0.45544554455445546),\n", " ([ASN116-CG, GTP201-O6], 0.45544554455445546),\n", - " ([GTP201-O6, LYS117-CB], 0.45544554455445546),\n", - " ([GTP201-N7, ASN116-ND2], 0.45544554455445546)]" + " ([GTP201-O6, LYS117-CB], 0.45544554455445546)]" ] }, - "execution_count": 15, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -534,19 +575,19 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[([ASN116-CB, VAL81-CG1], 0.9702970297029703),\n", - " ([ASN116-CG, VAL81-CG1], 0.24752475247524752),\n", + " ([VAL81-CG1, ASN116-CG], 0.24752475247524752),\n", " ([VAL81-CG1, ASN116-ND2], 0.21782178217821782),\n", " ([VAL81-CG1, ASN116-N], 0.0594059405940594)]" ] }, - "execution_count": 16, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -570,7 +611,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -584,19 +625,21 @@ "source": [ "# the default selection is\n", "default_selection = topology.select(\"not water and symbol != 'H'\")\n", - "print len(default_selection)" + "print(len(default_selection))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Using a different query" + "### Using a different query\n", + "\n", + "MDTraj allows queries based on different numbering systems: `resid` and `resSeq`. The `resid` is the internally-used residue number, and starts from 0. On the other hand, `resSeq` is the residue number given in the PDB, which usually starts from 1 (and is the number we usually refer to in literature). More details can be found in the [documentation on MDTraj's atom selection language](http://mdtraj.org/latest/atom_selection.html)." ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -610,15 +653,15 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 2.29 s, sys: 17.7 ms, total: 2.31 s\n", - "Wall time: 2.32 s\n" + "CPU times: user 11.3 s, sys: 0 ns, total: 11.3 s\n", + "Wall time: 1.1 s\n" ] } ], @@ -629,7 +672,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "metadata": { "scrolled": true }, @@ -637,22 +680,24 @@ { "data": { "text/plain": [ - "(,\n", - " )" + "(
,\n", + " )" ] }, - "execution_count": 20, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWYAAAD8CAYAAABErA6HAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ndAAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -664,22 +709,20 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Using a different haystack\n", - "\n", - "Currently, changing the haystack has essentially no effect on the performance. However, I expect to change that in the future (requires making some modifications to MDTraj)." + "### Using a different haystack" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 2.11 s, sys: 9.41 ms, total: 2.12 s\n", - "Wall time: 2.13 s\n" + "CPU times: user 2.37 s, sys: 138 ms, total: 2.51 s\n", + "Wall time: 503 ms\n" ] } ], @@ -690,112 +733,79 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWYAAAD8CAYAAABErA6HAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ - "(fig, ax) = cations_switch1.residue_contacts.plot(cmap='seismic', vmin=-1, vmax=1)" + "fig, ax = cations_switch1.residue_contacts.plot(cmap='seismic', vmin=-1, vmax=1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Let's zoom in on that. To do this, we'll do a little MDTraj magic so that we can change the *atom* ID numbers, which are what go into our `cations` and `switch1` objects, into *residue* ID numbers (and we'll use Python `set`s to remove repeats):" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "def residue_for_atoms(atom_list, topology):\n", - " return set([topology.atom(a).residue.index for a in atom_list])" + "Now we'll plot again, but we'll change the `x` and `y` axes so that we only see switch 1 (the haystack) along `x` and cations (the query) along `y`:" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, - "outputs": [], - "source": [ - "switch1_residues = residue_for_atoms(switch1, traj.topology)\n", - "cation_residues = residue_for_atoms(cations, traj.topology)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we'll plot again, but we'll change the `x` and `y` axes so that we only see switch 1 along `x` and cations along `y`:" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, "outputs": [ { "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWYAAAD8CAYAAABErA6HAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAF3VJREFUeJzt3X+QXWV9x/H3JxshthFwmqVoYCfRBlpRSWUNjlMUESSgJaNWTHQq4o8YC3a0oxVGRvwxzFQr02JFM1uMKR1NwEnUaFHEPzTOaCRJjZhEIksAWYJkAlUGbcIk+faPe7ZeNvfuvbt77p7v3ft5zdzJuec8e+4ndzffPPvc5zxHEYGZmeUxq+oAZmb2dC7MZmbJuDCbmSXjwmxmlowLs5lZMi7MZmbJuDCbmU2BpDWS9kva2eS4JH1W0rCkuyW9pNU5XZjNzKZmLbB0nOMXA4uKx0rgC61O6MJsZjYFEbEZeHycJsuAW6JmC3CSpOeMd87ZZQacrHnz5sWCBQuqjtHY0aNVJ2hMqjpBY1lzZXbkSNUJGuvrqzpBQ9u3bz8QEf1TOcefSfH7Nts+AruAg3W7hiJiaAIvNx94qO75SLHvkWZfkKIwL1iwgG133VV1jMYOHmzdpgqzU3zrjpU1V2ZPPll1gsbmzq06QUPq63twquf4PfCeNtt+DA5GxOAUXq5Rb2XctTA8lGFm1lkjwGl1z08F9o33BS7MZtZzRK34tfMowSbgbcXsjJcBv42IpsMYkGQow8xsupX1aYikdcB5wDxJI8B1wDMAImI1cDtwCTBMbRTlilbndGE2s55UVmGOiBUtjgdw5UTO6cJsZj0p8/whF+ZW5sypOkF3OXy46gTdxz9j0064MJuZpePCbGaWTOYpaS7MZtaT3GM2M0vEY8xmZgm5MJuZJePCbFa1zIsreaGsSvjDPzOzRDzGbGaWkAuzmVkymQtzy2GWRjcalHSWpB9L+rmkb0o6odi/QNL/StpRPFZ3MryZ2WSpzUcV2hn/XsuxNxq8Gbg6Il4EfA34UN2x+yJicfFYVU5MM7NydXVhbnKjwTOAzcX2ncAbS85lZtYx07xQ/oRNdox5J3Ap8A3gTTz9tikLJf0UeAK4NiJ+2OgEklZSu5U3AwMDk4wxDbKulpZ1KlPWXJl5dblKdPUYcxPvAK6UtB14FvBUsf8RYCAi/hL4B+Aro+PPY0XEUEQMRsRgf/+UbnhrZjZhmYcyJtW9iYh7gNcASDodeG2x/xBwqNjeLuk+4HRgWylpzcxKMuN6zJJOLv6cBVwLrC6e90vqK7afBywC9pYT1cysHO32ltP2mJvcaHCupNF7WG0EvlRsvwL4hKTDwBFgVUSM/eDQzKxyXX1J9jg3GryxQdsNwIaphjIz67TMQxn+CN3MepILcysReaelZZX1/fJ0uYnL+r3MmqsEXsTIzCwhF2Yzs2RcmM3MEhm9JDsrF2Yz60nuMZuZJePCbGaWjAtzK5KnWVnvyvqznzVXSVyYzcwS8TxmM7OEPCvDzCwZ95jNzJJxYTYzSyT7GHPmYRYzs44pa6F8SUsl7ZE0LOnqBsdPlPRNST+TtEvSFa3O6R5zt8q68tcMn2LVEQcPVp2gsRl+k9gyeqXFHZtuAi4ERoCtkjZFxO66ZlcCuyPiryX1A3skfTkinmpwytKymZl1nZJ6zEuA4YjYWxTa9cCyMW0CeJYkAXOBx4Fxe1bu3phZz5ngGPM8SfU3lB6KiKFiez7wUN2xEeCcMV//OWATsA94FvDmiDg63gu6MJtZT5pAYT4QEYMTOE2MeX4RsAM4H3g+cKekH0bEE81e0EMZZtaTShrKGAFOq3t+KrWecb0rgI1RMwzcD/z5eCd1YTaznlRSYd4KLJK0UNJxwHJqwxb1fgW8GkDSnwJnAHvHO6mHMsys55S1UH5EHJZ0FXAH0AesiYhdklYVx1cDnwTWSvp58dIfjogD453XhblbeVraxGSdXgj+XlakrAtMIuJ24PYx+1bXbe8DXjORc/onwsx6UuYr/1yYzawnuTCbmSWTuTC3HP+WtEbSfkk76/adJenHkn5eXAN+Qt2xa4prxvdIuqhTwc3MJqvdGRlVFe92PphcCywds+9m4OqIeBHwNeBDAJJeQG26yJnF13y+uJbczCyVWW0+qso2rojYTO3a7npnAJuL7TuBNxbby4D1EXEoIu4HhqldS25mlkrmHvNkx5h3ApcC3wDexB+ufJkPbKlrN1LsO4aklcBKgIGBgUnGMGuTp6RNXOYphiXo6jHmJt4BXClpO7VFOUaXr2vnuvHazoihiBiMiMH+/v5JxjAzm7jsY8yT6kZExD0UE6YlnQ68tjjUznXjZmaVm3E9ZkknF3/OAq4FRq9y2QQsl3S8pIXAIuCuMoKamZUp84d/LXvMktYB51Fbk3QEuA6YK+nKoslG4EsAxTXitwG7qS0EfWVEHOlEcDOzqcjcY25ZmCNiRZNDNzZpfz1w/VRCmZl1UvabsfqjajPrSS7MZtZ9ZvgUQxdmM7NkXJjNzBIpa6H8TnFhNrOe5B6zmVkyLsxmZsm4MJuZJePCbGaWiC8wsd6SdanIGT4n1ybOszLMzJJxj9nMLBkXZjOzRDzGbGaWkAuzmVky/vDPzCwZ95hbicg7zSqrrNO/suayiZvB/yY9xmxmlpALs5lZMi7MZmbJuDCbmSXihfLNzBLK3GPO/J+GmVnHqM1Hy/NISyXtkTQs6eombc6TtEPSLkk/aHXOHD1mydOsZoodO6pO0Nipp1adoLkHHqg6QWODg1Un6KgyesyS+oCbgAuBEWCrpE0RsbuuzUnA54GlEfErSSe3Oq97zGbWk0rqMS8BhiNib0Q8BawHlo1p8xZgY0T8CiAi9rc6qQuzmfWc0Q//2nkA8yRtq3usrDvVfOChuucjxb56pwPPlvR9Sdslva1VvpbjB5LWAK8D9kfEC4t9i4HVwBzgMPB3EXGXpAXAL4A9xZdviYhVrV7DzGy6TWAo40BENBvXaXSaGPN8NnA28GrgmcCPJW2JiF82e8F2BnbXAp8Dbqnb92ng4xHxbUmXFM/PK47dFxGL2zivmVllSpqVMQKcVvf8VGBfgzYHIuJ3wO8kbQbOApoW5pZDGRGxGXh87G7ghGL7xAZBzMxSK2mMeSuwSNJCSccBy4FNY9p8AzhX0mxJfwScQ21koanJToV4P3CHpM9QK+4vrzu2UNJPgSeAayPih5N8DTOzjihrEaOIOCzpKuAOoA9YExG7JK0qjq+OiF9I+g5wN3AUuDkido6bL2LscEiDRrWx42/VjTF/FvhBRGyQdBmwMiIukHQ8MDciHpN0NvB14MyIeKLBOVcCKwEGBgbOfvD++9t7J8xmmqyruCWdwqq+vu3jjPm2ZbEUd7bZ9mSY8utN1GRnZVwObCy2v0ptyggRcSgiHiu2twP3UftE8hgRMRQRgxEx2N/fP8kYZmaTM4FZGZVkm4x9wCuL7fOBewEk9RcTrpH0PGARsHeqIc3MylbWlX+d0M50uXXUZlzMkzQCXAe8G7hR0mzgIMWQBPAK4BOSDgNHgFURMfaDQzOzSnX9QvkRsaLJobMbtN0AbJhqKDOzTuvqwmxmNhO5MJuZJePCbL3j4MGqE3SfrNPl5s6tOkHHeKF8M7OE3GM2M0vGhdnMLBkXZjOzRLp+HrOZ2UzkD//MzJJxj9l6x5w5VSfoPlmny2XNVRIXZjOzRDzGbGaWkAuzmVkyLsxmZsloVpvzMo4e7WyQBlyYzaw3uTCbmSUitV+YK+DCbOWa4VOsOuLXv646QWOnnFJ1gs5yYTYzS8Q9ZjOzhFyYzcwSkWB23vKXN5mZWSe5x2xmlojHmM3MEnJhtp6ReNwurZk+LS0rF2Yzs0T84Z+ZWTLJx5hbJpO0RtJ+STvr9i2WtEXSDknbJC2pO3aNpGFJeyRd1KngZmZTMmtWe48qorXRZi2wdMy+TwMfj4jFwEeL50h6AbAcOLP4ms9L6istrZlZWbq5MEfEZuDxsbuBE4rtE4F9xfYyYH1EHIqI+4FhYAlmZpmMDmUkLcyTHWN+P3CHpM9QK+4vL/bPB7bUtRsp9pmZ5ZJ4jHmyhfm9wAciYoOky4AvAhfQ+KYA0egEklYCKwEGBgbyrkqW+JPblJ58suoEjc2dW3WC5rL+7GfNVYbkszIm+1/G5cDGYvur/GG4YgQ4ra7dqfxhmONpImIoIgYjYrB/3rxJxjAzm6SShjIkLS0mOwxLunqcdi+VdETS37SMNsG/yqh9wCuL7fOBe4vtTcByScdLWggsAu6a5GuYmXVGSWPMxeSGm4CLgRcAK4pJEI3afQq4o514LfvyktYB5wHzJI0A1wHvBm6UNBs4SDEkERG7JN0G7AYOA1dGxJF2gpiZTatyxpiXAMMRsRdA0npqkyB2j2n3PmAD8NJ2TtqyMEfEiiaHzm7S/nrg+nZe3MysEhO7wGSepG11z4ciYqjYng88VHdsBDjn6S+l+cDrqY0ulFOYzcxmpPYL84GIGGxyrJ0JD/8KfDgijkiNmh/LhdnMek95szLamfAwCKwvivI84BJJhyPi681OmqMwJ5+6YhOQeVpaVnPmVJ2gN5UzxrwVWFRMdniY2pXPb6lvEBELR7clrQW+NV5RhiyF2cxsOpW0iFFEHJZ0FbXZFn3AmmISxKri+OrJnNeF2cx6U0lX/kXE7cDtY/Y1LMgR8fZ2zunCbGa9aQZekm1m1r2Sf66VN5mZWackXyjfhdnMepMLs5l1nZm8uhy4MJuZpeKhDDOzhFyYzcwS8awMM7NkPJRhZpaQC7OZWTIuzGbWdRKPwU6ZhzLMzJLxh39mZgm5x2xmlowLs5lZIh5jNjNLyIXZzCwR95jNrCvN9NXlPCvDzCwR95jNzBJyYTYzS6Tbe8yS1gCvA/ZHxAuLfbcCZxRNTgJ+ExGLJS0AfgHsKY5tiYhVZYc2M5uybi7MwFrgc8Atozsi4s2j25JuAH5b1/6+iFhcVkAzs47o5sIcEZuLnvAxJAm4DDi/3FhmZh00w9fKOBd4NCLurdu3UNJPgSeAayPih42+UNJKYCXAwMDAFGOYWekSF64p6/Yx5hZWAOvqnj8CDETEY5LOBr4u6cyIeGLsF0bEEDAEMDg4GFPMYWY2MTOxMEuaDbwBOHt0X0QcAg4V29sl3QecDmybYk4zs3JJVSdoaio95guAeyJiZHSHpH7g8Yg4Iul5wCJg7xQzmpmVq9uHMiStA84D5kkaAa6LiC8Cy3n6MAbAK4BPSDoMHAFWRcTj5UY2MytB4jH0dmZlrGiy/+0N9m0ANkw9lplZB3V7j9nMbEZyYbaekXVFssS/tloF3GM2M0socWHOm8zMrJNmzWrv0YKkpZL2SBqWdHWD42+VdHfx+JGks1qd0z1mM+s9JV2SLakPuAm4EBgBtkraFBG765rdD7wyIv5H0sXULqw7Z7zzujCbWe8pb4x5CTAcEXtrp9V6YBnw/4U5In5U134LcGqrk7owm1lvar8wz5NUf/XyULGkBMB84KG6YyOM3xt+J/DtVi/owmxmvan9wnwgIgabHGt0XXfDtX8kvYpaYf6rVi/owtxK1ulfWR08WHWCxubOrTpBc1l/xmbyFMPyhjJGgNPqnp8K7Dv25fRi4Gbg4oh4rNVJZ/A7b2Y2jnIK81ZgkaSFwMPUlqp4S30DSQPARuBvI+KX7ZzUhdnMek9JszIi4rCkq4A7gD5gTUTskrSqOL4a+CjwJ8Dna/cW4fA4QyOAC7OZ9aISr/yLiNuB28fsW123/S7gXRM5pwuzmfWmxFf+uTCbWW9yYTYzS8SLGHW5mTxlqBOyTkvLOiUN8v6MZZ36WIYZfpdsM7Pu5B6zmVkyLsxmZol4jNnMLCEXZjOzRNxjNjNLyLMyzCqW+B9hWnPmVJ2gc9xjNjNLyIXZzCwR95jNzBJKXJhbJpO0RtJ+STvr9t0qaUfxeEDSjrpj1xS38d4j6aJOBTczm5JZs9p7VKCdHvNa4HPALaM7IuLNo9uSbgB+W2y/gNoK/mcCzwW+J+n0iDhSYmYzs6lJvlZGy/8OImIz8HijY6otx38ZsK7YtQxYHxGHIuJ+YJja7b3NzPIYHWPu4h7zeM4FHo2Ie4vn84EtdcdHin3HkLQSWAkwMDAwxRgdlHVVssT/25t1hW4eY25hBX/oLcMEbuUdEUMRMRgRg/39/VOMYWY2QTOxxyxpNvAG4Oy63W3dytvMrFLJp8tNJdkFwD0RMVK3bxOwXNLxxe28FwF3TSWgmVnpRj/8a+dRgXamy60DfgycIWlE0juLQ8t5+jAGEbELuA3YDXwHuNIzMswspW4eyoiIFU32v73J/uuB66cWy8yswxIPZfijfTPrPcnHmF2YW/G0tInJegNPfx8nbqa/Zy7MZmaJuMdsZpZQ4t8I8iYzM+sU95jNzBJyYTYzS8Q9ZjOzhFyYrXQHDlSdoLGs0+VOOaXqBM3NnVt1gsayfi/L4sJsZpZI8oXy8yYzM+sUjzGbmSWUuDDnTWZm1ikl3lpK0tLi5tPDkq5ucFySPlscv1vSS1qd0z1mM+tNJfSYJfUBNwEXUrtRyFZJmyJid12zi6mtTb8IOAf4QvFnUy7MZtZ7yvvwbwkwHBF7a6fVemo3pa4vzMuAWyIigC2STpL0nIh4pNlJUxTm7du3P6m+vj1V52hiHpBxbppzTUzWXJA1W19fzlxwxlRPsH379jtU+/u1Y46kbXXPhyJiqNieDzxUd2yEY3vDjdrMB3IXZmBPRAxWHaIRSdsyZnOuicmaC/Jmy5xrqueIiKVlZKG9G1C3fZPqUf7wz8xs8tq5AfWEb1LtwmxmNnlbgUWSFko6jtq9UDeNabMJeFsxO+NlwG/HG1+GPEMZQ62bVCZrNueamKy5IG8252ohIg5Lugq4A+gD1kTELkmriuOrgduBS4Bh4PfAFa3Oq9oHhWZmloWHMszMknFhNjNLZtoLs6Q5ku6S9DNJuyR9vNj/puL5UUnTPkVnnFz/LOme4lLKr0k6KUmuTxaZdkj6rqTnZshVd/yDkkJSu3NFO55N0sckPVy8ZzskXZIhV3HsfcVlvbskfTpDLkm31r1XD0jaMZ25WmRbLGlLkW2bpCXTna2jImJaH9Tm9M0ttp8B/AR4GfAX1CaOfx8YTJTrNcDsYv+ngE8lyXVCXZu/B1ZnyFU8P43ahyEPAvMSfS8/BnxwuvO0ketVwPeA44tjJ2fINabNDcBHE71n3wUuLvZfAny/qu9rJx7T3mOOmieLp88oHhERv4iIyq7+GyfXdyPicLF/C7U5iBlyPVHX7I9pMWF9unIVz/8F+MfpztRmtsqMk+u9wD9FxKGi3f4kuYDaIjzAZcC66czVIlsAJxT7T6TFvOBuU8kYs6S+4tei/cCdEfGTKnKM1UaudwDfzpJL0vWSHgLeCnw0Qy5JlwIPR8TPpjtPq2zFoauKIaA1kp6dJNfpwLmSfiLpB5JemiTXqHOBRyPi3unONU629wP/XPz8fwa4popsnVJJYY6IIxGxmFrvc4mkF1aRY6zxckn6CHAY+HKWXBHxkYg4rch0VYJcLwY+QgX/SYzV5D37AvB8YDG1dQpuSJJrNvBsar+ifwi4reilVp1r1Aoq6C2PapLtvcAHip//DwBfrCpfJ1Q6KyMifkNtTLms69ZLMTaXpMuB1wFvjYjKfiUe5/36CvDGaQ9UqMu1DFgI/EzSA9T+If23pMpuuFf/nkXEo8U/8qPAv1NbGazyXNQu2d1Y/Np+F3CU2sJGVedC0mzgDcCtVeSpNybb5cDG4tBXqfB72QlVzMroH53ZIOmZwAXAPdOdY6xmuSQtBT4MXBoRv0+Ua1Fds0uZ5vewSa6fRsTJEbEgIhZQKzgviYhfJ8h2j6Tn1DV7PbAzQy7g68D5xf7TgeOYxlXdWvybvAC4JyJGpitPm9n2Aa8smp0PVDLM0ilVXJL9HOA/VFtgehZwW0R8S9LrgX8D+oH/krQjIi5KkGsYOB64s/jtcktErEqQa4OkM6j1rh4EpjNT01zTnKGZZu/Zf0paTO2DoweA9yTJdRywRtJO4Cng8mn+zWy87+VyKhzGoPl79hvgxqJHfxBYWWHG0vmSbDOzZHzln5lZMi7MZmbJuDCbmSXjwmxmlowLs5lZMi7MZmbJuDCbmSXzf+1IY7lOxopEAAAAAElFTkSuQmCC\n", "text/plain": [ - "(167, 198)" + "
" ] }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWYAAAD8CAYAAABErA6HAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nHMXY7/sAAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] + "metadata": { + "needs_background": "light" }, - "metadata": {}, "output_type": "display_data" } ], "source": [ - "(fig, ax) = cations_switch1.residue_contacts.plot(cmap='seismic', vmin=-1, vmax=1)\n", - "ax.set_xlim(min(switch1_residues), max(switch1_residues) + 1)\n", - "ax.set_ylim(min(cation_residues), max(cation_residues) + 1)" + "fig, ax = cations_switch1.residue_contacts.plot(cmap='seismic', vmin=-1, vmax=1)\n", + "ax.set_xlim(*cations_switch1.haystack_residue_range) \n", + "ax.set_ylim(*cations_switch1.query_residue_range);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Here, of course, the boxes are much larger, and are long rectangles instead of squares. The box represents the residue number that is to its left and under it. So the most significant contacts here are between residue 36 and the ion listed as residue 167. Let's see just how frequently that contact is made:" + "Here, of course, the boxes are much larger, and are long rectangles instead of squares. The box represents the residue number (in the `resid` numbering system) that is to its left and under it. So the most significant contacts here are between residue 36 and the ion listed as residue 167. Let's see just how frequently that contact is made:" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "0.485148514851\n" + "0.48514851485148514\n" ] } ], "source": [ - "print cations_switch1.residue_contacts.counter[frozenset([36, 167])]" + "print(cations_switch1.residue_contacts.counter[frozenset([36, 167])])" ] }, { @@ -807,7 +817,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -820,8 +830,8 @@ } ], "source": [ - "print traj.topology.residue(36)\n", - "print traj.topology.residue(167)" + "print(traj.topology.residue(36))\n", + "print(traj.topology.residue(167))" ] }, { @@ -844,15 +854,15 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 9.58 s, sys: 82.9 ms, total: 9.66 s\n", - "Wall time: 9.77 s\n" + "CPU times: user 24.5 s, sys: 143 ms, total: 24.6 s\n", + "Wall time: 5.35 s\n" ] } ], @@ -863,17 +873,19 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 28, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWYAAAD8CAYAAABErA6HAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nHMMLs8fj8TiGF2aPx+NxjP8fp1TOa48dShwAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -892,15 +904,15 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 3min 41s, sys: 2.95 s, total: 3min 44s\n", - "Wall time: 3min 47s\n" + "CPU times: user 2min 17s, sys: 348 ms, total: 2min 17s\n", + "Wall time: 1min 59s\n" ] } ], @@ -918,36 +930,38 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 35.7 s, sys: 1.51 s, total: 37.2 s\n", - "Wall time: 37.6 s\n" + "CPU times: user 17.7 s, sys: 109 ms, total: 17.8 s\n", + "Wall time: 17.8 s\n" ] }, { "data": { "text/plain": [ - "(,\n", - " )" + "(
,\n", + " )" ] }, - "execution_count": 31, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWYAAAD8CAYAAABErA6HAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYA6CIGgYfwCB8c1H2F13OwAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -958,25 +972,27 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 1.5 s, sys: 35.9 ms, total: 1.54 s\n", - "Wall time: 1.54 s\n" + "CPU times: user 985 ms, sys: 83 µs, total: 985 ms\n", + "Wall time: 986 ms\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAIABJREFUeJzsfXt4XVW172+V0OSSnDZqoYHGEqFA\ntdUW2gN4vgpoRcALwrE85KjHVuUlFURBwNqz2dQekMfBCl7AogVRoUo9IFx5VgV65VWep0rVwAkY\nINQKpaQ1DWnX/WPNsedvjj3mfiQ7IXAyvi/fXll77bnmXGvOMcf4jVeSpilGaIRGaIRG6O1Lo97s\nDozQCI3QCI3Q4NIIox+hERqhEXqb0wijH6ERGqERepvTCKMfoREaoRF6m9MIox+hERqhEXqb0wij\nH6ERGqERepvTCKMfoREaoRF6m9MIox+hERqhEXqb0wijH6ERGqEReptT3ZvdAQAYN3Zs2rbLLtk/\no0YBSZId19UB223nL0wSgCN50zT8n6+zSF/b11fcjnxu2xbeW85vv33YzqhR4afQtm2+L3LMv5N7\ny3fSBrczenT2uXUr0Nvr25B+pWn4rOR4u+2Kn5Pum9x31CjgjTf87/Q45PfWOKVd7o8Qj3vUqOL+\nWM+H3y+/w23b/P9J4o/52fH3/C65v3wf7rPutz62+sTEbeh+M+l3rccmcwLI3qf+nufHG2/4Y34m\n+n4yTj7eurX4nvwettvOHseoUWF7W7dmx9tvX9wGv/MkCeeYtL11qx/Dli2+na1bw7blntIGPx+5\nntcqnweyfsj1fE/9bHleyW/5OfB64/vJtXxerzmenzKOujr/223bwjUmx9KO/KahIWj20UcfXZ+m\n6Y7Fgw9pWDD6tvHjsfq667J/Ghr8Sxk3Dmhu9hf29IQD7esLF4dQXWRY+tr163278p18dneH95bz\nLS1hO9Kfpqaw7e5u/70c8+/k3vKdtMHja2vLPjdsADo7fV+lX3194bOS4+bm8F563N3dWTvSv64u\n/zs1kQq/t8Yp7XZ2Aq2t4W97enx/dtjBb1TyO+v51NX5Nvkdclt1df4+/Ozk+4YGP7a+vrC/fB9+\nhhaD5WOrT0zcBl/D/ZNxCMkYeGwyJ4DsfervGxr8eLq6fBv8TJh4DvPxhg3+erlnXZ3vb3Nz8fOX\n+0sbPT1ZO0C2JoBMMNm8ufh+PT122xs2+PG0t/t2urvDtqUdmaf8fKQdXqt8HsjejVzPY+dn29Tk\nj7u7w7kixOuN7yf34fP8roHwXck4xo3zv+3u9s+C3zOvMQB43/uCZpMkea544MU0LBg9GhszRiHE\nTFcz4J6ecOLFFh+3xQsFyCbkxo3hYrKYh7Uwm5r8+Z6ecHHq+wLZi+TJIb+VSc2kxyJtNzcDkyf7\n/skkiB13dYVMSvoun5rxW5OWn1tTk5+cfX2+7+vXh32W/upJqttjBrx+fbg45Bre0GR8QMjUpH3N\n5Pj+fE9eyNLXcePC3/P9NaPv6/Pvz2Iscg23x0xFxsBzSG8G8j3Pd5mnvEGyUMCMRvdFvmNmyH1n\n5iLETFTa0ccNDeH6kc+GhvCe+t2sXx/OR2mPhYyeHj/HmptDBi/vRG8M+l2xsBMTwpjR8vsZNy4c\ns4yPhan2dt+fSZP8eKU9HpseP/enuTm7Lz9z3nSE2toygamfNDwY/bZt4eCZkQvxwC0pTZ+3fqfP\nW4vM+m1Dg2cMLB10dfm+8uLkfre0hFKTdQ9ug8fOE59J/q+rCyV6oVILFcjGzczSYqL8fFjy4mfc\n1FQ8aSslflbWe9CaG5NmbF1doeTKxBshM0khZvosOHR3e+GDpVFrjHxP3gyY0crvhVhDsTYUlr4t\nbWH9+nADYKbGjImfg8V4eJNlqbead8nEc5XvJ8+ctWdmcLxBjBsHrF3rf8cCjPy2tdUWCLkN1lpE\nO9YapFBnZyjY8AbI61c2HbnPpEmhcCTPbf16e13z5tLZGdd6WIAUWJvpD38oPleChgejB8LFIoO3\npDHAY9dMMfUZ8DuhqJVyjSVJWhvO+vV+0W/YEEIdfE9uz1IPWepmBsBSJDO4chtRKYmZGTnfX0gm\nEi+YcePChWpBV7wB8bHVN7lvb292LO+NGeD69fZ704xJM6/mZt+GaDuaQWltkLVG+S1L//zOLKas\nGaUFb/DGLeMDQgbDGwqPk7+3iJ8pa7Z6Y2dYyuqr1v6E5L6ayVsQVqxt1tas58bPm9dAU5OHJ1jq\n53HW1YWaMDN3eQYs5YvUPXlyqB3z7+Q+LS027Nbd7fvF95k+Pfvs7PTnrPmgiZ89/6ary7cjfbUY\nPBDysQppeDD6rVvDXdFSlZg03guEk0+rz3y9NfliUr+0wfiznmiaYVjE6qQ+xxK1vneM0Vv9ZXVT\n48wsYeq+MrSk4QW+Pib1smRaybOQa+VZsLSjGZmGBuT+GrphhsESMEtYQDG0JGNgya9c3y1iCZDn\nYXe3V+s1BMMSrhC/P4YRLC2PbUX8DmNYewxfZiZlwXYsQOkNkCVd6zy339HhnxULcgLdrVnjN+L2\ndhuu4g1tzRobgmLohKV4frZ6YwIyRivvSkOS0q/mZj8O6Utrq+9fT4/fODWfiEFuloYC2Ez+xRd9\nP1hoqYCGB6MHQhWbF56FZVtkqaWx6zSz7+kplkI0PKDVc7lWjlkK4cXGi4CZLi9MbpeZmPShtdW2\nS/CktQzVQlpb6e62mT5rH0ws9clY5VP6yPYHLVFWii3GYAc2sDLxfWIwl8WwOjrC9y2/2bAhVLf1\nhsIGRv2c2OBu2Sgsew8QajSWdsGwFG+4rL2wNMxMjSVWfs88hxijFoqtJS2FWxtNX5+fL5Z2zIZW\nYaz62ra2UMu07FAzZ3qm29rqpXdegwy3ynl+9zwenr8dHcDUqb4/ltMGO1PItQxxakHNgoL4Gvk+\ntlaEycvYqqThwejZ7YwXe1NT9iB22sn+XW+vbZDShhCLqTJZGB//ntvjY9406urCCWkxdy09C1nY\nXEuLXwjyHOR3MSiBJ22pydDX56Ud7ov2KLK8LaR9GVspqIRJtKrRo0PNQY+H2+b2LEk7ZvuwNATu\nE4+Tr2HmHjNOWr9j/J+lNPkfKJaiefPQTJcNk5pZaobNYwJCOwtvBuIZBYT4PmthloGa1wbPK57X\nkybZmhj31XqGXV2+3zHHChag9EbDfbckXH4mvLEzc2WmL+PZf3/fRswbRjbWqVPj8By/cxaWWFBk\nnmHxOWbwlpZTIQ0PRr/99uHL1IY1hl4Aj/VqD5wYLhaDdISsxaPbsh4sS8ZiPRdiTFCIcWVWo9no\nywuCGRZvAMy8GAKwJMlyMA+Pmc91dvrNoLu7WGXdaafSWG3s3nw/IR6n3IefC78L3lwsgyHfUzMX\n3qz5nGXPkP9LtS/EwglLqWzQ5XFwGyw5Wsxfu9zyRsQCUew9C7W1+WsYJmBc3trkSr1jCxZi5sXM\nm7U99tJhWOaJJ7LjmTNDDYmfC3trMdSiBT7G4rXhmsfJgh3j8gwFyYbBz0HeK2Pr7AnEmyxvfswj\npB9jxqCINA7f1+e1Fm1Lq4CGB6N/4w3bTbGcZMoTyZL6ZJJqiV42ithE1cSbDy8qXkgMOQFxn2mN\nJWqfXfYasIyo2sOE+8Xj1v3nT90mS0a8AbF0oqW0deuK72ltbkLagM4qtgWhcV+5L5rx6HO8wDTj\ntpi4xtQtjy/uq76vfFrSFsNpfI2GSbSrJW/EbDdgaZSZF2PKLNFz37XmpOcwP/tYDIk8K4EXLGjG\nsgnx2PiYvZg2bPCChYYEeVOS8bAWwS66lqspa3AsbPF9GCLS2o0IHwwj87pjn3/uK28i/E742VpM\nnteWZawF3qIS/bZtIS7PuyUA7LZb3NLMzNBidhbj3rgxZKo6wAgoljp58TLxIuAJbmkavPBj0mI5\n9Yw3N8v/XXtg8L0sbUUzBmb68jt2A2N1u709ZBilvC2s/sgxazTW89F9FGZjGdk1Y+dNjlVsfj8s\ngcbcCkePzhagZQeJbVaaEbIxWNrR81af4/fANhltz4jFlrBEbG34lUiG+tmuWxe+N/3M5H9Ly+Z1\nx/3kecXrh8esN1GGYCzhS/iHboPtH8w/eJ1YWr4WKGSsAuOI95fuHxtshU9YMM3GjXbfpY1yUGYJ\nGh6MPknCXbFS7w2mSrxe2FjCxEY4Ib1YWNK0GJmGUVhS4oWq22dNpqPDNgZ2d4cYnywkzdR5oVjS\nG4/RklzlvvI76xrG9jVz50VYThuT38i9dL9iuLuc7+0tD1Fp4gVrzQOWeqsxeMW0OQ2vMGTAG4MQ\nbwQsXQuNGxfaAkQg0lgv98sKCmQjLfdDGBYLPoyL67gJjtaOjV8bL7kNXhtsn9JeTEJ9ff6ekyaF\nYxZYQ54JewixlscC2bhxtqt0Z6eH1HSEr6wx9qdnSZ/nNPeFx1GOycszkN9Ke+ycUSUND0a//fYh\n02IJD/B+2EAxc7XUQ8ZxecKW8jfWPqxa+mbpwbqGGRtLYdpLRve1pSVkBjwedtWSa7TUwEY7vaHo\nBWjBXDF4g6VrLZnyouHfWhivJjHGsgbHz0dDNtJHy8WQxxPbuBgmaGjIAnEmT7afc8xFFcgWIuPL\nuq+WayJj7ZphM1yjoQ7eNHmz0IZBa95o6ToGRemNoanJ3hSkvzJGngt8T8tlkPvI5ywNpaHBM+uZ\nM/09+PkAoQ3EinXgZyUMmGFQ3uT4mpimzl5CLS2hp48mrSlrjdxymVy3LvtkqIfHY/WPtYUKaXgw\n+jQNIQuhUgxDruUB8+K0VFJtIGEDkcb2NAPjF89tsAsX94uZPvdRuyBqZhmTCESSZm1BP59Skrsm\n6S/3T4/Zkq5jUJQFaWhskoltFJb3ht7ALQbDUAx7l2hBAfCRlnJvC0dn1ztuMwZBxWwyjKMzXGa5\nZmroSs6xpG0JHIzd832YuG1tu9D9ZklXj9HCvfW7tbQYhtxY27Q07KYmL8RoP3ae79L2mjX+ei2s\nSHvsu295P/EzZHhl+vTQo4tTfrAnj4xB+sRu0EC47ksxebnWsrNYkdXVuJ07SlIr++MQ08wpU9LV\nd9+d/aONMtaA2LCnPXKs6/gaPmep/pZBMTapmfTitZi7JdEzaSmKPQ8sn1xWzTUz1JLd6NH+OWhf\naEva0p4KjKuy9sOLUGsu0pb2DdbvzFL1eUPlPkrbO+xgJ9Di9vh6PeaYpw1rCzH4SF/LpDcFZtiW\nlsmYPvuf80JnrFf6wAZIDUfEIC09Hk5Cxt/HoBj9TGIbOsMhel3xdew7LnYzoHjDZeFImDcLPMwj\n5HuNs3Mb7MEmWgS3o6E4Xh/a710/60piSMRlkrVC7itvQPp+0g9Hydixj6ZpSiqQTcNDoueUn+wG\nZhkWAc8orJ08dh2QXdvbm01wgRAA2yLOC4nbYGLmWmpBxcYhxNF8Qg0NtsTKMBOr1DqKmDfDzZuL\ntQw9DjnPnh+ME3KSKX4WlqRtQVWxDVkzXWaMmiHq38XevXV/7ZJmeUXpzdfS0iqxO1hGT8B+zzxm\nyy2RYRHG4rVBLqZ9xKAoIL7hWs8GKDZ+amGmlFFZiJmY9HnjxhC6aW7216xdGwoTPOd5E5fr+Vp2\nCbYk8I6OUJiR9dbWZrtdWnAm29hYIALK+8XrduSY7ZSWA0U5vmdQ2auTJHk3gB8BaAGwDcD30zRd\nkiTJOwEsB9AGoAPAsWmavpokSQJgCYCPA9gMYG6apo+VvMmoUaE6x9hjueRK1RrkhPQk1wuCcXG2\nyPNi18zIMoDqDYAlVsCWOoRisIcVpauJjTtawtaRsXoSWf2xJDJO3KQlLybtWqkXhP5OiLUIKwye\nv7eYFFAsKcn1VjIpXtSWJ1apvloUY/qdnSHD0IuZmabGuS14UsNpWvgQbc5aKxZExAyN79PXZ28o\nmpnHtAH5zsLL29vDtgVqa2nx1zzxhD+eNCncGLQtoLs7TPPN42atXe7Z0REKHMzorTXKzF9L95X4\nxctvxbis4yW4v3oM5XiiQZVwxj4AX0vT9LEkSf4BwKNJktwNYC6AlWmaXpgkyTkAzgFwNoDDAOzh\n/vYDcKX7jBMXFNCTvKg3arJboef8Wy2VAcV+9HxsSTN1dbZLGEMNPIH1BsCk/egtiU7aiNkcrEnG\nz02rnjqFATP6UgtW7tPWFnowaI1CfmtpN0Ka2VsMm8esNRAZP99fiJ+39qSwYBlm4lbshaaYAGEl\nywPC98P2D55PvNFY74IZlqU1aWGC72nNZbmOIbyY/UaPtxQMaP3G8i7ijdoyVjOz5vfLMRSTJ3vm\nzlI85+ZnW4DMK54zzc0e2+/sDCVnfoZsbLVcq9mZgp+BBdWwXzzPZYZepZ/SR+11I/2S+1RJZX+R\npulLAF5yx68nSfI0gAkAjgRwkLvsOgC/RcbojwTwozQD/x9MkqQ5SZKdXTs2jRplexmU2uHk2JIw\nyklaMkl5k9C/5Z2fr415TMh3QCgdac8CLclq/JsZEPeFNQDexPhZ8aLh35Yy3Og2rA2S+2UZveS8\nZYsodV8hy6Cr4Q1tyNxhh1D65mutbIJA+VQGlUjw3CYzeH4/bOewvJ6YAfJcseY9z49YUJy2Z1iY\nOmvMzFR5I9LajDBIvRGJbYYhL63pSX/1ZqKdJ3i+WcZllvo5U2RXV5iBVUfT6zXDz8HSPBkqZeMt\nr1m99vmZWFJ8Ka1a7s/vhe0Z2m7Dbs06S2sFVNXWkCRJG4C9ATwEYLww7zRNX0qSRACpCQD+Qj/r\ndOcCRp8kyYkATgSAiRMm2Amq9ATSxBJgDCPXD5i/s1wM+QXyvZlZWl4qvCBYSuN7W54Xzc3hBsEq\nuCW5c79ZirfwZLlGKAZvxOASS0PRrnksSUt/taSiSd9P/mcGJH2I/ZaZrHb7s8YA2AFT7FaoNzRr\ncZbbDLRwEGM8QjHDPvvLW9Kd1nxjycl4E2FtkoOa5JwFE/CcjMULWIZmOdYMmKVrZvQcvDR5cgjd\n8JgsX3JmwKwVsCTOv7O0WI5L4PnOkA5rIPz9Bz6AIuL5yfe3YCZ5FsLUuY9WzEHME6oEVczokyRp\nArACwFfSNN2YxOpnAtYXRa49aZp+H8D3AWDmXnulZmGPcu6V+ntepJVIZ5aKrdsCinPU8OKxDELM\naDXGyhMeKMa5hTTuzO6IHCgjxCoxj5+lR1YfrXHyouvpCSOUrY2OtQiWyPR70V5Put8W6Y3G0lyE\ndISwZXTm6F79Dnnuafc5fSz3iBmluX/aA4Y3AWYe1sYbS+NgLXxmnmxQZ0lWu1datiKGEy1XUHYK\n0IKItKerQcnYOFbBEhRaWvwYVq+2E/qxtrR2rV2VTog9wngjkv+BcF1r12v2dGKJXjD1urqisn4A\nvBSvhQzpH2slGzaEzJ0rVemkc9Km9FvDsWWoIkafJMn2yJj8T9I0/YU7/bJAMkmS7AxAnEI7Abyb\nft4KQJmaFdXXh1nsLEgFCF+eZj762lLwgWTyY9iB1SZpj7/nY95QLFyacUWmmIHPci/k47q6UNpg\ndVdH4HIyMiHu24MPZgEp3A+WxC3G1NcXGr5YlZbjGMPWTP/558P3pnPAs2ZlYZIWFqy9nyzIK+ZB\npSGymG1Ft6fJ8ssvVUCDj7U0znYGHSRlBWbpOBBL+NDPkwURIS19C8mGoe0C2r4BZPOUy06yn7qM\nkd+JpXFxPIW0w32Ra4RY4LLes4aVeLO0oDXt6cTzrLk5XhDkqafCtVfOhbquLkxqxwGSa9Zkx2xP\nkLG1t1cdHVvWj9550VwH4JU0Tb9C5y8G8Dcyxr4zTdOvJ0nyvwHMR+Z1sx+A76Zpum+pe8zce+90\n9b33Zv/EPEpYumMpkic+X8sLjNvkSlGM8ckLEpcslmo4+REzAz6vr2f1VM7zBsBRexZDY7Wf8cNJ\nk0IoiBcyR+zyYrLsAvwMuU+slUh7HI2rc5Kw9MyJoKQfjL9z/g5haq2tYTATRwJKv9vaQu1GB9f1\n9IT52GMRk9zXajx22EPGEiDa2/3YZ87042FGx33idiymzOd5nHrMvClZdg7rf/ktV3MCQoO7hifK\n2W30mmXp3RKgWBORtqdPD9+J9E9L7VYWSMbdGQ3gdcr5mTgrK2/ybMS38kgBwMSJKCIp66c1edag\ny9lwmDdYAlRDg8/u2dxcGEOlfvSVMPpZAO4H8F/I3CsB4BvIcPqfAZgI4HkAx6Rp+orbGK4AcCgy\n98p5aZquLnWPmVOmpKuvvz77R0tverHpSc8Tn9VXnkwWNqrdOLV0Ykm83C+5ZyygwZKMLWOgTv3A\nKhtvACxR8xhY9WViLUHnbefnplVMa4Jr6dGSNnnRcISjSF4sufJ9eLOOEUvSrIbzuCyPCMZuOdqS\nA2+kD3wvIMTumdFLu2wA5ffA7elna2G9DO3x7625ws+boYauLltKtjw6pD1tk+JnzMIHPxMmrf1Z\ntgZLaOP12NZma/J8T2aS3A6/W34WvFmwcTWWpZNtFLyGtAAZk+JffNE2lmtIlHkNb64M5/Hmr5Oa\nsc2B6lAnu+5am4CpNE1XwcbdAWC2cX0K4NRy7Ya9qLPzOAP+gd18c/a5dm18gbHBg8uSycucOjW0\npstDPPzwYomIJxerzGvWhIUJhAGzVMcGHB4b4Pt11FH+e2YMvCB50sqYGffVG8pqt5/edJO9OC3m\n0tUVSh48fml77lzPvK+6ytfLPPzweLAXkPX5wQez47Y24LbbsuOWFv98P/UpL7098QTwmc9kxzff\n7K/56Ed9H2+6KeuPtAlkz/7GG7PjM88MGaA8b9ZKgLDEn5CWyLTUHbP73Hijfw5nnumP+f4sfPA7\n5Occ84tnmMfy+dceVyyIMLG2JtKh3JshBD1mnpMMe1i2A74v+8Azzi2/mz/f3/ecc8K25Jr29lBw\n0CkMZPzsXtnVVWz05YhaTp0gc4+fhRY8LCb//PO+bS7oEoOF2IuG4WdLgOXrhXd0dPj5zoJahTQ8\nUiDsvnu6+uKLs3/YJYvVcIsZsfrKk1r7ocbc9koZn1jy4POlDL1s9LTwUDa+WIu3ocFOL9DT4zE7\nntR6InEfeVLoiauNggxhMTOwvB10xR9+zjI2WUjMCNrabMmMYQfedNjWwBI7e0fwpsSMxILteBNt\nagqzHUq/J00KJSmtrU2eXLyBik+5tNfWZhfc5jFoaMmyL8WgG30dEGp/TNpDht+btguwRqwN3nrM\nAs/w+9Qag/xOS8Y8lsmTwxxOsfgQS+Ni7aapqVgCZtI2MwvOa24OPX2A0nVbeTzsbMHt8bNlGxJD\nW/werGfBOZyMbJiVSvTDg9G///3p6v/7f7N/YhMs5jdqGTKZLMMSUMzIhFgCYebPL4fvHVNZLbyV\nNzGr3zwhNbzC+TmE9ALge1rSnrWJ8WTThkGGXXghMbxkaVfl3pvGoy0plTdf+Y1uzzK08qKSduS8\nENsLePyatKGdGXAs5QCTxfw08UbHEZs8b7nvVgoA/ayEWCjgcXB/rPkbC5zTGwAnDWMs3tI4LWhL\nl7NkpqaNrfJpudFq4VCPKxaTUorKpS+wNiIWThoa7GppvK65X4C9xnkcnFzN/a5m0M2Q0HbbFTMj\noFgK0d/LNUCIe/LE451VbyKWUZPdGK3FpqVE9lSwvBA0tKSlRF4Y3EeLqUh7FgbMi0pLEHox87Wa\nYbBNJKbRcGFka5z8HvgcT3ArFoEZE/eluzuUdizjtbaRCDE2ypIX3yf2DrXmpGEeJqt+rY7i5XfF\n12hi4yELE7wB8DtmhqHdeVkCtjRhnatF7sMCUUw7tjytJk2yx8T9YLuJSKnskcZQqbZhMFxjCS7s\nIsmMkdcQJ4/TZQKtwKdShbn7+kIbnOUGrPkOC5C8lhi9sOyCpeZfGRoejD5Nw92ZdzY9IbXboSWR\n6DSnQhr/t3x7Gd+1MDtdwo1zVbDKzmkC+KXp++iC3CzRWkEwDO/weR6v3jyE5HrODqilIe2Kxn2W\nc7xZWVgyP0ORzLS0zkyfx8nSLS8gOe7s9DYCIYbE2HDNPtD83siYVVSGjkPltScHPwt+3u3tNv7O\nDJiZtN7cdHwDb+BsmGXGwO8qplnqjdCaW9bmU1cXtm0JUNoQa9mWmLh/cjxpUuhpIqQ1tBgkyutK\nuxRrjxqZEy0tob2LxxxLX8DEc1v+Z2GC4USOd2F/ebGPyP/SF57vAtWyhsD3sfhbCRoejJ6ZQE+P\nHVgScx/TKrRObcyTWksgLGVoAxYbVliqYVW/qSnEwoUsTUSfFzxQu1fy97wImUlYeKSWtiwNyPJK\nkrEKMRNnLSem/VjMm7UiuX9rq2dObIjkqlrTp9uLmt/F9OkhXi/PR8bGrmnMJDRebG1iDOfxM2GG\nb+HinMtc7qWPtbYgaj1LwBrCEbJ85Hlec791WL8V1CRjkd/q9vg823C0EBB7tpbrKhO3raFQ+d4S\n5lgIZKiHtUVedyyEWVWgpJ8WFm+V9WODPo+R34msa21Qt2xv8r/0kXmYGKl5LluaSIU0PBi9Nh7y\nJLT8gmPuijFMNBZlaPmD8+KNGcR4U+AXzpKZpbYx82KXPcY3WSvgQCb2xbekMH0vq998b2a2LDHy\nhsJ9tGwKrI3wfWIYOUvOVl/b20ONhxe7ZdTk/vFCZ/iJITIepwVRsRtezFYUw7aZqfBGZMFY/N6e\neMLfkzHvWLANP2+eB9bC5w1SG/P4GmnPMuhq+EeoudlLydoVlaVn/VtmgOzSyO9Yw2m8PngOW/2y\nYmaYtHHXYvI6SZ2OI5Gx8f9A6O3HWhZr+xwTwpsEz0lehzKveK1pQa0CGh7G2L32Cr1uWA2z1FrA\nq5Qx5hZj0kL6ewv7Z/y/EgMfb1C6PV3FXV48T3ytPrPfLBdUYMmHc5boZxR7Dvp5WMydNxe2V/Az\n7+y0n0tM2mDM3fJl1mq6kPa/Zy0CCCVt9gZhzJQLmbe2emakPbKsTZQ3H0sT0O9Qzws9Nm234U1X\n7mNh6yy5WoKHkJU3Sm+W5YyxMWmdNy5L0+D2LBsOj4e9s7SgFttoLcM0t2/lM2ptLX5vpbB4bfBn\nTVUYuTU2bURnwcZKkc35fVjAbWgIGbz8zoBqkwkT3kLG2IYGj+Uypq2LRQjFjBIxBsfEEzimvgOh\nJKENibwjs2uiFZnKOzUboixo4qL2AAAgAElEQVSJXhvpeDw6slLOc9tW8BaPiRe3pRrz4uAFHpO2\nYh4uzNys/unnY20immFY0a6WRAfYHijsxVFXF0YmS7/Zrxnwi1oWnd7wrbnJxSxYWCilHTKj0Ncw\nY9DwkOX5wYGAPDbt460hT/6dFhr4vVkYuXZ1ZOiJ54q0LcQwa11d6fwucr28xzVrQkZqacqWNgcU\np8wGiguCMEzC70e/T964eNyauXO/5Xq2FXE0roalgGKko1yQoaLhIdG///3p6jvvzP7hQfDLYrrq\nquyTgyxiWHxfn10uDAhxcj0h2TebiV+2XAfENwPNdEph55yugO0WTE1Ntkujdge1JFJm9NYYeFJ3\nd9t1PnlzYYbFmyuPTY//qquAk0/2/3NfuG2e7PK/tF0KomLXTX4n8p3uNzM1fp7WBqafKx+zBMbq\nvNZIgbiHVuw9WJuFjmdgYYGZnWW34XnNkBOn2WCmYs1ZboefS09PCEEJxdJfWFI5Ry5rAzDfx4Ka\nhBhCEiZbKpWwltBlbMwvWOMTYucErRFadji+hsfARm8+5nfMa9Y922T8+LeQHz3nugHCCS+TTx78\njTfajCam9uv2rPOzZgGHHlr8HUsvEtXZ1+cNJRs2ANdeWzwgPQnlpTHjOu88f8wLidX3WEUka4Kv\nXw+sWpUdr1oVV331PTWOPNPNme5uP1HnzvXP7re/9QuHk09ZEFRPj2ckkyb5ZzV5sh/b4Yf7+6xe\n7aNeu7p8VO1RR/n+dnSE0rn09YorsuMvftGOPOTnoGEHC/dmidmK/gX8O7nwQn/NOeeEHj0ci2AJ\nAnoB6/uwJM5txDYl/p89P3j8QDifgew9WN5h2qhoSdE6MR1rypYAJf047zz/O45o5ijQmBah7TLa\nQUG7tlp+8b294dgsu560BYR+8iy98324r1ZAprZP8ebG84zTJMh13FdHb62AqWnT0tUPPJD9oxOI\nMYwj31u1IHkX1BIGT1rLD1dXbxeKeTswLq6xQfkdt8fXa+lMp7IV4rYtpiOkNzsgTPugpVogXGz8\nO1afWaPglA8swbAthav1sApuSa48jqlT/SLt6vK4bXu7v8/06f6Yo2eF6up8+ofJk/14tHQtNGmS\nd3HTUIzlPsnEarccP/GEv37qVH++vT2EJmK4upaYee5YGL70wwou026MIpRobUTbObRRmoUpK56E\nhTDGmjWMUsrtk7VGbdexDP4asrVsPnp8pTxqmB+wAZzdgrmt9etDd0cZL0N/srFqTYg3aGmb1xJv\nLLFEhNpTCm+14uBAuLOx6inEk81yyWJGr1VZnij8sNiVThtZSqUNYLKMpKw+84bCNgeGRRj+iUEU\n1oTQjEn6OHWqDSlZ0gMbkNh7QmtI/FvtswxkDFYzLMvALedZ3bVwWk28wLT3iMY0uQ1ZVJoZiAbH\nEhYzLMtzKua/zC6SfX12sjXLWC7XCzG2LqQlS57jLGSw0KLhImG+PE6WsKV/PE5eM9xfyzjIm5v0\nR7ep7wdkwoF8rwtiy7GW7vWa0BApr3sLi1+3LtRErPnOfeEYG15jFn/hzVLbleSe7E3G762uzoa3\nuH8s4FqwbgkaHow+Tb2Kry3LLI0DxRZ0K8eJlp6YkfFCYUbBu7Zcy99z8AO/bJmEWjK0cE2eqFZK\nAe4z+ymz9KTVRO4LT0jeLDU2zeqwdinU2KD8jjc6gVq475JIip9FT08oGbEEZpGG6viZcvpoTmss\n52LMmnMLSV/b2sJsoJw/nRethgg52IbhOGaummFaMCMTb9YM51hwEjMmNm5rLyb21oppi7pfzIB4\nbWip3ApM4+fBc0Xne5Hr5PtDDw0hDekTB6CxwdLSSIDiDbiUsZX7PWmS5zvMPNm1WttI5BouEsKe\narzxMBQlGyS7M7PApQ3kOqCNIUutkVdAwwO62Xtvn+sGsCfFHXdkn9o7wJrIzOg6OkKowYImvvKV\nYibEjB7wqn5HR4jny/mbbgq9E6Rf48aFHh5yf8leySooM1refGLwh1yn+3LPPXFDMlC8eBl3lOfG\nbooHHZTZMQDgmmt822eeGW4eLB0C2XWCs0+a5KP9eLP6zGf8YrvnniybJZBhyNL2UUf5tm+7zT9P\nzl4pmPPRR/txrl0bZioUam0NIzGFtF1DM0OWdNva/PXf+Y5/JuedZxvIgbgbq160LBmysZqxcP1+\neYPm+cIue2zYk3ch7ey/fyg0xbQO7peMbf36ENJh5qU3MZ5jN93k+zd3rm1ziLmu8nOVd7nbbjCp\ntzcUIKzC30zaFiD9ZymdoWR+bpbhnAUYhogsg7/81hIUDaGhZvnoh4ICrxseWAzj40Vi5eqoqwt3\nUN2mfFoukIyHWru69uJgKYiDKFgl4x08JtnJ9xb8JH0AitVXIVb3eJw9PWEaAGnb8o1m7yO+no2u\nOvK41CbE/WAplcfDk5pjDTg1gWY6PDb5tOA+xq77+rxWwEErLIFrxixkPW+NwXIgTczQa/VRSGuB\n1jX8PfdJ53KJ9VeIHQ0YDtAM1mrDgo64P9p4rBkpM7q1a8N0FuwBxJqLtblxwBZg123lEpaWMVhr\nLpb7ojbc8/2lPf6e3zE/n5hGzhugEKdDYE3RKIxSM4w+SZIfAjgcwLo0Tae6c8sB7OUuaQawIU3T\n6a54+NMA/ui+ezBN05PL3QPbtoXqMw9Iv2Rmokx6R5RJYKWM1b8RaZXPsZrc0OAlICDM3S0LpbMz\nnHi8obDrnVx/0EG+r9rIBhT78XOAlcbc9dja28ONiSEtadvya+bgEPmffyfE6VytVAF8P3l/48Zl\nErscy+/2398/H47eBMI0AdLm2rWhJ4uQtD1rli0I8Gawfn0I3VjCBG8SQq2t9kZw881+fh59dMhU\nuLCGxWwsLypmolpQsYykLFHzNfp6Ju0CqWFN3R/55E2RtQiuqsWkjeExW0FLS7ycKDNMZozNzXbF\nJwB49tnQMMpjsYQwDdEwdCK/Z6cNhkx5vvPYeDyifWrXVq6Ny9+xC6r0zxJ8KqRKKkwdAKAbwI+E\n0avvLwXwWpqm5ztGf5t1XSmaOWNGuvr++7N/NKOJDW706CxUmdUgNjAK8YJgv2LGlBnLZLWTMTH2\niRVitZonME8Uy/WKSS9K62VrjcRycdN+wELs1cMLmZ+JBVexlMgGW4ZntIaiDXIxw6pOOse4b0yq\ntAzdFnNjCZClTB4D91sHvPDmHrOzyPcWxKi1UH5elicWY9PcJyvEnpkKb4oacrK0Qu2gIH3hxH6W\nRqjJgqL4nciYAHvz0PYUK7hs3LhQ+xLiYDTAdpl86il/b54T0j+dA75cERDWslmD53FZhmh+h3V1\ndjQs98tybQXsZG+0TmpZYeo+x8CLyJUNPBbAR8q1U5Jee827x/Gk4R2cHxrg1TLDtzSYTCwR8Qtp\nbrZTyPL/3DZ7fVgSNbfP8IpeBHpD0bAE35OZCtdE5YnAC48XjTVpLTwyFpDDC5/tIsxI1q61XekY\nu7U2ag2V8RisSmMaUmFjp25bbw4sGTJDZw2Jf6u9KvT9rA2ciTFobSBnAy6TZh787C3PDcAniZPf\naalVEzM1NgjyxhETRKx5w3NVu1/yeNheI/ezIEEWYNhNsaPDH8unFfgkFZ+EtB1G2wqA4mhzNsQL\nae3LyhzLnno8NhY8eb5Z3oR8fXu77xtrxJZmVyFVrwOE9CEAL6dp+mc6954kSR4HsBHAN9M0vb9s\nK01NHquLSVIWxazPWqrjycbnrYRk1s7LfeFFpaNRrYnCC5wnk1Wfkr8HQqYjvuyxZ6L7GosBkE+W\nbrm/2ntIfm8F0DCz4ftYhjzefJlh6gnLRjM2zsn12m1NfsMueMwkWarnvnKucm7Hcm3k52BpaKxZ\nMSyl22DDNZPelC0jpvTPgo40zBezSfFGwxClPqc31ZgmaDHpnh4PizHub20ivBHrjYg3PSaLyXMq\nYR1MJ/fm+S7PtLMz9DiTOcbV0JhJM6zI70U2FE5+1tAQlgFkjZhz/LDAw4nP5HmKAMz31oVZKqCK\njLExSCZJkisBtKdpeqn7vx5AU5qmf0uSZAaAmwFMSdN0o2oSSZKcCOBEAJi4yy4znpOAKSCUjK1s\ngoCHbnhTsIxDLF3ra4S0imuR9eL1eUsl06quvFhm4jEjGxMzmxhcwpPGGg+rzPx7ljYsuAQIDVUy\npvb2ULXWBidmWHJvKb0npCMsmXlabqd9faHBlseh2+CNk6E6lp64j9qQyMU/5B6WpwQzCWaGGq6x\noASGE61rWXJm4mcSM9Bb6QXken1P7d0ipOebZcjk9tnmFBPCGKKJJfrT67RU4BNv7jFhw+oLr2XW\n4BneYbdLCx7Wbq6szfJmJXOVYeL29rCmsKVtWBsKwbHJ7rsPbsBUkiR1AD4JYIacS9N0C4At7vjR\nJEmeAbAngNX692mafh/A9wFg5nvfm5qeClpd6ezMdjhhLtOnhww9Jm3ww7KkTQvXZW8V/o3ObWEZ\nu/R5XkDaBZFVWcCeeEA48aycNjHfdEuSYulAS9r8TNiYZWkdnKYh5usvBl4594tfhO6p/H4YsmCJ\nRS8arTmxNKqZFNthGP6zND6OxeBxWjBNbENmyZmvY4apsWuGl+STGbGlWelNuNy8ZibEfYzBeXrO\nS79Z8Iq9b2mT36fl8RTbRJjRAjYWz/niWRPjecAOCTzHpd/t7TacBXjJnx0U2ADNa5bfMUMxbNez\ncHcWkngDZLiM71dOGC1BA4FuPgpgbZqmBSAsSZIdAbySpunWJEl2A7AHgGfL94ImML8IdlWzJuRN\nN1UmrcegIDnPWCFfw3i5ZbxjA5+GesoFMjGzYwnYiphtaipOriSffCybhPiu8xh5bJMm2dIw9wUI\nPVPk/BNP+OsZumloCBeN3I8XieTiWbPG9/XQQ8PcMJwxkqUn7SIqzwXIFhQvEh6X9Gn1an/MUhoL\nCB0d/hlZajpLXQxX3HabP//Rj4Yak+UhpDdxLY1q5s9Mn/FgDb/I2KxNsa7Ov0/tsSPj5U1W7mnl\nFgKyMVpSJ/+vDclA9u55DPK+dO745ubSgU/8ntvaite41hwsCFHb6KyIXhbOeAPid8WbCAtewsg5\nAljbhLhflgDHLqfcdq0LjyRJcgOAgwCMS5KkE0AuTdMfAPgUgBvU5QcAOD9Jkj4AWwGcnKbpK2V7\nsXWrP+ZJyJZw+Zw1yz/sWbNChmphk0Dc35qlBj2Z2bCipTFL+9DRkcxgLdybjVNsaLWMVrxZsXSs\noS0Z2/7725AWY5M8qSzplBceLxSWQjTDsjZjfn9sh2FtgeEaGb/OmcJwjTYkNjXZVbfYIFcJLMbM\nm7Uyiynz/GJfcL358iZhxS6wIBDznOLoXmv+1tXZRlvWJtlVmaVDNuhahUm0LYl/ZzklMIO1NC0W\nWnT0M0uvFlTDWHxPT5j4S0vA3D9Oo8ASumbW/E6sd8iuvZaHnx47Cyd8f0vL1gKmthlyn2K+/SVo\neARMzZjhk5oxoweKAwdYGtMh1npTkPMsHVkBQWxksx6gPscL01KjmLnyomYcn9vic9qDQcZjGcr0\n9UIxTJKJ1VruNz8rS8vSgSBCnLKBFxAvZF4kjJ3HmJS1IOQ3+v68qDl6kaVH1kQESmDSDFgTM666\nutA32grTB+znpuElDuqST5aK9fdACMUww9TSNW+Klg3Jwtn5d1pQ4LnMEAgzJK4wpSVT7WElm4u0\nZUW3ik1He3/JmNmoymvTwLQxbpzdF2ae/H6Yx/D6YCiK5zJr5FyC0OIrDHOx8VZ7Lsm17IHo2k5m\nzHgLJTXr7Q2LO7Bniiwmxs4toyPvvDHsjyVQjaVqhq0NgEKMn/GL0n67QiwZ8v35BfLY+HesGst3\nGqvja3jhl6IYQ9PPg1VbS6JmTYMzRcrilQUzZkz2jq3NT2cOtQyP2v6iGR9DKpMmha5prHbzWHij\n0wyU+86/jcVEsBSvYSHWjOQa9h+3JHp+rzFhRttK+DxrltYmwQxOGJYWQixDrsaI5T6s0cSCxPi3\nFsw2bly86hNHllteWcxsLfiFpWuGorgNraXzeuP5xBq8XCsb28yZYVwCPxOeV5ZnFwtF/K44sE28\ndWLeVyVoeDD6JPHHLOHqBQ4Uq+DWDm9JzUI84Swjm+UDDoS7vYW3cX1M7hcbMvkanoT63vI767z2\na7ak/pjUzZIZMyOWBuW4oyNU6/n+Qux1w8yb7RkA8mPHIrdli40d6wluMTXdB21I1PAP358jri3N\nieEyvUFrn2ndJ34mLCFbzJjfG8N8lkbInhkMs/HYuT0tIPB75r5bUr9VXIY1F362uq/8zHlNcDSn\nxuA5ilckZA3TbNwYMmzG+pm5yz0Z4uU5wQGPQm1tIexiZRplfL2vz85cy89CajisXRuOk58Pa3/i\nMtnSEgpNnGpbSMbQ1WUni6uQhgd0M3NmuloGqWiJ2wSkXC855mEUHTcAkEe/DYCwo43uOyDL1SCv\nfHsAje54B/cnv5VrhQ48/njcfUNmjugBIHLHgR/8IJaSWyj3Ufo2ivoymtqfx4VWDjgAA6annsKy\nadMAAK8gfE5CwuZGI3xW4tPwOoD5hx0GAPjr7bfjGvrtue95D/Dss7giSfAuOn+8NX8ES21uRr6+\nvnBankkD9eWMJ5/E7a7fspx7AJxy55247JBDCr+V5zYfQP0RR/h7XXEFfrPrrlhFt1/4ve8BX/pS\nIUryGdf+7v2d666dy6ZNgyyvBgBnuLm5RLV7uju/wp3vRfa85bej4d/PCcuXY/lxxxV+e5y0te++\nvsGHH+5Xt5cmSeE597n7air0Y/FiAMDPFyzAKPj3I3O6yV07Z8uW7Dr3Xo+R/kpEKmDnnamELENr\nZ6dn1JMnh5s8b5bigCDxJt/5TpasEAizYf74x8A3vxneR2P07GbLG/cllwDz52fH4lGj7WHlUAW9\ncbLwEYstYVdj6ZP7XdLY+BaCbjo6kHeLYycAYnLZE54BC/XBL3p9nif1dvSdMJg6Ot6erh8FQHQK\nud9GeIZ+yw03FBbJBvjN4roHHggWDzPP7el8A30WXn0s4MHhkcwgcy+8gAsmTAAAnPvlL2PJ5ZcD\nAE5/73ux4umnAQBznnmmcJ8dYD8joW3qezneHsDtt98OIHs28nzOes97soMXX0Q9gL/Rb29w760H\ngMQm5l5+GQBwJY1Bk7yHK6dNK/SbZRRm8qOoj98FsPnWW7P7PPdcUbsLv/c9AMBtSYIZ8IwKAG51\nfa0D8Cd3bgf499kDe4PMPfmk2f8rHZPjuVYP4Dp3fhv8ux8QbXajOPlk3H399QCAyQBEzrwP2byU\nfsmz0uZMOc+LXo6XOwavaRTCNbjMvVMZl6xbfkZ51tCJcqU22l//2kuyGzZ45s4eKwzrsgbChlnJ\n4MpZJVmL6O4O0xQIA127NoRB2Z1Z4BP2FrM0dg0NC7GGxGkcNNNnTZQN1kBx+u2YO3WEhgejL0Ey\nHDbRfJSOG4eBRlIreihJsJ+TmKqmhgYc/8ILtrdCP+lg/sdJWyfsuCNW/PWvADLGYQAPyI8fDyDT\nigS9FRlldi3e189+ln26RfLhTZuwqTHTz5aeeip2dpc9Ac8AN6KY8VVKeacRjIIfzxG//3128L73\n9bNVT8cde2zxSXFFtaCdCmkmgL1/8hN/Yv/946l8Nf3hD9nnpEleAm5owC2LFgHINkreROUZDYgE\n62bjMmep1EZ7sevNnOkZo2wWRx/tU5vPmuUZ9HnneWm8tTWsbSBaQVOTF8Q6Ojyjv+KKEHbRfeWN\niI27DC0xnMcGW3YI6e72Y9a+9kBoj6uQhgejf/31wiE5UBWkLgA4kifs0UfbPrYDIJZCSkoeNaKr\n3f0IfcShAK4wpOC8k+YBYPHllxeY66VPP13YCNdMmBBIZAtrPQbZQNatwxwJViEPi8XGQt+AjNkC\nQG7nnYu+7zcZjPHwTZsAAE82NmKaOwaA690GcBCAvWgT7XXP+cgXXsBS93yLwrcVbQMgAMURkvH0\nlfLew/2ib30LALBy0SLMXrIEAPCX66+HY0X4I4D3umM2vbOm9ksA/+/TnwYAzH/mmQF3Ke+YfLVU\n0XqKBb0xRMPYtLZnaQMxux7LNfJpuV6zMZqN69orSdsBWaLXCeos2w5DRH19oaeNFSRn1Qhgr5wK\naVgw+hd7LYU5pLybsDm3WPNJUjguyfRFMnGSl1YrzUn48Y9nn7/6Vdl+VUUvvlhg2la4wx0VNMGv\nt5TyttiNU9DSI/rD+Dd7mW2lY5ir4N8BNmzApY7Bl51255wDALjC9Wt+jTei213/Dvv2tzPJ6+tf\nB7761YKtZS+eK3vuCWHPyyZMwFHueMcVK5CfM6fkfYSRLnr1VWwDkKvhGAI6/3wAwGz3CQDvPu00\nfMA9vyNpPLMvugj5s88uamIqvK1p5e67V6dNuY0GLS1YfNll1fa+QNb6MoUqdjPt6gq9W4TB6eAt\nxsMZmgHC4CbGvHU+qZhbqpxnQzNQnKSPNQtd35aZO/eVpfhYZLt2OOCobd5cKqRhweiroXwJ3LcW\nlHPGyMGmrvKXVE0szVl4a62oP+8gf/rpgREX//7vwDe+0a/7X0CM4lzFSBY7hnfg2Wdj1hln4DF3\n/jHXZ9mkCvaEhx5Cfr/9sn/KMHmg2PYhmtlJNd64ZIy98JDTi/DQkTCUfH199F2vUf9vpudW6cbf\nXyYfk+Jj+H3ADNldlL3ptPdZqfzsOnCNz7P7p6VF8HmWwNlNk+MT2J2YNxcrJUtfX+iayZsQ58+x\nXHp57LrPZWhYMPpd3vc+L3lXQfn6+vJqYQkMNffaa9nBV7/q27z9duQEf6017bKL769oMddem933\npJMG3Lws+IXOGGrmCKmGdvBmOJEGZ2/ciGfGjgUA7L5kCS49/XQApbULITHi5pyHRy1JIKI+ALPl\n5HnnAcSoCprImjXYSTYrLiJTJVlaWb+INdoykKSM84nGxsK5UoZ3oSZ9Yt264vkhmuwddyA/gI2r\nnBQfJWa6sehaNliyQVSYt+UerN1vhVhajwXosaZhBZdxHAwHomlXXisNCkv9OvhSS/icDkZHQldA\nw4LRd1XB5NmzpiKSyexc/uT3CxyTfyBJ8MEzzihcHjB5azEMhO66C3nnTVKAoGrA4IUKC95Nqkfd\n4ppRS2nzvPOw+8qV2fGsWfja0UcDCO0IMcqxoXkANhYtxQfnPvGJ7POXvwQABNs83fOUz342Ozj5\n5IAxVcSQHJ20fHnF11ZLMp4trj/17v+CBiH3PvZYXJYkZe0LE5FpBABwkggCNaZ+M3gglG43bLAr\nw7HbIwcOWqkjWLpmzJuDl1hbYBdMJsbDORaBE7pZPu28aWioxXLHZExfB2LK99oVU7thlqBhwegr\nkUiEil4Fe5k4z5ALkqTgJpfbcUcAxRMuP3YsPibHJPXlp0zJflfDxfAbd+8PS11cDC4ElW9sxOF8\ngrWaKjbV5+iZiavpO2hTBCpj8IVr1Zj7ZfTu7S20wxJ6fkaWRDV31lkAgEVJUjyv7ror+zz0UDxD\n977RuSxW7QpJpSPzSdJ/I7616Tnpup42x+eSBCedcEL2jxSX37wZZ7z2GvJOy4rRJwBcKH0dPx5f\noO9apd9cZ5k0hkqo30z+qacyv3sOOuOAMmbGQJgKxUplwOlRGP7gwvQcCCdMd9KkMErYSjfMCc7k\nWXE/GKPnwEodBKoD3KQdPsdeOkCocehcWhXQsGD01Skh1VHeuQJa5JZ94Hss8Mei8eOxcMsWr1bX\nwMtnOfmGV0Pcv0rpNjqeEb2qespfdlkAhwwJiVF4Bx1VUUz5iy+uyD7xs4H1KLvXggXFJyXQqYog\np4sdQzzLcq11eO5v/vpX7AYgv3QpAGDu0qXY1XkXlWPygGfyAJBbsgSdDnJj2rRsGQDgEvdZCQ1E\nig/iE1gC5txK7A3DQUjMDOU7wDPM9nbbiMr34uh3bXS1jLpMlueMDpKKkZWqhBm5lSpFrgHiEdol\naFgw+m70A5IRkmg6onPTtADV/NX5dP8RwKx8Hvmc95PIHZx5iufvvrtwLgrUSOSfqJQf+1jsyiL6\nsNgC7rjDh0u7F5Unt8gYM6+Wye/pPsWbpD/2DwDY1VjEMS+TxUlS/bvrD40eXdDEHqivxwfTFNhn\nnwLD+ZtjMu9y/wdMR97Ztm0491nKnk2+5dVAN4NJeRe4BmQpYQHgWvr+WgD7VCl1F9o+/fRg828F\ngKeewiVVtjMgqAaZ733QBkMaVslGK4oUyBifeONYeL5OMy7E2Dm7Y7IGwXmHLBxfB3HFMHrLpTOW\n3pk9c3j8VUA1moZFCoSJSZJ+ofxlBRodOT7ZfV6C0FNBjHMrq7hHE1BgKO+fN8+HU8sLuOKK7JPO\nL3UuoCds2oTr3CLsABl977gDiyjcHaieiVdCowCcSf//h/tcwEZQ8XiJaSwbNwbQhCyk/Nix3s7x\n6KNY5CCThUlSsQFPIJd7HQRzYJVz8EpiJqe43/7ZndtDu9zGDJ2//rU//giVPHbaQ74KJirLrxvA\nLACzb7nFfyk2g1Jk9VHOObdU/Ef2FguYvRrnIne+v/Mp9+STFQc9DZTBMwmoeMzLL4dGSsbRhWnq\nqmMxjxkhCW6aNCnMM2Tlw+esp5yambOyWsnINJ5u+d/Ld3I9J0xjjx3O06NzVWnvG6fx1Kw4+FBQ\ntVOEve5jgArL+dUweKFuAL9wx7ctW4ZxTp2tAzCPc61UQJWo1rWkbQAuov+H4iVX46WRr6/HQfx/\nDN+WCFjnmdSfuIYglUQlfSyX3tmgioPRmek7YzHKxZBwgquHH4b7FY6hS/4rSeAysOC7lfZF0VAy\neQHgWuncz8ePxzES6KaLbAhj1AVGLA2A89WIlM8eKxxVyh4wXF6Sfe3b2sLEeFpiZ1fQUi6afJ7t\nD3193s7Iv7diAGJQVAU0LBj9jjNmIPdP/wQAuOHyy4OI2HL0NWd8AwBc5NhbjdTvQ93nvgAS542z\nfMoULL/1VhxnBGud4CJxmJEAACAASURBVDxQAOBzvCAIJli0++4APKzyC4QSoUW5vffGpY8/DgD4\n2g9+gPwXKtd/BMYxk48BcdvDmDHAPvsU9yVNg0AqicCtFrr5bRXXalpnnNvDRY/ioy5Bxn33lW6E\npXgmrs7VD1oFYNWRRxb+r2RzWUyb0QJnsBfvLIEST3EVyQog3CUOaHGaWX8ZfKVUSyle5uQrAOax\nXYLxbc4WyxK2ldQMKJZ4tYTMEj2nNGbXSSsHP+CzznI+fsvPnmsPaK+bUmnBJYW3bltfz+erxOjL\nQjdJkvwQwOEA1klx8CRJzgNwAgCxdH4jTdNfue/OBfAFZBWmTkvT9M6iRhXN3GefdDUtMJHC2pBB\nH5oYqfqa1f/77kP+wAML/worKx9/G5JIHnUAznCBVLfdfjsO58nJblbMJDgjJRcxls3A5Q/JH3JI\nWftEkNrghBMKBrkZAB515ycDkKwdnwfwbg55rzS/yQBplVv45TSogr//pk3Apz6V/SMS7nCh888P\n7DnVUI41Ph7X//k//vhLX8o+e3txtZvvJ5FX1pOO0f8KwLmUvG3RrrsCABY6+5J4EknCtsdQe6ol\nkweA3MKFAIAVLqXCHCU8oK4urLpmpQ7XfuZWinLL7ZK9eNauDaEgLrTDaawt4y0TawscSGWVE9W2\nBQ6eim10PD41tmT8+Iqgm0oY/QHIhM0fKUbfnabpJera9yErL7gvMpj8HgB7pmm6FSVo5j77pKtF\nQpk5E4sd1HEaPL480X0+DyBHk+xx6v9gsgqZPg0AJAj7yBde8BdoRi8ToqMDOOig7LinB5c647Aw\nu3L+z0C24QjiNx1+MdfBbw47wCeZ+gQAlm/e7VIMDzq5xfqQw7fvQXzzyomaft55AIBlF18MAJhH\n7/MZes+cYngrnd9uEG1Mm9x9bnL/d/SznaIgOSBc1JJ8CwA++UkAwOPu3nvr5Gnlgqv+6Z+Qp9TZ\nA6FaMHgNGSwQDfyiiwqbUzeA4197zQ7x10VSuNyhVbOBpWKL0esUyFYNCK6XwFAPM/qYYZg3HKti\nFfvit7cXG5GlPXbNlDb4mlpj9Gma3pckSVu56xwdCeDGNE23APjvJEnakTH90jNv1KhAlRZ1lXH2\n5+lY8OBdkGXoGwoSI1c3fHTiixMmQHr9C3imtvC114JSdYVI0ny+AM+IMqoZPXvgtLnjz23ZEhQ/\nWON81/cFCnnYOZMgb3g5STE8FOTcH8VttZRhkI2dE0tc92ZSo0vE1vHSSzVpL7AXUOI1zq+Tu1Mp\nwFK9qYJ8UACyHDWzZ5e/rgzVWopfIPEXkkMH2ZwtzBGd4pchGsHIuXAP4+gcncrtsWHUYpicRkEH\nYFlFWHTmyTFjMuEmFtQkBc753emoX8t11IJ39PEQulfOT5LkXwGsBvC1NE1fBTABAIOcne5cVXQC\nTzI3uQTX+xN88M4Jslgcg2lw19bCRxrwkE8fvHfAKwDeSdfs5ZjBR156CfuJdw3giy984AOBNJpz\nWKss4Cvq6zHfjePSxsZCLpNVAHaX4/p6zKI2ziUmscoxzNyWLVjkGMnCn/wEuOce35cf/rCyAdeI\nFn7oQwCA/P33V3T9PBoPHn644Iu+u0AWHR0Z5u7gsO1+8IOa9bUkiaQ9wBS8+STBAfqktC350xEy\nedmsf/XGGwCABU5bWkQbpJWhND9AJl9zBn/88dlBVxfw058GSQaFVR0p0E0Mj5ZUvVqKL5eT3do4\n2Aed4RI+jkW7aux+8+bi/kgtX11tzvLG0ZtTzNBcA6rIvdJJ9LcRdDMeWd2DFMAiADunafr5JEm+\nB+CBNE1/7K77AYBfpWm6wmjzRAAnAsDEiRNnPGcUkQDg8W0AGDMm89D4x3/05ygw5ekaM3qWrkfT\nsbzanQCc4hj9Qy+9hP3e+17/45ucwt/WllW1ATJDIdUQ3VRfj0Y3licfeQTTHBT0xwkTsJcroIGD\nDgpzUgNheDhPdoYATj7ZH1u1OIeCNm6syuMo99BD2YEEHT3v9DjRjmpRiWsANBCGdwCyAiFAljhv\nkfOTb4HXXJ21AnstX468c8PdBSTQAD5PPRCN5ehvP2vB5HObNoXwyLa4XrfCtT0nTcN1zsVBtGGT\n2+YSf9oYa3niAMXwB+edt6R4nZFS94O9gqwcNJLawGL02qBslWZkqMgogZhMmFAbjB4oZvSx75wh\nFmmaXuC+uxPAeWmaloRuSpUShPPGAQD87ne41E0Oywj7d/fdRUXfDA0FRkauEk+M/gLndXOau/YS\neA+c++GLffwJVNyiBKP/jWvvw6+9hmWOqc7btAm4jWJjrcIWQ0RcgYhd+HgTzW1P9bgqhSjeBHop\nSQpBS5X2klF0/k3uHe8oHP/91VcLx/+rhjYHMw2EQbVg8BK30ThvXiiIlHCJ/bm7xzGLFwOf+Yz/\noq4uZPRimGVXUy3dc+1bIKwdzIy2ocHHhzQ0+LXF/vJcNISLu7N/v5zXG4plC5B7Sb/kuL09HBNX\n1eKC5EKcZ0eMsVOmDB6jT5Jk5zRNX3LHZwDYL03TTyVJMgXAT+GNsSsB7FHWGFuK0Wt6zJkib7wR\n+Na3CqXNRsHj+LUKQmJmxJ4vOl2Cvmbh974HfPGL/kuWPHhyTpzo3QBrIa1KLhcAF1C6BSsJ2FAR\nG06/VeI6oalwEh6AJ+m304ZBYB+AwvyT3DqVkk5jwYw+T4y+lkVvliVJYNvSVHUqYf17TmHQjzqx\ny5MEx0kQ3/z5tjskM/S2ttC/niVclrCBkFlv2BCmJpaNg9MXdHaGHjic06ZUAjPWJGJQEjNrltZL\nSfScjx/INk/WFtzYamaMTZLkBmQFesYlSdKJLAr+oCRJpiODbjoAnAQAaZr+PkmSnyFz9+0DcGo5\nJl+WnBp/3SOPAMhA/wXsO080GFGmpe6h7yf/X3DqqRh96qkAMi+Z2eSdc7VzjwNcDvOZZd9RaeKi\nzDEStZhV4BpX6DLpYx8rMPdKEkaUTBi8ebPPdcN9H0INIJ8kAYOuhsYgrAR1tWPuJ23ZAlgJ7mpQ\nHHzeYYcFqRSYaiHFi4Y2A5QnH5QkrQxtBrDU5Qs6Ye7c0B+dvWeEMesC2cIEOzqKC4+sWRNWb5Lv\n77knDKQSYn94zbBl3axZ4zUATqjGxlXWRCxig60OsJLfsqeP5TvPG0GFVInXzfHG6ag1LE3TxQBq\nn3DcUR+ARc4Vb9TFFw9qfpX+bhzb4NX0JwA8LIW9f//7ooIjtzjj2pE1kOQkyOZddP8aJlkeEN1V\n/pJCoYw5jrHd7P5nD5U3m1j6roZOX7myYCjNbdlS8J3XVEhDTHaoy5IEZ1QTeVyCYQ9Uiq+I1lFI\nW4k033WIFMhpa/NMr6/PM3jGyzkjZEuLh4vYcCuMnDeOuroQjuHskYzlsz+85YPP3/PvLAmdSWsA\n7I7J8JMOsGKXT47GrZCGRa6bktANSWw6ze1pAK5xx8ciTPpUC2Lopo6OGbqRx83ujbmHHgqxNzaG\ncrTpY4/5IJovfSnMOyNQTpkIzy20QOv/+Z8Lxxf8538Wjs+9+mrgxBNLtlNTchBSvh/ZOgsGWaBQ\n+akAid15J3DQQbid5sFhbv7+nZ5DzXDufuS9GQhxIRMRCGTmaDfcHOWjL0j8++5bNZOvFYPPSWQy\n4IPgANw6fny0mtX1ZEP43KZNYZCSSMycyXLSJC89MzTT1GTnlrECmRhT37AhxOgtV0ad4EznidcB\nWpZfPl/D99HpGOQ8w0gsxRs++pUGTA2LFAil6GK3qDcb33HY97U1up88kFEAJKHBrwD8izu+DV5a\nPunRRwsPfPns2ThOPGVWrw5VbyY2kgLA4Yfb1/WDFjvm/hnqY+7qq2vW/lCQMHdm+NsQuh4ykHFY\nPzNzDkfS2h5QPqDuhiTB8e5ZxZj2YDL4QnuU9rjFHe9iXSiBe7vthj6QRF8q7zwbOy0PHF2fVT4t\npguEaQ+sbJf6PtYGYFWJAjxDjrlFaonfSo3AtoBYZGyVuW6Gp0QvqYd1rUUAi8aOLUgBewI4ngxC\nixxmqCEXYaWKxRaqSeWnTAm8I8797GeBq67yxQokQ+XvfoeVboFUVWi5FJFfcZokSL785axPl19e\nCJgCVO4cChfPkx+9GKbn5fPArFn++lhel1rTT3+a9cll8RwIxXLw5557Dnln5wiqgdHEXzRhQsHH\n/BZiaBXBY+7ZXtHYWCh9OFxJYku6EN8QhoLJM50DHwMghmDJ6gkAsyU1x4MP+myv4kfP0rJAMa2t\nntHrGqsi6etEYXItEzNOYZ5r14bGWMHu6+pC7UK3Afj51tkZGoI5N72QdunkjcbaUDo64imT5Z7u\n+7eNRF9Kbf4Twqx7EtSkZbyYg9dLrpoUQBKwlJgD/Eug4KPZjz6KERo8kvxCZy1ZEkiJQreRMfvP\n9P4kTUFhST1v+Jts3PimxBTkrr4amDu35lXFSiX/G2oGL3Rhme+v2H13zP/JTwAYzMcqvMHuiJp5\nWpkdrejWGLG/PBtVm5rsyk7cRyCDWMeNCwOwLEleG2C1tC6wDXvacOEV3QZ7GVVIw5LRX+mMl6cc\ndhgE0a4kWdMxzrtFl7fbBjfxuQydRLGOGYNcb2+2uwtRVGsRGRkdB0RU5i/hCNr9989cSC2iySTI\n+0v19UGemCGn55/3CdsGINGLrmIxecAncQMyP14AyH372+g9++zC+RwF30ncaY6jloEwiZaT3q4Y\nPx6Srq7i1MNlSKCzFYNYOrLonlUw+ZxL1rfs9tvhUPFB8V4Tj6O/AXjczY+ADXPgEXugMAMGQrgm\nFiUr3i8sFUugWWurnUiMi4PwJqFhHKaNG8P0C9wnvUHwefYuYs8gzrvPtWQ16Rq0FdCwZPRM5Rh8\n4JHh3O92AnCKnGcLO7nl5ceO9Qti9OjioKQ3mfKf/nQIJ/W3IZFsJ04sfa4KWkpMg9NVDERizaVp\nBtm5BHB/+fOfwYkbJGzuYRiJ0r7zneDfC0jqF5JEeU0ATn/55ahE1F8GL9u/wISJYrZzTjwRawZZ\noq5Wiufr51X4m/7SGjoOcjFJH3QRbiF2jWRJN4ahM3bNOXIY65ZNgRltzDVSl/XT1wjMs9NOoVQe\nq+uqI32ZWGJngzEQ2ip0GcUKaFgyeqkahH//dyDiByx0MUE7Z7nfjQJwdWNj5qdeqdHizUoTEKFc\nmsY9bmjD2nkY2FgAYJXBXCuhPctfAgD4XYnv8irpmOVZ34ewNvFLbt7svGkT8i6j6EDoMZQPduLv\na81MB8Lkre8KEc0rV/qU2jXKimm6VMakcz6O4d6SZkCub2kpltC5PTakWlkygRCO4fto5i3/i4bI\n0j1DQVa/+X+dJkFDUbE0ChXSsGT0BfrGN5DTJe+AII/Lla7y0ymbNhWCaoIS0kraY2+OYU/77z/w\nNiZOzPya160rqK9XzJmD+eyNE3O9ZHiDCnO3GJfOSlP8pkw5O/GoFi/rZgDvBjDLFWFfMmECYgpp\nTlxHm5qQv/764LsW2B4ruTPOyIqZOzqdtL+dBcrp6yvkmIkAZRVRRbqR+JdTgZrcwQcHNYurpaoZ\nfIXzP2j3d9k2u0+SFDTs0wBc4Y6rhXrM69kACoQSK7tXCsUKdTAUwtdaRlXN3K3cODodsZV6WNrR\nWTcZgxftQnsNcTQw99eCbri8YpU0vBk90c8dLNAKH3zTBIRM/e1GQxG9WkMS07/4T+kFzZWhqnMO\nA/IUF6DJYvIAAiYPkIfS8uU+zqGlZUAMHhhYmuWhYvJjAJwxQCHniDRFm2u/Ez57Jt8z99pruMzB\nZBtBMRDf/nZ27dln2++eGT0fa4ZtRYqyfzt76FjpEDjVMEMtzJi1uyQzbLYRACHkI/YESYsck9bL\npT3goC4NY8n3VdLwdK8cobcF3ZokOMJJ0fnGxoI0WfCVT9NCcY9GmYdf/Wrh9686Rs3xElxgRcjK\nQwQAuX/8R+Rd6gwAyDlvDwDAv/yLP3ZZIAfEdO+9t2y+orvdWA/esmXg9gxF5aCgQklJDrSqlj72\nMV9E58wzC6dvra8vvGcAhVgRycCZ27SpwJxW1tcHab73lrE89VQooVvl9DgylomZp0jXq1aFvviS\nZJA9ahoa7IRkXGMW8JoEBy1ZxtAYA9ZlDa3zrA2wRG/loKffVZq98i0j0XMaU0l9W3CF/NGPwmsl\nuZeRxvU3tCA+PAw2ubcluef+GIBOsqEscgxeKJ8kOJP+X5okhZS9UwHMkayWb7xRmKhnbb898i5H\nu9DCL38ZnZdfDiDLzSEluB9/5BG8yx2/BmDxpz+NBdY7vzlLtjCjsRH9cZ7N3Xuv/+fXv84+S8Uu\ncJK7au/VT7fJP4GiacvRXXdhkYtqXmjURtb0GIAPuPe8K5fZRHH6iqeRVScqor6+sEygPKO2NhuT\n5nOdnXbOKDaY8rEFizAUxFkq2ajKBmOGaGK57vka2RjYG4h96tevD6N05XqBorq6wnQNVeL0bx1G\nX4LySYLcyy9n/+jcGpLtstZukW9FcpvlX8eOxY4DyTxYrpwdEcM1FjZ7iRwkSVEkJTP0PuNc4TrH\n5IXEqyP32mv4pc6H//nPZ59GMZYni85URlKfOHfWWYAUljFIDMoPT6i6Fk9tkpA5CRsAcv2Q6Bfd\nfTe2Oa3nfQsWFDZUwEem5+bPx9WupjHgczkBWcDaq/C1jYHMRgOg2Fedg5A4HYBVTIQ960QbYF9z\nZu6traEbo4XH88agYRb2r5dP3qDKRdTqTJvsX29FwcoxjxEIE7JVQG8dRi9eMVRsWRvlCuedNGIt\njg/rUm0jVHsSjapKRsSlI9dEr6qcFikmn5s3z77QGZonAuhvZd2cZFStIBtptYn4hjz4adasrKbC\nDqEFbOFzz4W55iXNR5Jgrjv13NKlmbeb6+MTCPs/F8C7OShRiP3lNS5tlQzcsMFvAFoCl2uFOJFY\nzNCqK0zJMUvgVq4bfS8myxd/w4awDf4tj1vuaXkd6Xq4FdDbE6MXyOauSnImjtBg0XNJUlDl8/X1\nkKXRDV+QoxdZ+gYAwNSpWPTnPwMAFqpCJUIWRn8ogP3cBp4/5JCwAtlvf5t9ilrMmRUNkiRx9ZJe\n4ZxzkL/11pK/YSp4tQgjoIC4qqs1DSKDHwPEM2I6b6vFjY1YsP32vtyhG9OVu+6KU66+uhBk+Btn\nS/nwjjsCnZ3Y4uwPAqgGpUG/+92wVoNsJs8+a7s9clbHmIsh55uX597REeL2UmyEPW04wRm33dbm\nrwe84Z6ZvhBDKjp6lZkx+/9z39nQK31j/J/98rnfro2a5aMfdrR5c8F7YhRCr5uiqlN33eVzvrgJ\ntYgWilVzc4RqS4vJ6MgyCPu6W4bJTZE6rZaP/B0A9iNX1PwjjyB3cFara6WbK7MVdhyjenE7XbPG\nVwargvL77Rfm4PnkJ7PzJbyGLBpsJg/AS+Qq3/3SxkZY2+EFu+5qeszcByC3445F518svhQrTz8d\ns5nR77tvdn9dKk+OOWMlwxsao+bKUpLG1zLoMhTU1WUnO2Omyz7tYgTlzYK1DP6Oj9lYrP34LXdM\nltgZz+exvB0CpgZK+bvvDrIdjtCbQ9cO4LeXRM5bsMcohDCNMPl+0Uc/mn1+5Sv4YxWSPFPe5eAZ\nBWAhpY6uhIYCptkIhFqPImbQj7/xBjBlCvZOU3wcvkYA5s7NPkePBi67zENWRx2FejeG0Ua/Zy9c\n6JkbJ95jl0JODibfASEuz5IxR77y9wydMBNn7N6Cevi8lr41g21qClMgW8FRfH/26WftgAuKW7YA\njtzXtoUKqCx0kyTJD5FFdq+jUoIXAzgCmYD1DIB5aZpucCUHnwbwR/fzB9M0PbmoUUUDgm4eoyQJ\nzuD6uJtge49I7G8+OcNtrRN6Me0G4LMO9xW7TS1L8lXCaHdzn8/CZ9X885QpBQN0OV/9ISkIQtQC\nFLD0IvrZz7JPYU4aCtXebFxHob/04ov+fmwH0IFOlmTMkIqWvmUcIhEz02V4RhcVkdxX48b5thlS\n4b7yJmNpEbwpsQbATJ/xet5c+FoDo0+mTasZdHMtsiA49mG8G8C5aZr2JUnybWSpWCSr1DNpmk7H\nUJHhTXOH+9zbuv7f/s0fn3/+YPRohJgcvvkuALPdqZ9V8LPcvfdisfNmYSk+t2lTAboL2I1zsc2x\nlFgjyu28MwDgspdeiqYDZiPulU6ifwXAAnFpJI+XovaH2NgqsnIhzYFLefB1d/55AHuxRvyLX2Sf\njhEuThIsKOV2WaFX1nJ3/+PSNMTltTQupH3KrULcfX3ALrtktphYwjKW3vmenOyMjb4WBCNk4fbS\nnhAbizk1Am8u3A7Xh2XXTgvDr5DKMvo0Te9zkjqfYyvng/A1OoaeyL++WtxqhIaO/obKGLyQuCwW\nkdQIANBkfX/UUVXcpTJa5nLplCsCIsT4dr5KBg8MfjrhWCSx0I0AQNXBcitWAACuPuQQWBEAUhzo\nrIFoUQxXALZnioZUeDPgTUB4guUtI23KeTbYcm6acsxbMHgNJ+nUw9JXNhLLNbokoK5WBYT57WNF\nVSqgWmD0nwfAkRjvSZLkcWTr4ptpmt5fg3sEpEOuNfXSdSKlFMrLSYmy/8n01a/iOUoPsOtgQlyi\nAtcIuslT0NU9dP4XIp1SiuJa0bwPfhAAcMEDD5jG4P5QraV4sUtUGt2b04FNUvT8lVewS5LghIUL\n/ZeHHgrssENWyJzJSetFDL5CCOc4DuDSTM6qKsWpjLXULcSSsBV1qv312Y1SJHpOR8B+8twXZtZW\n1k0dDctMn4+FtFZiCa06wKsKGhCjT5JkATLNWmLLXwIwMU3TvyVJMgPAzUmSTEnTtEgYSpLkRLh0\n6hP7mS4X8FGyIzRMaerUQWvakrDvdlk0D67h5vVzl7WxFkx+sGCa/N13Z21X2BYXJ9dYfRcATHfo\nKweA1Tj30lKn7Zxw7LHFKQCY0TKxpB+ThuV7y2Cp4R/2emlvz9xhuW1m+lq7EGJ/fjb0il2A7Qdc\nqETnw+HCI6UgolKpjiPUb0afJMnnkBlpZ6fOopum6RYgq92QpumjSZI8gyzNRpGlNU3T7wP4PpAZ\nY6u5tyyWNElQDmX/X1oKEZ/g/8l03nnoUwm/Bo3+lNVBOidJylYfqpZYPJj3nvf4f57tb9iTTccI\nI3z44UIah/4U56gFk5cFu+CFF/zCF08hhCmGSxFL58H1SZIVI7nmGuRdivCcyy6Ka64B7rjDX/tL\nzixfPRVtG5wn3jJYckEOZoSMowtpPN1i1hZttqpTO2JjK29AOvGajMUyqgIhvMN9sYqT8LnYPSug\nfjH6JEkORWZ8PTBN0810fkcAr6RpujVJkt0A7IH+BxuW70eaIidFNNauxQUOV+yFLwRxa319tAr9\n/1gaMwa7D/EzqRWTz1GJwXlG0ZnBpjeLwQvJUr/bpVE4OE2Bm26K/yBCpbyg8mVqQNSKAg1JJxUT\niFV7snD2SIuRWoyTif3bNeOUwCi9EbB/P3v9AGG+Gu5fQ0NoxGVDKkfgsr+8tdFZbp7d3VWXEqzE\nvfIGAAcBGAfgZQA5ZF429UChfvKDaZqenCTJHADnI5uPWwHk0jQt64w8IPfK004DAKy4/PIgbP5T\ndLyXjLEGbmB/T5ICNnyEK12IXXbB627h/sPIphKn3TInxPx//3fVP+UMlcMh0G1VkmBlBdfVgsn3\n11V0RZJgDkUmB22uzHq/ZHbmCyUwWB0ACT0b7KR/17vn8Nk0zbxk2F1SmKswXyDMB89pCnp6igOL\n2JjKLo1AmIFSzsvGIrAJpzu2XCA5QEuwfSraHVzD91671l8vBVL09Z2d3gjLz4Q3EUc1Kw6epunx\nxukfRK5dAWBFuTZrRgccUCjcPVUxepZx+sRQJ5M+SQJj1CK3CIoYiNsYnqyvx7Qjjoj3g1w8/5wk\n2OOWW7J/PvGJyA+GAYnL3OGu+N1g577v7fUFNy6+uOqfbwMZWqtIqjZYNGvePKx0RW8s6g+Dl+yS\nfzzuOOxVZaCVRXOuvhq49lrkTzqpuC+zZxedkycpdc3uY6eHQWD6wnxWJAnmvPCCXVlKR4wKcYph\n7bJYuIGRVZLbZq+b7m6/qeiAJIZjhKwCJBpesaTuWHES3TZvcDIGZvRv++yVwqAktDyiglo26bJB\nOxwSvu++vqAw0Y/h3ee2TZiAI/fOvPW/g1CLGCFHTz2VfU6ejHw/GLzQYHjT9IduccyvlKWnv1L8\nYmecPBbAIkqZsPAPfwhy5lRKFoMvRaWMzfkkQe6IIwp5f3I1EGZ6QOkYmprCpGac1EukbY6AZU+b\npiYfZMXBTcxE5fru7jATJHvxMB7OcI1cwzl1YiUO5dpx4+xgJza6al979uTRRl9u721XSrAE3ZIk\nOPId7ygE4dyL6rICLqqvL8AB22CHhD/jNoa7ADzoJvhGeJx2DYC/PP54oQ2XiRx76JSiw5HcRjlU\n9PcK3SutIiIfA/DArrvigy4V9cXU1oB8t6ukleUk8gHCNFKQY4/f/x7bXNBVIW/Oww9nUh5DnJGc\n9+kg++EXUSRnTjkaBWAO95UZoJXJkv/XlaK09Bzzi2f3aqscoP6/uTksMq7hmFgaA+2BI6QZNrtr\nWumJLbdMdumskN5yjH75nDlgx6JKcFKLtgFY6KSS/JFHAtdeG16wahV2v+YaAMDhp56K9zpMc9ns\n2YUN5YQnnyzs/FcfeCBOkgIU3d1Y7gJ+/uqunS9MgD1CdtsNg0K9vYH2whsaAEyGt5CLul6UEK5G\ntNglJ6t0WkofOUvlXYCvNxCh/CDDDEIxSb4WWLxoipIrR46HS51jzuK58sisfMjsATzrXgBL0xSb\nAZzOAUEs3be22v7mXDWKma1Vpo8rNo0b569pb/c5ZEq5anLeHW07WL++9IYh7fEmZnnPcL/ZG4dd\nM9kmUetcN0NBJY2xLr9GniL1BoM4jf86AAtfeKFg2PnNtGmFiMD1QKGA9bEA/uCOKeMORsPnPikw\n+j32yA7YPa3GTS1SvwAAIABJREFUjF4ycy5UpepqzujLYeRDkN9GSKZ7kCbhoYe8lFkDKllsexD8\n4neD7aomOe/zF1/sq1odcACWufvNc66VYjF6zGij1tSEMCspUPlGe0WSYKs7Pv255zyT7OwMa7I+\n+GB2LGUMgbCYCFAoX1jw+7/qKl/usLPTM+jbbgPmz3edJ+ba0eEhHfak4Q3lppt8imXJkzN5crEn\njm6bmTLn8dEpk8WQzLYDTpFg1LRNxo59m6YpHiSSxy9McfGECZBEuc8gTIcsD+1pZEwTCBdVMzz2\n2AXgdGHyAG7bfffC8eGDtMmWY7DHrViBTXPmADACHN5CZE1eLf0uJqZrlhEsQYsGGaqJUcwf2bJx\n5JOkEE8g9x4KBg9EUlAAhaRoVzubQzR5GhPDHlwqj71edHpgDZsAXvpubrZLEzY3hxGwnIOe8X9u\nW2rG6j4CnhFX4t47enRxgRWGaNguwRvFDjuU1jgqoOEp0TsD3tJp03CCg0wsL4GBkhQdXAfPsIGM\nqR9x551eghBcb7fd8PMkwTGW/3Zvb5gzepdd/HnAS746qZoEaOywAyAxARMn4na3aA8r835kcR8L\n4L1isOzowAUOOjoUwN7iYSR5YqZODaGqE0+0G49I7lcQM2NI6jq3iQnjuQ9DQ/ORZd3TlEsSLKbn\nt+DOO806wgE5TSD/yCNFmlCh3aGu+PQWotzixQXGKIxehKhcmgLvfGfByeHKKVNwijy3GBYf82op\n5XkyZoxfV8K02bgKZPP5+eeLUyLIp85COXp0uB6kDV6/fAz4/4UxSxu632PGFLet7xP5Pqmvf3tI\n9IPB4IU4+ZTUsQxyYXJIMtHPGxt9tKRQT0+olgmjH0LKu/B/pl8CuM1J+MKwWgB8ka7ZLsbo+0lD\nxeCFLCYvJMu1UJ/gPtc7zu8tKTgOOCD4rRUcVS2Tl/KFq5Yt67c96a1E+QULot8tShIslJw6yDD6\ny9zzPENfLHAJ4+Ms0bMniw6qku85AEm+l8yQ2uXSqvokbQMZo5XNYqedsv97e23pWpiy9sYRbL2u\nLtsMOCGjjobl3+oNox80fCT637nSyRQskKfCwoNFuTPOwN8vuwy/onNz3qRncn2S4LOCvTrV7YIZ\nMwAA51KfLnCM5dyDD/b4JYAlr78OILMhcNm+f3HHElvQAOAMrggUK6/H4eBOSrkgSQI3PNGK/glU\nlGKYUgHXBgJGv8htkAs/9CHk77dz8FXD4DlH95H0O7l+FPoXYTsYVEhmds89hblWq8RtTKPoU0rR\nS9zLuWmazTVm1oKBszeKzijJcIzO/bJ2bQjnSOoTDdFYQU26LR1Ju36934BYU9AMmsmS4oXRiwai\n0x5oMlInv6Ul+v4w+NzBBxcMMpUaAXNnZHLEwwiLUc+p+u61p/yMGcW5QKzrHHPXxAYy2QokvdgR\nS5ZkB9OZJRnEhRkMyu28M650KXwHyuRzaYpHkwQznOR93SGHoGOAbWpa6uCsEw4+GLcbWR4tJl9t\nKmHJhm95o7D9QLJwjoZnrGLXqTQdci0o/+qrhTHOdee+Pwj32Uaf4rkUYPxsyIyl/uXrmpo8A+bg\nKc40yVG0uuC4tMVVrTgallMZM+Nlg6n0wwqusrQM6avux5gx4TVsmI0FXVVJw0eid4FQ1+26a78W\neO54F8D7059mwR1OZc4vW4YcYeqyiYjpRPyw2fc4ebOeieD355+PC5IE59BXyWGHZQc335x5FADA\nUUcFcA1jylx8ezKdB4B2AAtZulWQhVChMMQ//zNw3nkAYBbs7g+JEn66JCN79ln8JUkKhsR2FHtz\nDDVVDdNUMW9+7to55oMfxDKXHXOeK3CSd5vnYFK5vvI429xnR6378OST2cEHPpBVmOJoU7GLcbbH\nlpawyDbnjGH7E5BJ8NLe9Ok+XXZbWygZszFUBJvW1jDwSu45daq/Rr7njUhL9BYcZNke5Dyf44pY\nQsbmkjQ2vrUkegtfroSCvNrOYMiTuGXZMlzd2Fhk+dd7LXs67I43n3qRReEKfZaOJakX5NMRwwGs\nfh/HOft5MpVKH/Dd70Lk+aX/+Z/oqrK4dTnagGJm8+40xbuti0mt//nYsQWXVsu1shZUqRQ/kPw7\nbOOZp+8P4I/uXntJ6o0LLwz86/tDLPCUvVaY8KGHYpPbeGJ1fPtL+WnT/LPmzJRaumfmzgZTlsCF\nrGIkugA4++jLhsIBWJxXhrF+9se3GHZMitdpGSx4h33jWaOwqB8S/bBh9LnvfQ8AcOmpp1YnyfGD\nNRjXSc88E94nkvFwqLM5mkSlDUtJXIXvenuxxcFU/wHgXPJQkojK/JQpXgoRaec738k+vy5lWWyS\nJ/tiyauqp5wkg+sH/YGOa83ggeqk+G2R62tBBQb/mc8MKKf/u/ifajJ8fsAh6S++CAFSc+efj3wu\n1+++lKS+vhBzF9KpBsThQfug6/J6XDKQeQQnOIsVIdI1Xpnp86aj+2HVi9XfaddNJmb01kbCideq\nNMwOG0aPL30JAPC1urqSOTpyzz0XSv/lJq8OShqidLZDQqNHo94xmnPpNDMfkxGVYfAAgNNOQ84l\nIfuvCRMK+P6F6L+xriAlrl/vGUklRO8st2IF8i4GIOb+2K++VQvTGCkzakqyGd9zD7b0U5JvAjC/\nCim+LP3bvyEnLsf7719gXjVxmuDEZJwPhqETzlipo0stxsrMmn9n4fUMBen89hyRauWyt/LISztA\nKJ3rBGxW/hrOZc+MnpOaveVTIEyfDhe3hnc5ye/eCRNwoEjmfX0FL5IRihBb8//gZGBOiiVeNjvt\nhCg9/DAWO4PhNADvd5j+yQceiO+6S0bBM9vYtMv9wz8AABa9/joWTZs28BTDtGhq5blSDZPPfehD\n/p/7BtGRVASUE09EvXN/3S1J4CItMA3Ao5Gf9luKr4TYnkNQ6aX0vCTKOkhL4erO5ufMsZ0MdFSp\nMHdm0sxo+/qKUxMDoWTPErJV1o/vyamROXgJ8B422jArbQhT5lw4cr1cw/fkwCjLd5/HKd/rtMxV\n0vBj9ET5CRNwkDte5IJxFm7aFHh4nDXUnXqrUqlc/ML4m5uBHzvLAMEFjwJ43HmsMHPdhvLMVlw+\nS2wp1ZFO3zoAqlaKHwVg0f33v2n58D8rboiODneF0PN3313InHojgPll8gINBpVjPX91WtguiBjZ\nNSbNCbyYGXLBbwtrZ1dIaaOlxUM+urC2+Os3N9s5czZsKIY+pS+6r7Fjzt0jm5hGGth7h72OYoVW\nqqThwejTFLca4dtfANDqVM8nnHq4pLExyEuDz38e+OEPh6SbNaWLLvLHlUApBj2XJJBQrgsBfM4d\ntwoGPndulvtj7lz/o40bs5JwAPCNb0Tbvm6//QIpvb/S8+kCHTimNODiLw0NBYz/eldlqT8lzPoT\n3VrIiU8RzENOLKG7PFA52agbGpAbQFBNVfRrl6v1Ix8Bnn22oNkdCwD/+q9ZvzZt8t4wAJbttx9O\neOEFLHXvLSAtRQtpd0Qt6cp5K2c9S+J8H6vuK6c6Zi2C0x7wb7gcoDBgzpHDsAxrDnLt5s0hRMVG\n4ljSM/bcqbLCVEWzIkmSHyKrD7suTdOp7tw7ASxH5n3VAeDYNE1fTZIkAbAEwMeRJSCcm6Zpv9Jv\n/AAAFP7XBL+wxYWysDtatUL33DP7dLVLh5yYsdWgwlUldPGECTjLFa7In3QScpc4fwmXZuJ1F724\nesECrAKw8NEMBLht/Hg87dooUTmzKlrs3t9YAPN1/d5qiCTZ/3KM4vnYtSVoIOkLapcmrcbU1VUI\nAHupsRE71xKXHwBd2dhYiD6XLfGWCRPic8vK5KhTFLBLpTBmrgjFUq+cmzrVZrYMu/Amwn73PT0e\nGuIIeV0ERe7HGoVVBrChIYz21eUQ5U9L77qvVpbMElSRH32SJAcg07h+RIz+ImT1YS9MkuQcAO9I\n0/TsJEk+DuDLyBj9fgCWpGm6X6n2g1w3vb3At74FAMgvWlS2bzkuCn3VVcW5TP6nMPp99in41+f3\n268QJxBbVIK0rkJ5nL1WJDgtgPL58N/5TmCWCz9au7YQ2TgQw99Ac9TkDj44O/jmN7PP/9/e14dZ\nVZXt34vGGWRGwEK+i1FQUfm9oJBYL69o+JFdIBopWpqp4ccrvWhIStN4Oo4TGilhlBl+kFpKlopy\n5VcUFFdG+QGGgIKKvQMOMiXgMDHT5P79sdez973WWfucfT7nwDv3dc119uyzz9777LP3s571PPdz\nPxH1B0XDZZf5rzKD/fnP/VfxHCdPDo1VuvxLMdCDyKYf6vlfR4cZ7njjDaCjA09TQWOg5cROWr9+\nqewWwDSAtsY78+4B/3/m37OmvCwzu4a5+0OHmjRNjsELH1+Ezuz4uwwGNouIawSi+scKdu0Kz5Gl\nOjgXoQfDgrUSBADP836vlKq1Vk8FghD6TwGshN8wfCr8AcED8CelVF+l1CDP8+JVgVRWBjTDUQ0N\nmKbbqyW1QNJRAMRk9wXCH1NYCjYcXaK6DMX05F8OJ02JdeuCWHayqiqoQJQ62NUIvdNTACg9WC58\n++2gkGlrgU7LYMbkEVZY1IUGXrD4+ecxgwvNnnsus0harmARKzEeuu1jUilUAKj72c/8/6dPD2jD\nCwcMAOB7ZXVSP2FXXhYDLL/NWL8eyaoqv95FfyenQ8HVoIBpuNkYuuSBd+0yWw8CvqHkGL18jmPh\nnZ3hcWprzc+K4bWZNtypSuBKkrIRl+8n+25u9s+f8wyc6GWP3dU83E76xkA+Ab0BYrw9z3tXKSUu\nxBAA/0vbNel18Qz99u1o1FPzTgDrtYEXsF++C8DfN+pgw5lnYgn8jH+DUqi/+25/vVxIPUto3Okr\nxPfR+5hZqsRasfqcOrTfawDMpp6jcksy01iKXyoBzNWD4axbbw08lcZZswri4XNsv0E3qwCAei7i\nchii199/H0frGUrTkCHYnbJFPBRSaXI7gKROSotImsggZyuBnAuSVo/a5Je+FC7TQGg/1NL+cGoB\nztFg0kQ0Hhd+1wak4vWqKqMu402l/BoWjosDZtybDb0YQI5Tc7JTkvXNzSZzR9DZ6faoeZBpaTGl\nEVxUS/b4WWpBwAMU5wX4HGtqonXrWbBNztXRHDwuipG5cT1FKXeYUuoKAFcAwCfySGqJcmFwuT79\naeP95KxZSLCA1/8BtAJIOipZ16du6uMCn7OR/MMfgoe0GGGcjAndJ580buKkK2kXE8WWEk6eeWZR\nmQwryHhOkpg7GfM+AP4e8Vn57ZJ9+hgCa12Jp/T32YVQ0yfIebz6qpmM5PBGTY1pdCW+bRtPTo7K\nq6xLl7iUEAwQLXDGXjdLHwjk/NKxYmwNnv79owusWMgtqtK2hB79DgnJKKUGIVT9bQKMSvahcBRX\nep73E2j9pHHjxoVP5eDBgXeUzYPZCiDxqU8B0EafaXgrVwaLdfLDZnmhcoZMac8+O73mdK5g2Ycc\nOjt1wBTzcnlhhUYlYFYlOhpfP5LH/kuhF5+Q/X1YKDa/iUmSDwCCvgg9YM2ETjsNgK+dLwJ9yQUL\nAOiZmvQnKCA7yHVtE7qzlSCQd9izJ9BIAgDccQfQ1oanSW9qkBTRVVSERpw93aFDQ2974EA364Zl\nEsS73rQJGEeha9k3h0Vsz5g9ZhfDhRuVMFsmqoiLu2TZ9saWOLZlirl4CzBDNz17ugu30iAfQ/8k\nfEafMPuW0fqZSqlH4Cdjd8eOz1tIHH98oLBoT1tTtpVE3+TJuO773/fle2fOxCQAq487DhP0zbeO\nbsjRpQjbnH12uFxktk1g9DWP+v4BAyKZKfLD1x1zDPCINqtf+AJw660AgLumTUOEeLGBXKpTO2D2\nRRXjMW/qVMxtbMxiTyZK2RAkKcdSKlSlzKJ94fP6vE5/553QeDzhV4gkr7wyTPwSPoTvpQPA2fAf\ntOB8tIEHkFKQFLSYLMT9Lgno3/xGH6wSf1fK0P2Re3617jG7CkDdbbf5lOKZM4P2gS8BmLx6tV8V\nv2ePGf8Ww21TJ8XA7dtncurtZtojR5rGUJKbEyaYhpmrV1m/nsMwLHcgsuAc/hHYBtpF+dy3z037\n5H2lC+HIcjEkEJRSD8PP2/VTSjXB1126FcAvlFKXw2e6nac3/zV8xs0W+KQPW7MpNn71yivY9Mor\nsbZNTpsWxgxvuCFITkmzhxVK4dMwC3calSpsbNXhsc+vqsIcm1ZYLIOvH8K7/vAHZIriyS3WvnEj\nqmSWox/ehmHDUL9tWxA66YGQpbPS2k8hZAjEEFUgfeOKdCiHrk9yvIz6NzF6BScdMsqMJ9O8J3dh\nctgwwwD/k67HwQV2cuT3T8yZEzBTViDVwKyrrg6SdTO0vlWDUqh/5x3T0LnkAwCzyTcnL21qJse0\nud9qS4tbPIzZM337mgMKH5v3b58Hx/IHDjQHLlvTntGrl6/e6drGZdCZuhkT5SNT7GgOXugH9dMA\ndHuT0KM9AA19VPOMOCikfkwpjlkOBt5GHEOffPvt6O2//GU0PPggAB2q0V5k8swzg00uByBz3HTX\nTe60udu24Z+U88jZ0N/pC2Bs1sqpR7rkDmSGppSRIzhLV/Yu16EbduHqt20zdV/ESEpHKMDkw9vy\nwFLRrcNZ+Na3gBu10HdNTTgDaWoK17MB5gGgqcmkT8q5LFkS5LMCcIiYwy/pkqcuHRs7vs/c/DSf\ni0uvLGtDDyAolInDn+Zsf+K22/zP3XADgOKpDGZEiYqkGB8oFcS44yhPstd3FH2OG2BE8fKlpvcR\nAJcK3Y/YIHGQSCb9z2WhjJhtQ5BiYCYt/xgxnAZ9L99fXW2E1KSiQAINW2DSW4XAyQTGxNe+hoYf\n/ACAb+ilBKcZfkMYAMC11wIANt9wA47UaqaufEhBQPRenHBC9HZAcB1+p5/pUz3Pl+HgZCjz6MW4\njxwZhmB27QqNLAufCdauDd9niYShQ82wC3v07MW7CpKam03tGQF7+TxwRHndLqYNh31YMZPj/MLh\nJ3qlGjJk/9Kjj8I/9c0Qx+s7TyefksOGBTc5tKGfpxTmfu1rSOqHQ8o4it42sIQGXrAI8b3jxHXX\nBdRTo4kxKLYrrKX33gP27AnixEFrvpNPxqUyoDU1+Q2ikXsYJuM5F8CLlxv/EzAlFPg+k22i0vbC\n+JLtkkqZDW1iDPIuhrtd3+1iqMt9LGjm96RxyQ03pAgAJpXCiQDOOuigcKWLJKCLsv59+eUAgI9Y\nnruEQK/2PLygFD7lqHoOWl7av5c2qKdKsvjss4FFi9xhDea9s3fLIRPZDgjXjRhhyhVw0w4Gd4xi\noyrYtStk1YwYEWrjuLpe2fIKdkinVy9fPsMVorGXbS19HkRcap0ZUPaGXhDHcLF8MTNPSm9qCXGU\nIrsQDQsWoF4MvfWgBdectXK4MI2bobe0BA9KtgY+ridfSC9eUuT/j3IRgHmfxeVlxd3ONSvdA+Cx\nmJ/PBT+XhTyblmQCP28ZZ8+aBZecPh0J0d3nmDZrwNjSBHaMHDANuRjArVtDjz5dPNuusLW3t2WN\nZRtbJ8cFW764rc2cCchg0KuXabxZIoG3d2nxx0T5h2408pmSJ2bMCJZXL14cLE8oxXfvCkO/YQOe\n1g/2n7P42KcBnE6emTy8uuDf9+o2bAgYM0F3L9tj/frX/c8TEyRfFDoWn2CFR3mQN20KjEpy2rS0\nhT8Z992/vyF+1qAU6nWv3qTVGSxg7Wi5ALv4Sa4uh80SBx2E+f/6V7A+cbHfgyz54IPGTGSsXp78\nzjumASn0TDOHgsD5SuF/9HLV3r1mxygxtixlMGKEKTzG/HUJa8i65csDWipqakJPvF+/MP5uJz3l\nfw77sNbNb34TVCcbDctdyVMWOLNFyOxBSZLPLsqmwFav1NfkwInRC7TG+vI+fSJ1uNNBjH0DGfqu\nkpstCXQc9NHq6rSGaiSA6Y52jACwhgzpeLpWC2n9rHTXsH9/JHUlcq4olIGvAFVDSwFSOq120vTP\nSg9HDyAvDBiAT1EosQcKm+CugDmTSIiI3eOPQ0oG/2h9Rqp5AYQ6QkDqdRCdfZeWz+c+Fy7/+tf+\nqwjOZal9Lxr2s+0YPXdhskXF2EvmWLstIMaeeG1taOhZmMxWqWSxMzn+1q1mBS43J7fBMwE23Kw8\nyeEdTijbFcB2dyz+jnSsAyZGbyMfI5+CPXsKqwPi8mq4CUipQEqPmbzRDgAPVlXhYmnsQtS/8TpJ\nauOzMU+jXIw84Bd6DD3ySP+fMWMyi9zlqMuTHDAgSJ5yKLHQLCY7XMSV0LaBD7bRrJ0e8Ps6CKS2\nxFVX8qZ+rxitNuUKL1AK13E9gZ2sdMW07Upam7XC+2huNnn2zK7hpKfsnxPALFPMSVI23K6KWrvA\nybUPO/zDMxqeDdhwqVtmwH5j6CUBmNNnyYsXJHbnqp6yf6AhpgjYWwAS3Ff3858HHvOjxo0UO6+7\n8cZg8OKq1WJ0EC0GZXLotm3AVVfF/0AenZmey/FzmZK/jMRBB+F9HbqRjl92hWoUPkQYHjrHtQEr\nJtrgfI0gx2tlDH52CETATcNHjTK56eJ1c3MQOfcnngiplhUVgfopWlv9wkA5JhtsMbybNoX7Yc+c\nQzcyQ6itNWmenDjmAcBuJCLbC7gwzJZDkPPOUoOesd8Yenn45yuVtVa60RCcKVSFjpu7YpM5CBDl\njV69glL5OAPkXbp719UkhAaEBidhMSpOiXkacQ2P/Rkb+Rh5YT2/PmQIjj700Jz2IY9XP2RW9RST\ntw/Ze/F1msUkwmkAcD2Aai0TkBw9OmCL/epf/8I0LXsAyoVoIWN8XF/7hM4LNMyahXrJBQiiKnlJ\nMiHFkz///NjfJw6uk3ASV6mywbSpjkyjdG3DRVfslYuR5MGCYbcJlM/u2uUu3nIxYOzz5nPmLll8\nXnx8/l622Jq97wOpYMqFdUoZrQTjQvposgrMjEJ+d+640wXNRlKgpZ5x/fVBoio5dmzKZokVunZY\ndEE4xPTRj4bL//hHbueh471svFwopIEXemfwnfKUEg7UH5991ihaikKhi86i9mfr2yQ8z+i/wHRP\nI5GrDX5y/Phg4ACIavxnncLPQtIhF9ylr2tPAJe2t5veOnvJbFTZIIpHz/x2VziH9e155mCrWvIM\ngZOqrGtvyxTU1JgMIfbAo7pU8cDBhVFyjiyZLGDpZBoIDtgYfS74WOZNYmONUhivNfJxzjmp080/\n/znQ5ykHNFRXpzU4DZMmmUJZBcbtGQw8UFgjXwlgXl2dz91+Mp1QQHxI+c9LMYw8UPh4fL3OLSQ3\nb8ZgfuOOOwAAfZndRAJ+gLvxTHJ8RB8gcUakh0NbG+7XIZ5Li+QQBn6p3ZFJjDRrzbPAWUWFycAR\nR1FCLqtXh+0rt24NC6a2bAnX8zF37TKFzzgBK4b5oYfC0I3dGMT2sNkD59CNzYF3MGlSCrlcOFB5\n9ILRzz6LJ2I+cIIoOVe0tfnxReluE0ODJAp3TZqEq2VqLDdG//5dUjAFALjpJgBAvZR7V1YGvTxx\n0UVYoK/hdUuX+gqbril5rl48IZ3GXt4dnyhZ3KDzCZ0gNhULyuWBj+vGLPeRbEFJIX1XScv9egB7\nlUK152EWhdYeHjIEGdLM5q5peZp+TY4fb4Y7Ab+v8aZNSGqhMiD/avOeCCt6I2PQAweaLfTY6xZ0\ndoZsGjHWp51mhktc3rXtga9d689i7ASr7DPKgXO1ErS5/fIdtmwxaa5c1MVMG7uTlt26sITqlSWF\nVNkVSlw4uJH37Em/oYXxhx0GnHSS/w/pcFwtD9sttwAzqTg+R+pZvggEtkToTalQ4XPMGAhJ7vXp\n0/EGgCkuQx/Fjd5AXJ40JfXpjHYhvPioQqukUv7+N2ww6XSlZD4VEJlkp1fr9/OtC0nq5C5gcvkT\nc+Y4t1+lFCbmccx9AM4SmWKbRSMe+MiRpmF2Va+6Cqb4dwdC42rry7h0Z+xz4d6zAhlwOLRjJ11d\ndQH2ufIyz2jsGQLvmweUmCh7Q7/ZevgLNS1OVlcHzJtf6WTktKgCIMKjO3fiPEdz30VVVZhZX5/5\nwMXqNAWgXV+rW2kdG4nktGnBssR9ixFkKraBj3sOCdF3yQXbtwcVs9nXIRYWcpewUIF0CINSwfmt\nyPM6RuYWvv3tcFkPAKfI/x0dKQNR8Bt/5zv+6ze/6TxeB4AFo0cDAK7bvdsMR8gztmtXGJY57TRT\nS4aNncgHixP20EMhuwYIZ0XNzeF6Vq+U47W1mTF6IFx+5BHgoov8ZdbOAfxnmc/H9fnKSrNLFqOi\nIrrbFGAyhJjPHxPlaei1l53s0yfQ6ihCyw78VDNStsJklizVD8z0CG/l0aoqnCdxbX3xZ/7wh2Hy\nb+tW4J57/GUdOkkOH44rAAxyaILkg1/pc10P4MYcPh/cLm1tIWXs2GOBtjasIq9u4t69QK9emKeU\nMauq199nsdUizoVSK03OO+44475JLNMtEzo7w1grYA64r77qv1LpuYOjUVJkuvcLdX5RTlTS0psC\nfLlqm40VwNLOWaR/Y7ttZ8r3Es/X1nphx0rAUsKcSHWFf2pqoiWAeR/cBcolX1xT49M2TzklmvXC\nBtpl0CVJ3Lu3Odvv6EhthG5/Xy4Wy5JqWZ6GnvDzzJvkjK20LF7JSOeWIToBXMjJSz2yL73mGohZ\nnCy0NwDzhg83bugG8n7SVubmEPK5NfMmAeShfgNIjcdq6PrIoLhmr35gs51VdZWUMF/3HpFbAXfr\nc3kPQL1QGfNoY8gIwh6//KUhTeyCBM9+Ya2XR5p9uB5AQJdMjh8fiIzFaRaTK+zfPVNIKVlXZxIh\n7rwTuPVWrNCia0bJjx064aIm8Z6bmsIBmgupgNCjF3BIhY37pk3+31VXmS377GSpS5u+uTmUKZZ9\nNjeHA1G6Z1WciShjzgy9nj1TZ/v8fg4oH3qlpifmUxiVK8YAWGutqwBQJ8lVSsI8qm/u81zXTUrH\ngdC7X7/1mE4SAAAgAElEQVTe1OogUbCGujp8CCBx4YUAgOTDD4eGQabLEhd8K9Q0lHxFPrMcucWE\nZz7c8/zmBwAweDBw331IauXCWgAyCf4eskM56sUDIRNr5umn427d5OM9FCY0KNLNB1uhQPneN8I9\nKMs5RZIHigAmnn6K+PqFhvD52dCvtrfhGYIUQA0d6o7Ls9cv/zOeeSYM4wAhS2bECLfWO+COtfN+\nm5tTY/8CVxjWFaZNR71Ot719Lvr8VFVVcemVSqmjASylVUcAuAl+SHMGAKl//6bneb/O9TilgG3k\nC4l548c7DXI6DxPQOQTN9igGhF+0Ub8O/9vf8I4u2X8OpuLnVhTfwCc8D7crhdmOoqFCgWPQwZzs\niSewT4cm6g85BMkPPsjrGBUADpYE46ZNwH/8R/AeX5OE8N3XrzebV7z1lhH3rgBQJwl18qD7A7ha\nz7Ti9GqIglTxfgvFMfACFnKLzAsJdZLDEhyLtuPyLv168a63bAkNfb9+oaHfsiV0njjW3dkZzhxq\na02jKiFN9t5ZLgFwe9uc0JUZuosW2dZmxvHb2tyyCvb3zgIF8eiVUh8BsA1+j9hLAbR6nhfbNpyg\nlHexXs6OAxMikDt98slIg2ILSwXdd1asQHLSJH8/8pACxkOaM159FRv1A7QaYSMQaWQe3IArV2KN\nNrTjpaqRPRzhR69dGzRTyQdBonLlymA6nBw2LOBpx2lY4txvDlLCcT6T0Jr4+ernFBOFbG4j3/0r\n+v9hjipj4fe/jOxh9KR9zhJtoJ4DQHbSDHEgproSxFbbsiU04jU1oRolSxMbO+lrFkHxDAAIJQ8A\n3+BLaGdkmuCsbFNbGypccmVsbW14HGbxRMXr2dDbDcTtsJJt6AWuWQvNZlR1dUkLpiYBeNPzvHdU\njtPyXA28eKYPPvUULtYP2skI45n8ENSvWWMUiwSsefrx15BXM74QD+7AgYHeOD8oyRdeCJYTWuVQ\nHrfxEqaRm71ASIgEgDwEn/iEQY8MYvWtrWgYMKDosfhMhtH1fuLrXw8rQYvc4CQTRNvx1AIn2IGI\n7+55ZpWvNtBrlYr1WxnqlemqhXv3RuK//gsA0PCHP0ArxjgboOQCCZgkduzwjWj//qm0R5eBi0pA\nsvKjgCmSnGjlillbDM2lUsnHr6hwa9bHgYuFw8v2QOAKHTGy7BtbKEN/AYCH6f+ZSqkvA3gRwGzP\n8963P6CUugLAFUAoH5sL3kLqQ3Eq/T/lu9/1F77hR041OQoPAdjk+Oz4Qj+0ffui7iVfc7Nx7Fin\nV/Sg9uR7AKhjgTH6kefrAqdsdX6A0BsG4McuZQARTRM97UxWVwcyu9kY+UJ68Rlxxx1IcJ3C0KFI\n1NZm3b4wX9QC+BuAS0qd47K9bwDj4D9ogPm7JdrbgV/+MlyRjRSEzjfVA4GH+a/qaqzI5lwzIDlg\nQHgfMKXRbqsnaGoKDS3LEYwYEYZdBNywpLPTDO3wvjlcxJLAbIzleamtNZeB1E5TnNyV8+PkMn83\nu2CLmUEy05f9MeuGBd1iIu/QjVKqEv5M/zjP83YopQYAaAHgAWgAMMjzvMvS7WPc4MHeFGl/lgPS\nGQ1D8xoIPNjkxo3GZ6O01/PG9u1YqhkcLv9ciGNX2q3nODFqoSFX9osecIKb+4wzjNhiJhaFc59Z\nePH8TfLSGZJro2/2+6uqjB6sxYSoPY52yDqXA1YrhQnSog8wBMoKgUYqXEzo5UbPix3WqYB5HwTS\nCm+9ZUoGiKEbOjS6kIgFzsSoiwFuagq99ZEjQwM9YkRogHv2NHvTSix+4EDTYEu4ZsyYcDYsBA02\n0PYshLXr7ZCNvY0tkibnyAbdlibu3RtKqZKFbs4C8LLneTsAQF4BQCm1GMDyTDv4IEcjH0dHb/a9\n95ordFXnyZYxGr+ikL4K4Ze/TGuQj+J/OHPvMPACGRyyjqPLzSYFKOLh5RAiyoVNM6MQs6WOjlCL\nRcdJLwCg522oQDgAZjsQViB9HLo/fK33q8uAqRaFYndNkwboDUqhwfNQ73mog5VP2bYNAHD7kCFB\nCFWCLrPXrcPDrqQvNxthXjwbNxY74/eGDk0tIOrZ00zccjcqV4KTmTasH9+3rznQ2Bo0LS2mty7H\nbG0Nz6+mxq1pwzMNHgzkesjx5fxkH9yIJSYK4dE/AuBZz/Pu1/8P8jzvXb18HYDxnuddkG4f48aN\n817UnWuSDQ05n4v4VlsR8uElnfokgDl792KRZijMlFZyxWrxJ54yCRT9qroa0/TAs1xTFwFgcq6/\nQWUl/leXrd8XY3NhnYiPtxV+sk9423HDQvlSJnsAqOeqVYeMwiqlsFIvX4AwPjyrvd0vWgECQ18o\nhk6mLlCJQYP84737bkjPjNkEvCCIOM5T+tpP8Tws1ssFVWZlSKJQnIMT/JSwLbmBykrgzjsDtk3Q\nurGmBo8SS0hM24Xr1pmhGPaAOX4t2wwcaMokiDfO4Q+mT9psGSC1e5V8JzbuffuG6ydMMBO2gEm5\ntFsGcrKYl7nvrawfMcIMNcmMRs67pibctrU1OL7q06f4Hr1SqheA0wFcSau/q5QaAz90s9V6Lxq6\ngrSmoSGtEFa2eAShRjijYcAAAKEyIG7VzGb2biNKt53o6DC5uvpHWzBgQGBgWwEs1Ab+c/zZM85w\nxl4z4sc/xhYaMDJBjNhWWrcki8OVAyc+l/BSXGSaASTzCC8eaGjUktd19j0hs63PfAZvcm9cCk3I\n8/AuLGVZZsSwkJk8VyNHhp5+a6spk2A3zv7e98ImKSNHhhII+/aFxxk4MLVQS/Ytx+H4+vLloYGX\nddykhWUKOFlqNxLhSlvuPMX7YRE22Qd3tyqleqXneW2wfivPC5iSOSFbIy9hjK8AqBJWwUMPhd7e\n/Pmhp3rRRZipuenJt99GQox8EbBQGySbTSQ+hlT8GjS3LDHv8stzLpqStFzc4aUQRt7wQ9OIoQHA\nRM8D++lHy8KGDWGC8dpr/fMoUJHd/wD4sV52XdeAjmtfi1IplEYcZwqdT9E8eYGu/owMcS3XkdrP\nfAbDd+8G9G+TrKry76HKSkzT5IDFO3eGxWGs2GgrWXLYg7XcXa332OBzMxLZ3/r1pgcuYEVINsAt\nLeF2a9eagoaAb5RZUZN7wLKR5pkD5wgczqExSHA7QgGJKcZF+VTG6rhxo6WlEgcfAzBTjLbVCzSY\nytqCZekaIBcCepq9s6oqKMj6I0IOMRuSObn+BlTktCSLj/UAUH/bbQCQkZNfKC/+ev1aHacxNxAZ\npvi3UviIVA8vWQIAmL9zZzCYnwIEIZ+4EA+zftUqeDoMdDOvL3RtxYEAqxfy+3RPHEr3DAutTZL1\n2ym7NGGCn4j9/e9Nj14Mo23Q2JNlw+zqocrNtnkQ4aQvywGz8ea4O4eL7Nh5S0vIueeCKubfc8EW\nh6U4mcyhGebrC2zWjT6OGjBg/2w8UrdtWzDiJmMYQLupSKPmFIs/sAdWabXcoFweXSjwvnV2/tcA\nLtF87y2a7/0FAIflo6wo+MQnMEyuURbG90NkNvBAYUM1vwRwCWvquMq9paMV6eA3KoW6ZBJrtCSx\n647m3MLvHe9ngoRslk+ciGG0PpDSYvXGhx7yX7nApavRFVLYYoh0jJ5nrtywcZJLR0mIBpqxNE8p\nzOXBtGdPk23CRlJi8baaI3PmAT+Wzro4Ag7LpFOMlGU+j02bUmmNbKA5ocuce8DtgbNMsj0zEHBu\ngQeZ/b45eE0N1mXh4crUL7l5c+SXESGxejL4C/S660SgTLTKuSotnwfnet+H3QqgURv4DwFc5dq2\noyM3g9HRkfUPHgfFiMVvRdiw/GQAEzMwcJJVVc7f8xYAmD8fgFtGIhetGjnOOgCTNWPksSFDAoGw\npY8/DgCYzsaoG3lj/ttvh7N3Zt0AZm9nu32frOfPCpNMDPfKlb7KJOAbYhkgVq4M8oEpLBledgmi\nLVkSflZyeZw34IbgW7eaXHv2xl3tEG1Gj83u4bg8n2tMlJ+hv/ZajL70UgDAE/ffn3FzkeatOvfc\nYCrPFy1ZXR1UMHLc7CoABxerhd5FF2EzVWtyKEpi81887jgAwGFFqKrMB4Uw8qwpU6uXL7n33lD5\nD3APbOTJpxSy6Y5Z4x0hnQVKBR5lYts23KXrFljJMYo6WQvgEm6arb3NQITrf/7H8akyQ4mb2gAI\nwxUaw6KcszTnNgake8PNRvr1S+XFA6YiJW/T0hIaRpdcMXvuI0eajBaO8wt4hsDhGFbM5KKnpiZ/\ndmLvw1WYVVvrbnbS2RkORi66KEsTu5qbZ0D5Gfr7QqLgN+6/HwfPmAEASC5enLJpLwBVOrm68/HH\ncdgjj/hv9OwZ0KAqAUyUlnP33OPLk/bv7/eqdGWu83lo5IebPBlH6h+l16xZEFPxgH6dcemlwKJF\n/j+dnbkfs7IyMHiJl14KGA8sIBUXhTDwAYUOAGpqsLi6Gh3Qid/Pfja8kYGMyVh8/vP+62OPud8n\nIajBCJP4DUOGoF530kpOmwY5ynkLF+Kn+rpsRcjEuuTee/0E3WVWTd/+YOC7EgXo1tUJ4LCzzvL/\nqahwc9254jUqFt+vX2plLGvY20wXHgRkuaXFnYy1PyvgEA3gz65tRU3elj13ljngginmxduhqHRN\nSWKg/Aw94eBDD8VCh4EXtAGGxneNDseMBzBBqyB2IOwnWs+GqNCgkM8Lo0cHVbBtCIt5AKBez1YK\njosuwu0bN2bezoFChWqCknZ9LbYjFOWKBSvBByCUZ9YPwfNVVTjdivu+gTBkk3jnHb8TkUbQ9HDL\nFqNBxzGyIB2DulFy/A3AoqefBgDMvOUW09AKbFExTqoKWLNGtmWD2tISetQvvugngAGT6cODCIdR\nWI+ew0hsoFn/hgciHiBc2jn8XR0SxMb73NLQPk4MlLWhR3MzxDeVOHu6GKxcypcATKCbRZYWDBiA\nT+rlHQCmXUUR8wceQE54TwcIiO61CYBEG/8GQNK+pwHAj38cfraQibwNGzD7ZV/CLak5zpmQr4Hv\nBWCOxK2ZMaFnKCLWtnzYMHQOGYLhZKCfouNMWarVrj/7Wf/1t7/FXY8/jqtZ90fjj/ALNwC4BZ/6\n9Qvpl6NHB+JcuPFGzNLUv8a338ZkkYPgRu45YpVSgdYMQHIbpSqk6goU4LtVwm8QDsBMkrIeDIOr\nTdlI8zInN11x8dZWM+5th0/klUM0MltgY80SDa7BJ4oiGqWhv2+fO0cg+7T1d7IM35S3oSdx/myS\nbLsANJCxk8s/0Ll1YfBOdTV0vSb2wJQnECPwCQBHC88YCMMTXYBCePHnA6aBtx/65cux/Jprwv3r\nZOxRCAdfRkOfPqjXUhTvwW+/CPgVz7xnSerW605efG+0V1ej6pjAX8e8P/zBXxgyJMjnfAj//kjb\n4YvBDWV0v9F/79yJj9x9d7zPW3hTKePBi4xv25A2hzbF8yc/8V+vuCKn8+kqtNgrbN0XINXrtkMy\nst4eGDhMaOvOs5fM8gaupCp77DxgsNKlgBt88/fgJuB8LrbsAn8v3gYwB66KCnd7xTQob0NPFDz5\nWs0xP8oPvyQHZ1x4YUir/OpX/dd8E1naExzW3o5ZzLfV9LPk8OGYaydci+Xhaapb4uKLkXzwQecm\nuRr4hObdv3DDDUGR1RIAie/ptgPSUeuMM4C/aYmxU06BtPF4hPbFDOHzASyYPh2Apn3qvgCMt6z/\n5bcVuWLGrQAqKITF9QoSXNMTd3ygFA5pbAzvBSD07L/73aAgKxPGwZ9ppEAG9VIO6HLtCyxmloIC\n3cMBc6qmxt1mzw5psOcepSsjYG9Y4GpcIp/jsAzz5GXfrHyZSXbYjr8zY4aXo6SGbUPPyp05NB4p\nb0NPiGvgXQguy623hiO9XCxJ9uX7MHK12jPPpB9xf6HVZc6PI8sWH/k290iHBs275wG0NtP5aGaR\nDd7H0Tt24Ghdc5DUUsz5Iuox4E44X89ifw26iKp+4UIs0I1PegG4UpfYV/frhyOmTUv9YMQ9NXz3\nbpObHxM7tRjYYdZvuehKX2VkZjYevauOIRt85zv+azYyIRYqQIa+b18zXs3t/sTArV9vNidhb5i1\naWQdC5NJ+MX2uoOTqTANsEtumPeZrgOUvT+Gfd72ZwB/cHEZdR7MSimBUAoUUtskOWyY8X9CszPy\nAj0wO3W590MwGx/LdxgDYOpS6r5YQO8rWyOfbZjGFTr7GxAmPuXG698/O49j9epQpKyIGIWwKnk1\ngEOYWutqxize/L59ECLhU7NmBb/rHiDQT0m6jHw69O4N3HFHdp8BcFgEHXgm38fF9uSjwCyqDRui\ntyMYdwkbYE40Dh0a6tScc46pGc+fdTX5dqlOAtENumV9ba05SPAswmbbvPhiOJvl/TK7R2iZlZU+\n4YAHC9d3tvMLsi7bZieE8jP0v/2tc/peDDTSAyqXkKssjRguSRoAqV4VOjshLR5a4TaMawGs1WGK\nBGuGt7XlHEIqphefCR8CRseuoN3f+yl9ZiKRnDbNr1yurAQefDDQzI+bUI6L9bDyAty8HQiNkxis\n9esDrrh4nbsQNkl/BAh6j2bq/1swRFEahUUCpHceJJYPZK5pEIjevmY/PazvHQmn1WXw6I2ku+N+\nDIx9VDMNLjYCTE+ai5pY7gAwk5e29+sKtXCjEvuYfGx7/UknubXm7c9VVKT2lbUlGKJmAPK+q2FJ\nTJSfoS8hMvqdP/qR/3rKKSkFIp5SUO3tYSl4U1NqcikNZHYRtO9rawspYDG9smJ78dkil36uLE/R\nA4js6Sn+Yjxf0Q0uQUlu3uwff8kS01DK+xEDDecLXonBBCsJ0jGGfvtb5+q7SAhOfOO5zH6y8hP/\nqxQ+TiwoeXb+qe8pphBPVgpjs9VvijJcUSGKqNg9x+A5hs9etJ30raxMpSuyp837dA1GvG87eSqD\ns6t5OB8nCjyY8aAU1VYxAuVh6D0v6JoUX0q/sMikmnk3PdQsY7BUx6Gzb93hI1ldHRp7htwge1K7\n6Zabgc8HgaohgPpk0peXvekmJHbvRoM2RvUkhPa0UkYf4DqtwS4sJxkiL92xA0ktRQ0AiXPPBXRB\n3fyqKsw591z/jWeeMb1b2f6114Icg/i7HQhnBa0oXA/VgiKNk5DUsfxKhEnqTNH55Ntvg0vJWDLw\nG47tJ8tCWxvQ2opX6b0pGY4V6UW7DCmDm3/Yrf3kc1H7FrDHbHvPLpqkq6I2aiZgQzxy+7uki/vb\n55clysPQE0rVEi4WiI1xpabsLdu4EU8CmKqNU6B/MnBgYFgyNbCwkaRGDILEIYf4C7pis0HLQaRt\njJGFkU9c7KtJR7FzSoGU89UyBwCA3r1DAw8Eoa2zXnsNa60k7wUAJOK9D8DVjsK42x9/HLO1Pkkb\ngPlav2aO1raxwYlk9sXYIZiri/KSEyeawnnlBNGHh1m89hQtzxR5b57ZSO7l/vvDmaqmuwokuc1z\n3eWA4biw2RNnTkKiNaBQKevLA26jxkaUC5mA1Fg3M11s0bOopCbvjz/LBA6mdNrbuipebb15Thzb\nA5fLmDO3P9OAlwZ5G3ql1FYAHwD4N4BOz/PGKaU+CmApfGLGVgDnuxqEC959+eWcp78sMnyqftgK\nlcCV/SSOPx5LNWUvZQLGVXt0TivzPfYHHyARs4o2Jy9eF4glZIp+wgm4XSnM1hovucgoxMWNmTfx\n4cpbHHtsih78IZ6HBMtN61BGor09+A1bgYB/nlizBk06t9A0ZAiGOq5fYsWKIFfE2j0yid8FBL95\nD/gFfbF5+SXE/boqHAhrO+rOPRd/1wNdQow8gPu1w3HpbbcFLCvA787mgjyzb1jrxXHh3IWRx9Ay\nxX1BBVNsOPv2NYXMhBJtG0U2mFZoFaed5n6fK2btoiZBba07L/CFL4TrZN8sXuaqaLXBXj+zbDg8\ntGtXqmgZz1T69cu6YKoQrQS3AhjneV4LrfsugH94nnerUupGAId6nhepiztYKS9eGyoTkY0gAKCH\nf2vFkTqOQqSXFpW84jicng3k4zEnli0LlpNTp7q3ydLIp2ukjmOPDWR4C50Mzeo8Cgijl6kc84QT\n0PjKK8H6lC5J8KVzo5q6JA45BBs/8CsEjilD4/4ufedBdA+3kwNU5dLY5zChNizJqqpAF+gTyD1E\nyZCeskYClBuFcLycDR6HaJgyyfIAHEPnBC1vy6JmHPKRfNvIkamiZbK9gD/nkm6IamTO+7C/j6vJ\niMv7Jx17NWRILD36Yhn61wGc4nneu0qpQQBWep53dNQ+cjX0QBqDobnqSc1yyQWf1q+n795tXvw4\nhl7fKA9XV6d4PIVAQQ28C5buzDt630sQzqJGIF6vWsEoWp5WKgMZwRf/N12rjzjOpV0p3OrYnYTU\nktrQl2rAygZs6IlnY8ykXIb+d/pzp65bh6SrgXeB4LwP9uwxVR1d4RXWb6+pMRuFiJFmpUmWQ2DJ\nAlbJZI13Wc+yBp2d4b5HjDDbGspxRLKYu0TxACDb2d/NTvQK7OSxnJ+AlC7V6NElazziAXhOKeUB\nuNvzvJ8AGCANwrWxL3gH7owPmC5GSlhFSXfpm/k9ACfoda1InX6OBFLEszKCBwC9fKHnYb4+Ztzm\n25lQdCMPpLABhmk6aOWwYThVNzjHVVcBujl5HJTMuDMiBuUmWh7meL+qvR2Q0J1QYSVn89xzSDg+\nUy5gLz7BIYgMFN5TiVUjcfYV1dX4k143Gr6OVD6oATCNJCoCsAQxF0lxWIPDFVzJ6gqT2BrwYjib\nm824ud0xSuBKqtpFVfZ2thaPK84fpY3jCtfIej6+7DvL6thCGPr/9DxvuzbmzyulYs3ulFJXALgC\nALLp+Bm/FbYbV2u2RePjj2OKLjRZNW1aiqGfrjnhAfIo+ZZWgXcpZWikZ4uSGHiB/X01m8MIk112\nGQbr4zfDnSguVzmvjPoy/P11Qde8558HAMwt1kmVIf6MMKGar5EHfKdqIUlUBJkgbvfHsMXLXEnI\nvn1DT5vBHj3LGLgKoDh2H6UU2bOnWXnr+lwUW4f58BzfZ80cV12AwI7/lzoZ63nedv36nlLqcQAn\nAtihlBpEoZsU+6Y9/58AfugmzrEKMk3Wkgd1tGqi52GlNlgypi7cuROzCtzQ4WrPwzx9nGybepfU\nyGcBbkYt5yO6OACAb7hIePsHjBxNZSXm7i8a9Y6ZZSxw/Fjf+3O3bcNTupHLlBkzgsRo8vLcXK4K\nALO+9jX3m6wNL+A49q5d5jm6lB0zebp2xypXDNxWinQpT/IAwaEgfp8HFBdDaNcuUwLZVSXLrBv+\n3qVUr1RKVQPo4XneB3r5DPh9lZ8EcAl8jalLACyL3kt5YZZDGreQEI84Lrc9GwNfsgrNCATD4pgx\n6Tbbf3DOOeHyr3/ddefRxZDm9msXL0avNP0h4qATwLwf/CD4f+6dd/oL3CWK+6OycbU1YNiQsvfO\n2wOpnjgngF1hFPb0m5vDbVpawvNiAUOXkFo6r3sTBT3YqLs6XzFc2j4xka9HPwDA48o3PBUAfu55\n3jNKqb8A+IVS6nL41Pjzcj1Aor4+z1OMgbY2fFEvbh4+HEeWgBOdiGHws/Xii9bUJCbmiMa73JAj\nR4Yl9EDYRGQ/wYO6KcZFAEDJWSfLq6shSec//QnztAjb3ClT8NOnQsb8JVmc92p9n01obw8okPsA\nzD7+eABAklhLgElBzYS5rtqFmhp3jJqNZd++pjfMHZnE0+fBgpuAs+fsOuaLL5r74wFDS12goiKk\naboUMfmY8j8fSyB0zObmVH0ceXUNQAw+1xjIy9B7nvcW/ByNvf7vAPIWrEns3WsUE/VqaICYjZwS\ne21tgZY5AHxZvw7buzfo5WpM12WqLlK8BZBmjSUJnAMvPrFsmSkO1ru3s6q2aNi+PfM2eWj6lBVe\nfhlPa/rpWeVo9KPAtQassS9gDXeNn1ZVGSQC28ALsioQ1KEggO515rRzjNwOowjYo3d5t9xgxKVX\nL/vm9RyX58pXV+zcdWwOv9ihH14voR47hs/JY9mGBz9Xsjomyq4ylmEY+RIdRwpszgdwTFQssYjI\nVcKAefZBVW2JkY5775R5KHPI/EM8+Q4gEF0rO4gTcvLJYf7ngguw9amnoj6Rgqd0NfCUH/4QKwp7\ndpnBhosNY79+7nZ7nGDlhCk3+HAxVlgZUraTfbiojBUVYUiFWxm61DDtcA03LGcPXWYfduNxhnj9\nrp6xPXs6B+V0yJtHXwjkwqOPnWzcsAFYuRIA8OY112B4YyMAYGNdHY7RNMF5l1+ekhw9H8AxHAq5\nlVjV2bade9KvLYwqegIKr1FjqGOWQrq2o8No0NwwfDjOADB+zpxwm+9+N/Vz5QyWZLj55tALPvnk\n0jX4yBecQJaZKeCcnb5O95v8kn9EYUXbPgZgppXkBmDWO3BIo6nJNIwSsujZ04zBM5URMHXkmRnD\nnjN3e2ppCY2rzf7hmQGHaeRzTNGMMsxyrnz8LVtCPj7TSDkXIftmWqZsA0Add1zJePT7FZJ1xLdJ\nwxz4BYAeWl+m/tBDTUNfYOxvQmRRaNRaKGwYkvPnB8uJ/c3QW3hQx74vLgPnKC48SnwqNvQOPK9f\nZ27bhuU6vFJoZc5PAlhTVYXx9jW0K0m5OXdUOz1uNsJGX+ASOGMDbGvnsLfOxlu855qa8DjcJpCP\nF6dpt0uAjb8nn4vAZuUcUM3BCRK6+e+4H9Dx6cbjjkOdTv4M/8pXAIeAWBSCW8JujCGx761bwxvi\npJN8JUSB9g4Wjh4dqYxZVAPPU+FcYuNRzZ/POMN/fc5vKCjVlG8gVI68mGYT42+MrWxTfrj5ZuNf\nw8BnGSPtKqjXXgv/kRDE8uVYpnv5TpWQ2osvQrdRx7ohQzBbr+ewZgVCbRq+p7MR8XsGEbPxpqbQ\no7bj3tyzVRDV8FvAhtPWrWHBMebXc6iHKZ5243HeJxvdnj3N2LoMKryNLVzGx5HtXcVTNhMpKkkb\ngS9M77MAACAASURBVP3G0EtCSHySBE+jM4CTP9lAUpkNEycGrIJ+AK6M6PQTBTsNVOyGIED4gAax\n8TihhjZ9lXlQ0A055uv47ZzTTwcAbFYKrwPgYVNi2oHW/uGHI/n228H7iZ//HGUDnl3sx1z/QkLc\nmcQnP4lFDoeoE2457ygjn7j77kAa2Ynt20N5ARIFNJKeQ4ea8XqmRnKRlF0dywMBh1TYuLJ4GSd3\nuQLW7l7lSsZyopU9fVlvh5lcOQI+DieABXxOB3LPWEZCy8MCAISHe8opwC/9Hk+rGxowQXsy2V+S\nVNQ3NmKpDvlM/+EPgYceQuM116AngNmk/gfxXleuNLTQjXPPsfAp10EgWV1txuvtfrWPPQZMnpzy\nuZ1VVTiMvUHZ3/PPB1RUAHBwN0IMHIgeZOgDmVqJ0RarSXopIKG8m2/GcqUwmesvmFLa1eAWf8KM\nuueegBvfrA36le+8g+v1ur1/+UsQR7+bWDfXPfss/qr7+j6GkFJZv22byaThGLw29FTm5IZd9MRe\nt6sKVT4DuCWD7e5NYmh5JsaSBYC5DXvjPBjYISKeOezaZe7PFaJhz9xODPOMwjbm9v/7Y+ORbE1Y\nUsdKE8cfD+gGzSnbRDSmzgXJurogdNSop7zBe66G1g4jn68XL59Pp6oYhcDD5n61HR2phnbmTADA\n4vvvRxuAL9I1lC3bAEjp0Kx778VLafIcyRdeCM+/sRENnB8pNFziZXZXH15/7bX790BTBGiXCXPb\n2wHdsL0ZFMK85RY84ficHS/mZjKCZqQ+Aw8PGRL04L10zRq39npLC/AnrbZz0kmhoWZBsM7OgHAR\n6Og/8YTfKQvwPX/Z97e/HTaa6ewME73cypArVrlX6xNP+A6l7BMw+eycaLVDL+yts2Qyw6VZH6WX\nn2XosCxYN+NGj/Ze1HK+2ajmXQbg43aTZwDYtw+NujtRPh69+GUX792Lu7TnI2PzpcccA9xyC5br\nvrMfga8L4kKh5QtYmC0bSL3qVPK4Xq+qwlF6+RaEntd2wAhX8bHk1hsJvxervV6u+WCEGuiJvXvx\nLoUDBhX6vsvW0PP/+eIofQXfKIZOaZHADbxd8sAyK7n5Zl+8TqCNTXL4cMNxWKpVYqfLDFdyOVxf\nMXiwcQqPKhXMFi556SV345HOTr+YCfANtythum9fmDAVFsuSJaFB59DJQw8BF13kL3NVa0uL6a1z\nMliO+b3vhZ+VdaNGuSUVWlvNMI4MDFylyx48M4eYJ+/SzqdZgRo2bD9i3Rx0UCCVOhl+l5o4uA9A\nD23QxyE0tNl2eIpCYNxqawPPowPALFLfS8eqjmvg5UeoWxZPKeJqvd/59KDEgUzXmeT5GPxrJ5Ai\nslsRGvqrGxvxvPbG/4jQw5u2dy86qMnEdM0xb9R8+gnw2UsAgC1bDMncRBudueQE2AB3dJiGR1or\nvqd/Faa4RvXjfOaZ0KtLt10ucAwWi/RvO7MMnKdMmKdna0aV6m9+Ey5fcQUA4M1EAsO5fyx7lXRt\n5df43Zln4lT+/pZxZ+yDpfkkxpC12dlLZqEwW7KA5QMA32hz2z/ZBxtXSZIOHOiOi8txXLIKLmVM\njvPzNhzb5/WdnSaPnwcx+3yZLir/Z4HyMPSEse3tGAv4D9BRRwVNnKMgBv3PjnVxwRehk9bNPuss\n/59Nm9CTGl8/pdX3xmlv3oW4Rl4meLNyMA5zPA8PE+slLuwOXH+k5TtpWa7FT+vq8DnaNri+ra24\nUHekwhe+EDwQddLKr7kZlTJD27cvbBRTBD2h+fSd5pTY0C7cvBkfKekR88SePcFvsYJi65McRW3D\nly3zwyJnn+2vkAEXQLJPn+A+PzWHa74bQCByzcYwilFjs3FcSUkxxJyo5bi4LQ4mYRQ7zu8yzM3N\nodEXvRqbwmkXbsl6Tsy62iTyAMGVua7CrOZmt1xEGpSdoTem0+vXIyEa4HqkTs6fHySNtsD0/uXS\nZuvRdyJVEOxDAA9rrZO/w++TKNuKJNHLSEW2YZpZ3AAiB1woD+dVV2XsZhUY2r17gwehcfhw6P5C\naAFwqTbcm2fNwpFSGUz8675VVZjlkolgiLfdv79/LDnujBn+wq23ArfcEm7PTIrgZCvdoRVXsVpl\nJea49InEOBUDdG5HIWRoAQBe1neGUO2KeR45QjxpmeXNbm8PGTBAmMRlNgzBvTZ7OJ9Tm1PvSliy\n98zeOxcy2QwZex92Mw8BFyzxey7jb+/btQ3PUGypBy6kYmG2dIMYJ5pjovwMPaOyEvjxj/1lPfqN\nnD8f1dddBwDYtGCBIbgkxjqX0M1X9KtMXpsQcvdZ6TodezWr5tzcwPpPfwrbuWUL8QruuQenaEP/\ne4Tfnwew4NFZvTqYdn8IBM2fRwJBsunIxsagrSDGjAliurMOOsi/KeOGQSS+CmTNFIjqDlUWePnl\nwPnYCt1Dttzxox/5r+PGBfdHcIXvucckNkitiBh6oTNrmeJLCiBp8S/Qc8qhEw6HACaP3qUxw3F0\n9pZZSpiZOyxZ4KJXchMUPharWrKB5vCKK/zC+2J2UZSnz9u4DDpTMWOivA09Q1/YLUDQrf6MBQug\nhwEj6ZpLfN7VEm+tY50LORU+Sfa+gBW3KyPWi28StDY+6aTAo+89YAAulTgtU8VqawMWjgH2+rLE\n8gULAACT16wBFi0K32B6Z2sr8JnP5HyMrgAnqhOrVuFunaOQbyEpxkPKJHaf1I3RGQ3XXANoRln9\nMccETJeGPn1Qz3RmjcU6NzMjj+/UEzTQdHa6PewoWiEbbI5dS4yemSsSh5f14l0PHZpa2Wovc3ES\na92wx+8Kr9hVskz75G1dhpylGXjfPLhkifI39JKo0691hx0WGIZDX3sN/XRSqQXZN/NwIRu5VSA7\nI38iKJewNu4wkgHk6SaEgbRvX8Djr3/22TAO6WjgcA6QGjKx9muAmRFxQAVtgQ/44otY1NAAwNc9\nuUvH169eYUlpZePFl9rjHzHCmby7e+LEYAb4CIBrU7boOiy1qMEMvt/XbNwI9OmD8Z7nGwjtxQMI\nrvOMn/0s7/PpBTJAdus/9u6jjL4rHi6xeZfxFbDRFePJx2TjbkswCHhw4W2jCqMEXAnL58I5B565\ncPI5ywSscZicP9lV+M1v/ETIf/wHcOyxmCFTyF27sFknlo6cMgUNWrWvJ+L1arWpgZmQixf/b/5H\neL9yc8Wo8M0IGTz69sVIWTd0qMn1tQzisB07/JsorlBbHgZ1uiRhhw7FTKKpXc1hgP1FxpiSkl9E\nmLeZsmoVFuk6j5laux3L4/LIiovpeiCdP2lSyjPB4c7xgwYF6z8PmMZJWDTZDviZwMVGbHTZG5ft\ngNTErNzjYgy/8AVTg94Vc29qMrn4HFJx5Sa4+berSpWvE++PvXbucMUVu1zp269fam/affsOcI/e\nhh3LJo//SKnk7NkT/bShv3rhQjTM8jtTfogwIXkI/CRrsBv9Kj9busEhGyN/BYBBujctALyumTq3\nn3kmZnse8OqraY6UJWiwmO5SCHQhWyXOfMDFLswgKLTRKBU0RfR1AEH9ad++kMqOZa+8gqmuJhtd\nBW3UMqXx7nr3XQBAf93j+Gh+Uwrtvv99//88w2wzPvWp8NxcFa52OId579w1SgyzGNExY8Ll2tpw\nf1/5iimpwElVFixzqUaOGhUuy7F5xiHnIufPAxdLFkfRJHnwsL8/5w04cRsTORt6pdTHATwAPwT5\nIYCfeJ63UCn1bQAzAAgf8Zue5+Xeh83iWz+sFC4UTfBRo/CCnvb/G6HuyqsIk2OLZ80ypqUS3mEj\nD1isiQhkY+Bl4HgRwJRvfStYb/w8P/pRWIBRADyoz6U3AOZ5tAA4rIviw4/S9TkvSiOIReNEmqHM\n8ahSOE/PRDYC+Kte32/06OB+Ww+gB9EXp3TFb6AZQCvGjoVkV1xhSV73HoBRtLxMfwcptFuqFKZP\nmeJvoMXtggKpLFAJYJWunp7IRremJjSMJH1trGcPnQucGJyYZQPNCV2XfDFr6tj8doEcn9cxz58T\npnbs31X1au/LpmByRa0t3RADOVfG6qbfgzzPe1kpdQj82qFz4Eu5t3qel14TlTBu3DjvRWZnpIPQ\n+e68M/U9TQlbtnGjwZT5h37tQHFj8ILedJxKhMa9J0LWjkiLbQHxzgX9+8er3rSYL0v1oDf9mGNw\nt+b6X9nVujLlzJzJB6S/v3j48KAe4rwVK3D3JL+52pViDHU/gi6BOEqnnYad2qj+BOmNfSUQVEtv\nQHgv1511VkC1XXzccZjB1OAcWGNPKxV4mqe/9prpGXPoQozuyJHumPbWreE2YgybmsxlMczr14cz\nyBEjzN6wrlALx+jZexfvf9w4M0YvZAUeuDgUw3IMducr5s7beQFuQk5hHjV2bHErYz3PexfAu3r5\nA6XURgC5yURmg3QsFU0BnLp9O27XXkgNzCRtNoycfGSEpYDm6sMPD2+ErVsDVcnpugFKQ11dWHwh\nzajPOSeklbrAsxy6UaZLTBjAlRLG2rLFFLbqRsHRBkCbFGycNCmYHa7T4cP4oh7FhWiHZspDdcA3\n8ID/vMgzs+Dpp3Gtri1pAcLwDeDfr1kO5B0AzrrwQv8f9mbt0IaraxNXxo4cGS6LkR4zxjSM8pxM\nnhxSfm3FSpeQ2sCBZsWuS4+e5YVZOoE5/64qWa66ZckEhpwfD1Y5JGYLEqNXStUCOB7AGgD/CWCm\nUurL8CMXsz3Pez/XfS8mw5qRyiXeY79+wRfLhWqZr078EaAY/8iRuF0/HP25ZSEJfC3QybtWUIPv\n63VZmGvmQnheS0Cc3t4e9PNMtLf7vGhBVxp6ZhedeGLXnUeh0dkZJACHAzhVvNvVq1Gp2S3DS9Bk\nPiPEw/z+9/E5Tat8BO46C14nzw87SZ0IWWMdAP6qG/P8P/6eLomKCPQFsOrhhwEAE7/3PXeMnmPT\ntsfPVEYXHdH1OVc83fU5F6OHt2MvnwcLPj/X94k6Lw4vueQYuB1hDshb1EwpVQNgFYBGz/MeU0oN\ngD/gewAa4Id3LnN87gr4uUr0A8aKOvjfrO1YKYPbTycOOshf4NCALHd2Gg0T4qJQOvE9rOVshNXs\nCPUx8hBp72Th8OGYddhhAIClO3cGbI9M51Of7e/s0qYHgO98x3/95jdTP6Ov/xodQhq/bh0aSaRu\nBG06vUw45TmDYtONSgXNbdCvX1DnAQD4c5TUXYlAs795+pkolOIPR8XlKPUShhTPVxwWAPi1map7\nSikId2kiS2kDpmFk/XgOgXAc3w51cDcojp337GmyW3iGIDOAgQPNgYMNMydY5X0XR54/x9IJXLHL\n+vXcnIQNPQ8WPIvRA7iaOLH4omZKqYMA/ArAzzzPewwAPM/bQe8vRoRGmed5P4EfLsRwpSKf+u2O\ndYGRB/wKPqG66anj7ZaWSxzk4sX3QniDMz1tKMIBK9sZxS9oORHhESZJdycTbGmHguO3vwUArJk0\nCeMd5xs5yLlkkssMb+rfX1RMb0aYpGTZ5g8BNAwZgv6gkFlXgjugkXxFodsCitkZiPA5SA4YgETE\nNZDnSZ61nqCKYjZ6HLqJ4qZzRyhWhGTDzVLDrkQvG2MOo9jhGpcePht3m+ppg5k2dsWu3etW1tu9\naW2UqjJWKaUA3Atgo+d5d9D6QTp+DwDnwlSydeJfSPXk0yH5L18KKSgQ0l6LePHZXIJ8vPgKuPn3\npwFYopez9eiNc9AD1hcRxlezRc6s9Cg+O8dDLdhiac9YktMy+5AB7FdKYZpw68upWUcMvAwEtQof\nIrqxRoNS2c+mCgjRP6pEYZrwuNBs/R+3F0Q7yBHh+DR7yYBbp76z02Te2F41G0KWKQDcrBc22OxR\nszFmI848e5fSpi1exlr38l2ZUWSHouzvZX+nLGP0+bBuJgD4A3xmmTgL3wRwIXzpcw++DMiVZPid\nSGHdCFXrnnuCphkuJHbvNr5wtuGaUjTlrkB2D5h4ih2gNoCAYXhX6XPcjviqlRUA6ojPj89/3n/9\nshYmfuABM1wjXiEVBgGIp70uGuSbNiGpGShjYEpKiGe8Pxn6VUpBsgxx2pwHHZi6ytB3dKQMvsUC\ns9kSWosKAHDHHa7NAfgUVTEc07dtMznjAi6kqq01PXZetjtIcQKUvfXVq0NnhSUQdu0yWS8uZgx3\nvhKMGGEOADyLsCEDFYd/XLIPnGxlDXpHNyx13HFFZ92shrs5VG6ceR3ffbqqKpgC9Ehj5AFfJlUQ\nu2k4SmPgBdl6UXPvvRcA8M7ll+Od6moMc5zrRG2wn0ojk8xw/sht6UrCQixQCte1t4ddfjQalEL9\njh34nZZa4JaC4um+RevYyNcCmMac+ijvZA9VN9CA8yv6rabp69NI6+rkmrW1Gb1Ps9WJn6f3KWc3\nRxuwpNbskXSjoXWzbBkap/qK/3VdnYzdt89PggEY9NprBe26xkicfjqSzz8PADgDwAsLFuBT+vfl\n58p+7vaBno90KpCSUB41yl2R2twc3p+im/T974f5gebmcP+rV4dGuG/fcJnZMC0tZhGfHPOJJ3w6\nJWAWYzHPns/PRRdlZo78P3iwb/94cLHBCWLm4sdEWVbGZtNMQ/CjmNsV0sh/DKmFV/lio27N90v9\nf71jm0Zt4OMOIrJdUn8uQUb2V3pqP+2BB+Bpo6g8D//s0ycQjGMkN2/OGPfPlCDeinCQlllLUqkg\n8T7D83z2Bt3MEgJZHeO3WqcURufrRTsGQjHwAleHr+TUqdHX54QTwuUxY8Jllqi4+WYAYX9dgGYE\nzz2H31HrykADXhK+J55oGtbdu8NmL0Uy8gACIw8Az8G8v9KhDZYevYC9XLtRt4BZKMx1d8Xf7aIn\n8ejtcJEYd5YlsEMxXFUr58RMHPvc7a5m3EnKplPaDk+vXuZ9yN59lq0Ey8fQ6wtylufhz0XwrvM1\n8K5Cqw/yOyUnjtH8eqTpr1p37rkAgLsefzzrdoIAfMqjpj1yd1tFhVsH792L67g8XMsrJA4/HIt0\nw+9FAwYEXvKpxx6LN3WR1kNZnEq6cJsMBrbh5KSPzGlkMDuHN6yoQDyT40aH9RoXco9I2CQqqV5s\n8Iy3lIjbxnMf6Hmy9V04Scpw0SPZ+2aqo6tRuHEC+6Jnk8yT5xi9nSRtajIHan6voiJ94aNsJ9vY\n59LW5pZIOFD06EWrffOAATknIY39FcCLdzEWCkVTE6/2zepqvFlXh+Geh3pu32bjsccAAFcjx9lI\nbW1QkLVRr/qLUrhODP3NNwNf/arpNQhLZswYzFzvyK9v2IDh8n20h9kwfnxWTA/DHNL09UMACd20\nZMKMGZjgmLZ+Wr++B+B0+b23bPHVTnNBr17hfWMl+7OBYeRfdrWqccMZ1z/jDHcnJ6pPMO71EsXo\nE8kkkolE8H9dzNlUb9BgwDF3wOwHK+BkLCc1bdEwILXxCN/L3H1KqmftClXWspH7jT1wSaSedFI0\nM4YhxtzeN5+XS5qhszP07P9PqVdmgUKGaThJKihUb1q5qYf/8IfhuiKqOCaHDTMKyuTxahgwAPXJ\nJABg1ZAhQdy9XhurxUphO4BeZPDm6JzC7Zdfjtm33ebv/4Yb8js/pYxEtBj5pFJIzJiBeT/4QfBe\nBy0LDta/8QSb5ifFPMJzT5dQfust3D3cH7quzKPJRrKqKvU+7OjAP8kAH+wyjK6eujJQcAgICCUW\nzj7bT2rr+yn5/vvBbOhziN+LOQqVMO//Sfp1NRl5AH6xlFxrbkJuFe79A/T8MNcdCI2abfQE3G7P\nTlQCpiyC7B8w14mRF0PqCtkw1q83ayQywRWjlzCSHebhbexlPseo9zOgLA39PJ3gy8djLoSRl2Sb\nXT0oF23GwoWYr5Uxc8krQO+rccgQ3wuSZiQlAN/GLOg2Tz+0fO2TVVVG4Zp81wsKfE6c72DvObl4\nsXM5Ezj5mJDetjkgF0+e0agUvoCQITWlhKEcMaSFEEq2n0fpHvDftJzIYgZlPDNRFascXuFYO3Pa\nXWJgzJevqDAZNXZ/BvG2mcfP9Eo+Jjc+sWH3mmVjLKEb/j4uCqksu8I46d7PgLI09HPJSGdrnAvp\nxcuN3YnQ6/03wiKPu2bNyij5ymCqZVBUwvG9HKQKEkuX+gsXXIBkDgnIHgDqRQ1UvJ2TTwba2rCA\nDFwgP/GNb+DR+fMB+CqhR1/mFz3Pviwsfj5Be/TxAxW5IQiLfP/7wSwimAksWoQJJ50U6ggBYVl+\nOk9ecMQRuFK+s/5uSV3ynw1cD5gdTqmk+3Ou5+EVpXD8s8+GG3zve8BzzyE5diwSzz6bohj5oGb5\nXOx5uPvtt8MZSJ4DVCbI4H/Yjh2Ads6SO3eaz2Cae/pQUI8G23BFccmj1kucXgyxrScf9TmGaz3T\nK0eMMMMucfcBmAWCrm3sQSIdcgjhlKWhZ7gobFHIx8gzoWm255kxsZaWQKr1Pfha9gBwyZtvAjqW\nntQCVoB/UcWT+hCk/rd7N1brRNXq447DhELwq0XW9/zzgRwGtA8BLNSt78bqdRPa24HWVnd/3Obm\njKya7Nsi5AZX/DlZXY2EDiEtmDjR+A71V1yRsn2s4+Rg4AXy6D6S7TE1uyZx+ulZH/OuIhn4xKpV\nSGpdJsCv45BnLpca5w9AoRtbvExgx985YcseuxhJib/ztq7Qjr2NvFZWplIjxaiz1IKrTaC93s4l\ndXSYMwSbRhmlyZMuaRwTZW/or9Y30t3aiNlVeEBhvPhWez/8ww8ejKnHHAMA+OnGjQgEWfftw2Yy\n8AJW/AMv9+yJCfUuwmRhIB5utgk4maGsATBbvOSePU22y1FH+Z7wRRehVlMyoyAJw1PPPtsYAAuN\nhNZHeXTYsEBtMfDyly/Hdbqpxe1anjfwhIGs9NMTorC4ZEleyU1XnifhkJE+3vNwPFIRNJS3BMMu\nphzClXwPb9+OR7WDsgnp80k9AIgqzVb9eoznpcgWyOte6/mam4PTYhQT2gVObCR5vSthy4aeX6MU\nI+3iKiC1uxNXu8pxdu0K17vyBjxYpfPOo95LN0jY4Zq43r+cWlZbdwGkECbqa+Vj5LnI6jA74WbT\noXRSabhS2AsE3viRWsyqcsiQ4AHugdCL7wSCasqnq6pwFmt4Fxi/y5Nh0Qpgp97HYeeeG4aZjjwy\n2Kb9zDONQigXpAHKxaLHXiS4qqaTVVVI6IKy5AsvRM8ujjgCeCvNN3GxHLiJeRqwLIbkMdYDmKbD\nMUniwierqnzeOd9vL7+M28eODf6dnYURna8U5khtAjU9Saxbh6SWpPgKQomOWvqsJIWPoXXcwAYA\n8I1vAEBQYzFb1g+mLI5URmdAJyIMkK0eyRx5l2drc9cFvA+XkJjdycllpG1+v93z1d5GYEsJC6ee\nu2TJdvKdOS9g75urcg+0VoJJakxgoxBevBRZBXHdqLJ/wkfsFfqm6Qet0Q2z2QjgazUDQP3u3cCS\nJeEbOTRriMI8pXBSAfZz2OGHAwDaH388WLdo82YAwN+VStF02aivOYuxiZhBMb35dEhSxbCEbmYC\nQZgteJAkr3Dffen3p6V040KCGysAHK099qOvv96pExS3uAhA0PA9cfHF/ooHHgAQhmqujjkg8G8V\n6eXHrJzOiDSNZzphOXBsjFl3houWXCGYKH12VyUpFyxFJYDlHGQfdoco3rftZbsSrelyAn37+tel\nrc1sYMKDVO/eef8eZWno2WC7PPmCSxjY0yC7mo3wKZsxoalvM157De9rlsdzCGUAnkD4MP1vnz74\nODUHCaoj82gMLt+7EqYMQa6Yr4uh+LZiNowrdGYjk8ffFVgEoK8u6NoFICG6//C9YMAvtsq3biNx\n6KH+wj/+gQknnwycdhrw+98bfQVugq+ECfhFTSn38wknRLK4AiNPCLa97DK0wc0SepgE5r6K0Mm5\n1MUAOvHEoHm9OCnH9+iB2z0vJW8zT6lUdpxSSOiwj6tYzA77AAjDJaI0yRWonFBnQ+pq1MEVq+y5\nR4U6hKcuz7oYdtcsgUMzrmPbsw/7GLI+KhnrGlAETLc+EFg36Qx2sTRquILQkEDmUfTGG/3Xr3zF\nfxUuszT3HjkSh+qQwfTVq7HXKpcHgPsAQJqDrFoVrJcbXwRlE54X6LlMc3znJv3evbSuUMVb2foN\nv8i8SdmA9AuDBGuhpdSWve/32Jn62GP+DELE4wjK8zImzqM87STlRxLao2+FOXC5wDyjO0GUYepn\nfLtmU83+5CcDxtUeAImIc02XgJWQK+c0bKNvfEfbcEtcvLU1pEOuXRs6Ry5DC5j0R2bGSMilosLv\nUnfTTaHX3NHhv88SAwwumLINLDe3l+3SyW/zNvZshz/ncDIDcIVuTJSNoc/WwGf6TM7n8a9AfQMJ\nx/sP69jphfY5DR2KRq0TPwKZ9V6YvXB9mu0OdPQAUK9j1+t07Hq052G+UsagIxHrl/I4lvRBfQMh\nM+g9IIhpA0BCG4R0qqnpsA/AdFYJjUDUPR287yjSSixb5qy1OAPAC/ff7882IxhCdnGfLDdq4173\n0kuAXk7+5S/GZ6Nou1GmyGVU2Mj/xnVO7HVzHLuz0y9UErBGEIOrYAHfoIp339QU0i1FJfe990xj\nydo5tjGX9Sx1LMez5Q/s922uvqyXeL2sY/KHDdvoZyloBhSgw1QhMFgp78qI97Lx4iV+HCe8EAeD\n4WhfGNV5CQiTUP36BZ5SUj886SB7aotYl6ivR7KhIeZZxwNfq2wbphcCfDtHMTYCxofEsXv3Nn77\nQpx3X4QFY/Vvvonk8OHpNk+LTMa7IHAoej6qFM7LwLhK7N5tzFxr6b1L5Lw/rYUknnkGD+tt30DY\nyD6bnhFRSPzsZ1j2pS8B8Nk9cs/PZZniioqQBWPrurBhZWO6erW/PEoLYN9zTzj7ZhbNrl3hPmwG\nDxt6DgGJeubq1WFfZ/b6sxQYAxDG5QW2oXd59DbTp2dPqKqq4neYKibievH8BYRadpdSuYl9MMV8\nMAAACixJREFUEQZn3iQVHBNsjj/cuMIlBUqFOWFQ+uiGWlhVhVkiN5BFBWq2+KJ+PTKTV+t4P+F5\n+CfdAwfrmgeJS1cAqNNhDJv/LsVlyenTg3Wz9u7FKv3ZVVka+cQKXQ+aJdUtLziIAudFXMcTQEVr\nFRWB8zCnvT1jKT+Hegph4AXJL30paB9ocEdsSiPrunPDbTbu8owNHJgayvjsZ0PDPXCgL4kg+xPY\nRU+shsnvyTLvUzDQpifExJ49ZnhJBp/t22EoYroQVXOQBmXp0Wcbi0/nSSWVCgwLYCbb5FLOfucd\n51Q9Lw9NDOioUUhq1kq24Ol7vmX4gENF0fYeBg7EP3WMOU5jjbzOpcD3ndwfowBM0wlvaZYukGYn\nLMl2OcJcR2LbNoOSmA6GpHI54TvfCb1bAHiESrXSsMmi8DrJRz+GkGOfD46i5SAEumGDmxmzb19o\nTNl5Gjgw9LT79g2XJbTDjURGjAgN/dChJo/ebnIi+2amjzS4HzXKlFIAUrnzdktA2VaOM3CgKakg\nhp5bI/KgJwMTM46IZaQGDOhaj14p9VkAC+EzEu/xPO/WTJ/JJdmayWBUAjiS5HelVBugKf9Xv5rp\n1LKHGNH164Ec+e2FMO6CtNdJzvUf/8DBsv1ll2Gd9ohHK5WTvELKOWRBJcx63y7vH2ZDEklsT7vp\npiAUdi809RLA32MY+WDwFcNSbvjmN3EXfeer2TPNwdD/HmFVeqHmLZECFGIwm5tDD7e5OTR6+/aF\n6zmmz0VNLu58a6u57JIvqKgwjT4fx1bQ5HPlY7LQWs+eJl1SDDYbd9aV54YkLS3hoOcaIDo7zXxB\nDBTF0CulPgLghwBOB9AE4C9KqSc9z9vg2n7w2LFIcCtBjVy9eIYd/5XPPa33fZa8X6QOUwAgZTaF\nEJaKC4mrXirhhRwwWgxzaysqtBFk3Z8ItY9o5GBo8kWdLmgz8K1vAZTz+NiaNcFyQntvt195ZfD9\navXrJW++6RueI44oaA1EoRGXTx8HMzzPyAtw7D5X9HetZOPGoQtu98edophrDqSGUGyqIjcPZ29d\nEr0jR4ZG1465y75cxrWmJhz0uQk5V/d2dpozCg71CXXUVu5kZU45Nieoy6Qy9kQAWzzPewsAlFKP\nAJgKwGnobeTrxcfBWREKgp9wrs0DlZUYq8937KuvBtWJxUQP+KNrXr1KuYiod2+jPR8APxlNnrEL\nvQFcV0QvPhYGO7ItlZUwhH5Jz12WZ3d2InnNNQCAS7TUQs7x2P0d4oRNmIALv/Y1AECS5KENKYMY\ncObPOMnKXPOoBhusGRMlPcDGnnvJkoZV4F3bMgmuitS+fcPwEdM4mWfvahTOGvQ8E2hpMT19Vwgo\nSjytTBqPDAHwv/R/E4Dx+e60oHFdi8YkqZyi+pz9+hnl8YVG0Iy6mDK4zDa6+WacrA39qcQM+gZv\n3wVefBxklAr+7/9G4r+z6UR8AOMkXXPd2RkUfvX/wQ9C5UkAn9KvyxEyxuaQ7IIgcfjhbjlulgCO\nagLC0sT79pkxbXtgsL1rQU2NOSvgY7r48nxMOZZ93hzzZ+9fHAM+V9ugSwMTHhh4dsNw6e/ERFGS\nsUqp8wCc6XneV/X/FwM40fO8r9E2VwBB7+JRMHNk5QRWNygndJ9Xdug+r+xRrufWfV4hhnmel7EJ\nQLE8+iYAH6f/h8JXNQ3ged5PAL93sVLqxTiZ465AuZ5b93llh+7zyh7lem7d55U9IhvW54m/ADhS\nKXW4UqoSvojfk0U6Vje60Y1udCMNiuLRe57XqZSaCeBZ+PTK+zzPey3Dx7rRjW50oxtFQNF49J7n\n/RrAr2Nu/pNinUcBUK7n1n1e2aH7vLJHuZ5b93llibKojO1GN7rRjW4UD8WK0XejG93oRjfKBF1u\n6JVSn1VKva6U2qKUurELz+PjSqnfKaU2KqVeU0rN0uu/rZTappRaq/8+1wXntlUp9Vd9/Bf1uo8q\npZ5XSm3Wr4eW+JyOpmuyVim1Ryl1bVddL6XUfUqp95RS62md8xopH3fqe+5VpdQJ0XsuynnNV0pt\n0sd+XCnVV6+vVUr9k67dj6P3XJTzivztlFJz9fV6XSl1pnuvRTuvpXROW5VSa/X6Ul6vKPvQ5fdY\nLHie12V/8BO1b8Lv/1AJYB2AY7voXAYBOEEvHwK/yvtYAN8GcH0XX6etAPpZ674L4Ea9fCOA27r4\nd2wGMKyrrheAk+ELNq7PdI0AfA7A0wAUgJMArCnxeZ0BoEIv30bnVcvbdcH1cv52+jlYB6AKwOH6\nmf1Iqc7Lev92ADd1wfWKsg9dfo/F+etqjz6QSvA8rwOASCWUHJ7nvet53st6+QMAG+FX+JYrpgL4\nqV7+KfxOeF2FSQDe9Dzvna46Ac/zfg/gH9bqqGs0FcADno8/AeirlBpUqvPyPO85z/Ok3PJP8OtM\nSoqI6xWFqQAe8Tyv3fO8twFsQdjzvmTnpZRSAM4HkF0T3wIgjX3o8nssDrra0LukErrcuCqlagEc\nD0DUrmbq6dd9pQ6RaHgAnlNKvaT8imIAGOB53ruAfxMiQiuqRLgA5sPX1ddLEHWNyum+uwy+5yc4\nXCn1ilJqlVLqv7rgfFy/Xblcr/8CsMPzPNb9Lvn1suzD/nCPdbmhd6mXdSkNSClVA+BXAK71PG8P\ngLsADAcwBsC78KeOpcZ/ep53AoCzAFyjlMq9m3iBofyCuLMBPKpXlcP1yoSyuO+UUnXwZY9+ple9\nC+ATnucdD+DrAH6ulCqlWFDUb1cW1wvAhTAdipJfL4d9iNzUsa7LbFtXG/qMUgmlhFLqIPg/4s88\nz3sMADzP2+F53r89z/sQwGIUacqaDp7nbdev7wF4XJ/DDpkK6td8m2rlirMAvOx53g59jl1+vQhR\n16jL7zul1CXwFay/5Omgrg6N/F0vvwQ/Fn5U9F4KizS/XTlcrwoAnwewVNaV+nq57APK+B5jdLWh\nLxupBB3/uxfARs/z7qD1HFc7FyUWX1NKVSulDpFl+Im89fCv0yV6s0sALCvleREML6urr5eFqGv0\nJIAva2bESQB2y/S7FFB+U54bAJzteV4brT9M+b0coJQ6AsCRAN4q4XlF/XZPArhAKVWllDpcn9ef\nS3VeGqcB2OR5XpOsKOX1irIPKNN7LAVdmQn2wuz0G/BH47ouPI8J8KdWrwJYq/8+B+BBAH/V658E\nMKjE53UEfMbDOgCvyTUC8DEAKwBs1q8f7YJr1gvA3wH0oXVdcr3gDzbvAvgXfG/q8qhrBH9a/UN9\nz/0VwLgSn9cW+PFbuc9+rLedpn/jdfDbvU4p8XlF/nYA6vT1eh3AWaU8L71+CYCrrG1Leb2i7EOX\n32Nx/rorY7vRjW504wBHV4duutGNbnSjG0VGt6HvRje60Y0DHN2Gvhvd6EY3DnB0G/pudKMb3TjA\n0W3ou9GNbnTjAEe3oe9GN7rRjQMc3Ya+G93oRjcOcHQb+m50oxvdOMDx/wEuaTs8h8feewAAAABJ\nRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -998,32 +1014,25 @@ "\n", "You'll notice that these may not be pixel-perfect copies. This is because the number of pixels doesn't evenly divide into the number of residues. You can improve this by increasing the resolution (`dpi` in matplotlib) or the figure size. However, in both versions you can see the overall structure quite clearly. In addition, the color bar is only shown in the built-in version." ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 2", + "display_name": "Python 3", "language": "python", - "name": "python2" + "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.14" + "pygments_lexer": "ipython3", + "version": "3.6.7" } }, "nbformat": 4, diff --git a/examples/contact_map_without_atom_slice.ipynb b/examples/contact_map_without_atom_slice.ipynb new file mode 100644 index 0000000..98de8a0 --- /dev/null +++ b/examples/contact_map_without_atom_slice.ipynb @@ -0,0 +1,304 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Contact Maps without atom slice\n", + "The contact map classes use an equivalent to `mdtraj.atom_slice()` to cut down the trajectory or frame to only contain atoms that are part of either the query or haystack. It does not use this optimization if there are no atoms to be slices. \n", + "This is more performant for most real world cases, as we tested it for a protein system without water (only hydrogens are sliced) and a system of only tip4p water (hydrogens and dummy atoms are sliced away). \n", + "It does involve some overhead mainly consisting of the mapping of sliced indices back to the real indices after the contactmap or frequency has been calculated. This overhead could be significant in the case where the resulting contactmap/frequency is dense (resulting in a lot of keys to be mapped) and very little is sliced away (triggering the optimization).\n", + "\n", + "This notebook will show such a worst case scenario and how to disable this optimization.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The worst case example\n", + "This is only adding a noticeable overhead for `ContactMap` in this case, but this could be worse for other systems" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import mdtraj as md\n", + "traj = md.load(\"5550217/kras.xtc\", top=\"5550217/kras.pdb\")\n", + "topology = traj.topology" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from contact_map import ContactMap, ContactFrequency, ContactDifference" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Select all atoms\n", + "atoms = range(topology.n_atoms)\n", + "\n", + "# Slice away a single atom so the optimization is triggered\n", + "used_atoms = atoms [1:]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 824 ms, sys: 48 ms, total: 872 ms\n", + "Wall time: 291 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "frame_contacts = ContactMap(traj[0], query=used_atoms, haystack=used_atoms)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 1min 12s, sys: 3.28 s, total: 1min 16s\n", + "Wall time: 20.6 s\n" + ] + } + ], + "source": [ + "%%time\n", + "trajectory_contacts = ContactFrequency(traj, query=used_atoms, \n", + " haystack=used_atoms)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Check if the optimization was triggered\n", + "trajectory_contacts.use_atom_slice" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Disabling `use_atom_slice`\n", + "\n", + "The default for `use_atom_slice` is take from the class variables, to disable `use_atom_slice` set `class._class_use_atom_slice = False`" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "ContactMap._class_use_atom_slice = False\n", + "ContactFrequency._class_use_atom_slice = False\n", + "ContactDifference._class_use_atom_slice = False" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 668 ms, sys: 20 ms, total: 688 ms\n", + "Wall time: 204 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "frame_contacts = ContactMap(traj[0], query=used_atoms, haystack=used_atoms)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 1min 12s, sys: 3.42 s, total: 1min 15s\n", + "Wall time: 21.1 s\n" + ] + } + ], + "source": [ + "%%time\n", + "trajectory_contacts = ContactFrequency(traj, query=used_atoms, \n", + " haystack=used_atoms)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "trajectory_contacts.use_atom_slice" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Speedup on a real use case\n", + "\n", + "So the example where both the query and haystack are defined, would be an example of a real world case. Lets see what the slowdown would be if we did not use `atoms_slice` " + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "switch1 = topology.select(\"resSeq 32 to 38 and symbol != 'H'\")\n", + "cations = topology.select(\"resname NA or resname MG\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "# Set class_atom_slice to True\n", + "ContactMap._class_use_atom_slice = True\n", + "ContactFrequency._class_use_atom_slice = True\n", + "ContactDifference._class_use_atom_slice = True" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 536 ms, sys: 32 ms, total: 568 ms\n", + "Wall time: 167 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "cations_switch1 = ContactFrequency(trajectory=traj, query=cations, haystack=switch1)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "# Set class_atom_slice to False\n", + "ContactMap._class_use_atom_slice = False\n", + "ContactFrequency._class_use_atom_slice = False\n", + "ContactDifference._class_use_atom_slice = False" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 7.35 s, sys: 316 ms, total: 7.66 s\n", + "Wall time: 1.99 s\n" + ] + } + ], + "source": [ + "%%time\n", + "cations_switch1 = ContactFrequency(trajectory=traj, query=cations, haystack=switch1)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.15" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/examples/data/gsk3b_example.h5 b/examples/data/gsk3b_example.h5 new file mode 100644 index 0000000..00742de Binary files /dev/null and b/examples/data/gsk3b_example.h5 differ diff --git a/readthedocs.yml b/readthedocs.yml index 5e89905..dfbea26 100644 --- a/readthedocs.yml +++ b/readthedocs.yml @@ -1,5 +1,16 @@ +version: 2 + conda: - file: docs/environment.yml + environment: docs/environment.yml python: - setup_py_install: true + install: + #- requirements: docs/rtd_requirements.txt + #- requirements: requirements.txt + #- requirements: docs/requirements.txt + - method: setuptools + path: . + #- method: pip + #path: . + #system_packages: false + diff --git a/setup.py b/setup.py index e76d3ec..8ef8d25 100644 --- a/setup.py +++ b/setup.py @@ -9,7 +9,7 @@ ####################### USER SETUP AREA ################################# # * VERSION: base version (do not include .dev0, etc -- that's automatic) # * IS_RELEASE: whether this is a release -VERSION = "0.3.3" +VERSION = "0.4.0" IS_RELEASE = True DEV_NUM = 0 # always 0: we don't do public (pypi) .dev releases