diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py
index 6e89d7bb8..92f6304ec 100644
--- a/brainiak/reconstruct/iem.py
+++ b/brainiak/reconstruct/iem.py
@@ -11,6 +11,10 @@
 #  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
+#
+# Copyright 2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
 """Inverted Encoding Model (IEM)
 
     Method to decode and reconstruct features from data.
@@ -36,6 +40,9 @@
     written to give some flexibility compared to the specific instances
     in Kok, 2013 & in Brouwer, 2009. Users can set the number of basis
     functions, or channels, and the range of possible feature values.
+
+    There are separate classes for reconstructing feature values in a
+    1-dimensional (1D) space or in a 2-dimensional (2D) space.
 """
 
 # Authors: David Huberdeau (Yale University) &
@@ -47,30 +54,28 @@
 import numpy as np
 import scipy.stats
 from sklearn.base import BaseEstimator
+from sklearn.metrics.pairwise import cosine_distances, euclidean_distances
 from ..utils.utils import circ_dist
 
-__all__ = [
-    "InvertedEncoding",
-]
+__all__ = ["InvertedEncoding1D",
+           "InvertedEncoding2D"]
 
 logger = logging.getLogger(__name__)
 MAX_CONDITION_CHECK = 9000
 
 
-class InvertedEncoding(BaseEstimator):
+class InvertedEncoding1D(BaseEstimator):
     """Basis function-based reconstruction method
 
-    Inverted encoding models (alternatively known as forward
-    models) are used to reconstruct a feature, e.g. color of
-    a stimulus, from patterns across voxels in functional
-    data. The model uses n_channels number of idealized
-    basis functions and assumes that the transformation from
-    stimulus feature (e.g. color) to basis function is one-
-    to-one and invertible. The response of a voxel is
-    expressed as the weighted sum of basis functions.
-    In this implementation, basis functions were half-wave
-    rectified sinusoid functions raised to a power set by
-    the user (e.g. 6).
+    Inverted encoding models (alternatively known as forward models) are used
+    to reconstruct a feature represented in some N-dimensional space, here 1D,
+    (e.g. color of a stimulus) from patterns across voxels in functional data.
+    The model uses n_channels number of idealized basis functions and assumes
+    that the transformation from stimulus feature (e.g. color) to basis
+    function is one- to-one and invertible. The response of a voxel is
+    expressed as the weighted sum of basis functions. In this implementation,
+    basis functions were half-wave rectified sinusoid functions raised to a
+    power set by the user (e.g. 6).
 
     The model:
     Inverted encoding models reconstruct a stimulus feature from
@@ -97,7 +102,7 @@ class InvertedEncoding(BaseEstimator):
 
     (3)     C_est = inv(W_est)*B_exp
 
-    Given estimated channel responses, C_est, it is straighforward
+    Given estimated channel responses, C_est, it is straightforward
     to obtain the reconstructed feature value by summing over
     channels multiplied by their channel responses and taking the
     argmax (i.e. the feature associated with the maximum value).
@@ -159,18 +164,20 @@ class InvertedEncoding(BaseEstimator):
     W_: sklearn.linear_model model containing weight matrix that
         relates estimated channel responses to response amplitude
         data
+
+    See get_params() for the rest of the attributes.
     """
+
     def __init__(self, n_channels=6, channel_exp=5,
-                 stimulus_mode='halfcircular', range_start=0.,
-                 range_stop=180., channel_density=180,
-                 stimulus_resolution=None):
+                 stimulus_mode='halfcircular', range_start=0., range_stop=180.,
+                 channel_density=180, stimulus_resolution=None):
         self.n_channels = n_channels
         self.channel_exp = channel_exp
         self.stimulus_mode = stimulus_mode
         self.range_start = range_start
         self.range_stop = range_stop
         self.channel_density = channel_density
-        self.channel_domain = np.linspace(range_start, range_stop-1,
+        self.channel_domain = np.linspace(range_start, range_stop - 1,
                                           channel_density)
         if stimulus_resolution is None:
             self.stim_res = channel_density
@@ -187,18 +194,17 @@ def _check_params(self):
             if (self.range_stop - self.range_start) != 180.:
                 raise ValueError("For half-circular feature spaces,"
                                  "the range must be 180 degrees, "
-                                 "not {}".format(self.range_stop
-                                                 - self.range_start))
+                                 "not {}".
+                                 format(self.range_stop - self.range_start))
         elif self.stimulus_mode == 'circular':
             if (self.range_stop - self.range_start) != 360.:
                 raise ValueError("For circular feature spaces, the"
                                  " range must be 360 degrees"
-                                 "not {}".format(self.range_stop
-                                                 - self.range_start))
+                                 "not {}".
+                                 format(self.range_stop - self.range_start))
         if self.n_channels < 2:
             raise ValueError("Insufficient number of channels.")
-        if not np.isin(self.stimulus_mode, ['circular',
-                                            'halfcircular']):
+        if not np.isin(self.stimulus_mode, ['circular', 'halfcircular']):
             raise ValueError("Stimulus mode must be one of these: "
                              "'circular', 'halfcircular'")
 
@@ -230,13 +236,12 @@ def fit(self, X, y):
                              "dimensions.")
         else:
             if shape_data[0] != shape_labels[0]:
-                raise ValueError(
-                    "Mismatched data samples and label samples")
+                raise ValueError("Mismatched data samples and label samples")
 
         # Define the channels (or basis set)
         self.channels_, channel_centers = self._define_channels()
-        logger.info("Defined channels centered at {} degrees."
-                    .format(np.rad2deg(channel_centers)))
+        logger.info("Defined channels centered at {} degrees.".format(
+            np.rad2deg(channel_centers)))
         # Create a matrix of channel activations for every observation.
         # (i.e., C1 in Brouwer & Heeger 2009.)
         C = self._define_trial_activations(y)
@@ -292,11 +297,12 @@ def score(self, X, y):
             pred_features = pred_features * 2
             y = y * 2
 
-        ssres = (circ_dist(np.deg2rad(y), np.deg2rad(pred_features))**2).sum()
+        ssres = (circ_dist(np.deg2rad(y),
+                           np.deg2rad(pred_features)) ** 2).sum()
         sstot = (circ_dist(np.deg2rad(y),
-                           np.ones(y.size)*scipy.stats.circmean(np.deg2rad(y))
-                           ) ** 2).sum()
-        score_value = (1 - ssres/sstot)
+                           np.ones(y.size) * scipy.stats.circmean(
+                               np.deg2rad(y))) ** 2).sum()
+        score_value = (1 - ssres / sstot)
 
         return score_value
 
@@ -307,13 +313,11 @@ def get_params(self):
         -------
         params: parameter of this object
         """
-        return{"n_channels": self.n_channels,
-               "channel_exp": self.channel_exp,
-               "stimulus_mode": self.stimulus_mode,
-               "range_start": self.range_start,
-               "range_stop": self.range_stop,
-               "channel_domain": self.channel_domain,
-               "stim_res": self.stim_res}
+        return {"n_channels": self.n_channels, "channel_exp": self.channel_exp,
+                "stimulus_mode": self.stimulus_mode,
+                "range_start": self.range_start, "range_stop": self.range_stop,
+                "channel_domain": self.channel_domain,
+                "stim_res": self.stim_res}
 
     def set_params(self, **parameters):
         """Sets model parameters after initialization.
@@ -353,9 +357,9 @@ def _define_channels(self):
             centers = channel_centers
 
         # define exponentiated function
-        channels = np.asarray([np.cos(np.deg2rad(domain) - cx) **
-                               self.channel_exp
-                               for cx in centers])
+        channels = np.asarray(
+            [np.cos(np.deg2rad(domain) - cx) ** self.channel_exp for cx in
+             centers])
         # half-wave rectification preserving circularity
         channels = abs(channels)
 
@@ -368,14 +372,14 @@ def _define_trial_activations(self, stimuli):
         Parameters
 
             stimuli: numpy array of the feature values for each
-                observation (e.g., [0, 5, 15, 30, ...] degrees)
+                observation
 
         Returns
         -------
             C: matrix of predicted channel responses. dimensions are
                 number of observations by stimulus resolution
         """
-        stim_axis = np.linspace(self.range_start, self.range_stop-1,
+        stim_axis = np.linspace(self.range_start, self.range_stop - 1,
                                 self.stim_res)
         if self.range_start > 0:
             stimuli = stimuli + self.range_start
@@ -386,8 +390,8 @@ def _define_trial_activations(self, stimuli):
         stimulus_mask = one_hot[indices, :]
         if self.channel_density != self.stim_res:
             if self.channel_density % self.stim_res == 0:
-                stimulus_mask = np.repeat(stimulus_mask, self.channel_density /
-                                          self.stim_res)
+                stimulus_mask = np.repeat(stimulus_mask,
+                                          self.channel_density / self.stim_res)
             else:
                 raise NotImplementedError("This code doesn't currently support"
                                           " stimuli which are not square "
@@ -400,8 +404,8 @@ def _define_trial_activations(self, stimuli):
         # Check that C is full rank
         if np.linalg.matrix_rank(C) < self.n_channels:
             warnings.warn("Stimulus matrix is {}, not full rank. May cause "
-                          "issues with stimulus prediction/reconstruction."
-                          .format(np.linalg.matrix_rank(C)), RuntimeWarning)
+                          "issues with stimulus prediction/reconstruction.".
+                          format(np.linalg.matrix_rank(C)), RuntimeWarning)
         return C
 
     def _predict_channel_responses(self, X):
@@ -416,8 +420,7 @@ def _predict_channel_responses(self, X):
         -------
             channel_response: numpy matrix of channel responses
         """
-        channel_response = np.matmul(np.linalg.pinv(self.W_),
-                                     X.transpose())
+        channel_response = np.matmul(np.linalg.pinv(self.W_), X.transpose())
         return channel_response
 
     def _predict_feature_responses(self, X):
@@ -456,3 +459,591 @@ def _predict_features(self, X):
         pred_features = self.channel_domain[feature_ind]
 
         return pred_features
+
+
+class InvertedEncoding2D(BaseEstimator):
+    """Basis function-based reconstruction method
+
+    Inverted encoding models (alternatively known as forward models) are used
+    to reconstruct a feature represented in a N-dimensional space, here 2D,
+    (e.g. position on a projector screen) from patterns across voxels in
+    functional data. The model uses some number of idealized basis functions
+    that cover the 2D space, and assumes that the transformation from
+    stimulus feature (e.g. 2D spatial position) to basis function is one-
+    to-one and invertible. The response of a voxel is expressed as the
+    weighted sum of basis functions. In this implementation, basis functions
+    were half-wave rectified sinusoid functions raised to some power (set by
+    the user).
+
+    The documentation will refer to the 'stimulus space' or 'stimulus domain',
+    which should be a 2D space in consistent units (e.g. screen pixels,
+    or degrees visual angle). The stimulus space is the domain in which the
+    stimulus is reconstructed. We will refer to the each point in this 2D
+    stimulus domain as a 'pixel'.
+
+    The model:
+    Inverted encoding models reconstruct a stimulus feature from
+    patterns of BOLD activity by relating the activity in each
+    voxel, B, to the values of hypothetical channels (or basis
+    functions), C, according to Equation 1 below.
+
+    (1)     B = W*C
+
+    where W is a weight matrix that represents the relationship
+    between BOLD activity and Channels. W must be estimated from
+    training data; this implementation (and most described in the
+    literature) uses linear regression to estimate W as in Equation
+    2 below [note: inv() represents matrix inverse or
+    pseudo-inverse].
+
+    (2)     W_est = B_train*inv(C_train)
+
+    The weights in W_est (short for "estimated") represent the
+    contributions of each channel to the response of each voxel.
+    Estimated channel responses can be computed given W_est and
+    new voxel activity represented in matrix B_exp (short for
+    "experiment") through inversion of Equation 1:
+
+    (3)     C_est = inv(W_est)*B_exp
+
+    Given estimated channel responses, C_est, it is straightforward
+    to obtain the reconstructed feature value by summing over
+    channels multiplied by their channel responses and taking the
+    argmax (i.e. the feature associated with the maximum value).
+
+    Using this model:
+    Use fit() to estimate the weights of the basis functions given
+    input data (e.g. beta values from fMRI data). This function
+    will execute equation 2 above.
+
+    Use predict() to compute predicted stimulus values
+    from new functional data. This function computes estimated
+    channel responses, as in equation 3, then computes summed
+    channel output and finds the argmax (within the stimulus
+    feature space) associated with those responses.
+
+    Use score() to compute a measure of the error of the prediction
+    based on known stimuli.
+
+    Parameters
+    ----------
+    stim_xlim: list of 2 floats Specifies the minimum and maximum x-values
+        of the area to be reconstructed. In order to be estimated properly, a
+        stimulus must appear at these limits. Specifying limits outside the
+        range of the stimuli can lead to spurious estimates.
+
+    stim_ylim: list of 2 floats Specifies the minimum and maximum y-values
+        of the area to be reconstructed. In order to be estimated properly, a
+        stimulus must appear at these limits. Specifying limits outside the
+        range of the stimuli can lead to spurious estimates.
+
+    stimulus_resolution: float or list of 2 floats. If a single float is
+        given, it will be expanded to a list (i.e. we will assume that the
+        reconstructed area is composed of square pixels).
+
+    stim_radius: float, or sequence of floats [n_stim], default None. If the
+        user does not define the design matrix of the encoding model (e.g. C
+        in B = W*C), it will be defined automatically on the assumption that
+        each observation was for a 2D circular stimulus of some radius.
+
+    chan_xlim: list of 2 floats, default None. Specifies the minimum and
+        maximum x-values of the channels, or basis functions.
+
+    chan_ylim: list of 2 floats, default None. Specifies the minimum and
+        maximum y-values of the channels, or basis functions.
+
+    channels: [n_channels, n_pixels] NumPy 2D array, default None. If None at
+        initialization, it can be defined with
+        either define_basis_functions_sqgrid() or
+        define_basis_functions_trigrid(), each of which tiles the given 2D
+        space with some grid (square or triangular/hexagonal, respectively).
+        Alternatively, the user can specify their own channels.
+
+    channel_exp: int, default 7. Basis function exponent. The exponent of the
+        sinuoidal basis functions, which helps control their width.
+
+    Attributes
+    ----------
+    channels: [n_channels, n_pixels] NumPy 2D array defining channels
+
+    W_: sklearn.linear_model containing weight matrix that relates estimated
+        channel responses to response data
+
+    See get_params() for the rest of the attributes.
+    """
+
+    def __init__(self, stim_xlim, stim_ylim, stimulus_resolution,
+                 stim_radius=None, chan_xlim=None, chan_ylim=None,
+                 channels=None, channel_exp=7):
+        """Defines a 2D inverted encoding model object.
+
+        While the parameters defining the domain in which to reconstruct
+        the stimuli are required (e.g. all `stim_*` inputs), the parameters
+        to define the channels (`chan*`) are optional, in case the user
+        wishes to define their own channels (a.k.a basis functions).
+
+
+        Parameters
+        ----------
+        stim_xlim: sequence of 2 float values, specifying the lower & upper
+            limits on the horizontal axis, respectively.
+        stim_ylim: sequence of 2 float values, specifying the lower & upper
+            limits on the vertical axis, respectively.
+        stimulus_resolution: a float or sequence of 2 floats, specifying the
+            number of pixels that exist in the x- and y- directions.
+        stim_radius: float, default None. The radius in pixels, assuming that
+            the stimulus is circular. If None, the user must either define it
+            before running fit(), or pass in a custom C in B = W*C.
+        chan_xlim: sequence of 2 float values, default None. Specifies the
+            lower & upper limits of the channels in the horizontal axis. If
+            None, the user must define this before using the class functions
+            to create basis functions, or pass in custom-defined channels.
+        chan_ylim: sequence of 2 float values, default None. Specifies the
+            lower & upper limits of the channels in the vertical axis. If
+            None, the user must define this before using the class functions
+            to create basis functions, or pass in custom-defined channels.
+        channel_exp: float or int, default None. The exponent for a
+            sinusoidal basis function. If None, it must be set before the
+            channels or defined, or pass in custom-defined channels.
+
+        """
+        # Automatically expand stimulus_resolution if only one value is given.
+        # This will create a square field  of view (FOV) for the
+        # reconstruction.
+        if not isinstance(stimulus_resolution, list):  # make FOV square
+            stimulus_resolution = [stimulus_resolution, stimulus_resolution]
+        if (len(stim_xlim) != 2) or (len(stim_ylim) != 2):
+            raise ValueError("Stimulus limits should be a sequence, 2 values")
+        self.stim_fov = [stim_xlim, stim_ylim]
+        self.stim_pixels = [np.linspace(stim_xlim[0], stim_xlim[1],
+                                        stimulus_resolution[0]),
+                            np.linspace(stim_ylim[0], stim_ylim[1],
+                                        stimulus_resolution[1])]
+        self.xp, self.yp = np.meshgrid(self.stim_pixels[0],
+                                       self.stim_pixels[1])
+        self.stim_radius_px = stim_radius
+        self.channels = channels
+        if self.channels is None:
+            self.n_channels = None
+        else:
+            self.n_channels = self.channels.shape[0]
+        if chan_xlim is None:
+            chan_xlim = stim_xlim
+            logger.info("Set channel x-limits to stimulus x-limits", stim_xlim)
+        if chan_ylim is None:
+            chan_ylim = stim_ylim
+            logger.info("Set channel y-limits to stimulus y-limits", stim_ylim)
+        self.channel_limits = [chan_xlim, chan_ylim]
+        self.channel_exp = channel_exp
+        self._check_params()
+
+    def _check_params(self):
+        if len(self.stim_fov) != 2:
+            raise ValueError("Stim FOV needs to have an x-list and a y-list")
+        elif len(self.stim_fov[0]) != 2 or len(self.stim_fov[1]) != 2:
+            raise ValueError("Stimulus limits should be a sequence, 2 values")
+        else:
+            if (self.stim_fov[0][0] >= self.stim_fov[0][1]) or \
+                    (self.stim_fov[1][0] >= self.stim_fov[1][1]):
+                raise ValueError("Stimulus x or y limits should be ascending "
+                                 "values")
+        if self.xp.size != self.yp.size:
+            raise ValueError("xpixel grid and ypixel grid do not have same "
+                             "number of elements")
+        if self.n_channels and np.all(self.channels):
+            if self.n_channels != self.channels.shape[0]:
+                raise ValueError("Number of channels {} does not match the "
+                                 "defined channels: {}".
+                                 format(self.n_channels,
+                                        self.channels.shape[0]))
+            if self.channels.shape[1] != self.xp.size:
+                raise ValueError("Defined {} channels over {} pixels, but "
+                                 "stimuli are represented over {} pixels. "
+                                 "Pixels should match.".
+                                 format(self.n_channels,
+                                        self.channels.shape[1],
+                                        self.xp.size))
+
+    def fit(self, X, y, C=None):
+        """Use data and feature variable labels to fit an IEM
+
+        Parameters
+        ----------
+        X: numpy matrix of voxel activation data. [observations, voxels]
+            Should contain the beta values for each observation or
+            trial and each voxel of training data.
+        y: numpy array of response variable. [observations]
+            Should contain the feature for each observation in X.
+        C: numpy matrix of channel activations for every observation (e.g.
+            the design matrix C in the linear equation B = W*C), matrix size
+            [observations, pixels]. If None (default), this assumes that each
+            observation contains a 2D circular stimulus and will define the
+            activations with self._define_trial_activations(y).
+        """
+        # Check that data matrix is well conditioned:
+        if np.linalg.cond(X) > MAX_CONDITION_CHECK:
+            logger.error("Data is singular.")
+            raise ValueError("Data matrix is nearly singular.")
+        if self.channels is None:
+            raise ValueError("Must define channels (set of basis functions).")
+        if X.shape[0] < self.n_channels:
+            logger.error("Not enough observations. Cannot calculate "
+                         "pseudoinverse.")
+            raise ValueError("Fewer observations (trials) than "
+                             "channels. Cannot compute pseudoinverse.")
+        # Check that the data matrix is the right size
+        shape_data = np.shape(X)
+        shape_labels = np.shape(y)
+        if shape_data[0] != shape_labels[0]:
+            raise ValueError("Mismatched data samples and label samples")
+        if C is None:
+            # Create a matrix of channel activations for every observation.
+            # (i.e., C1 in Brouwer & Heeger 2009.)
+            C = self._define_trial_activations(y)
+        # Solve for W in B = WC
+        self.W_ = X.transpose() @ np.linalg.pinv(C.transpose())
+        if np.linalg.cond(self.W_) > MAX_CONDITION_CHECK:
+            logger.error("Weight matrix is nearly singular.")
+            raise ValueError("Weight matrix is nearly singular.")
+
+        return self
+
+    def predict(self, X):
+        """Use test data to predict the feature
+
+        Parameters
+        ----------
+        X: numpy matrix of voxel activation from test trials [observations,
+            voxels]. Used to predict feature associated with the given
+            observation.
+
+        Returns
+        -------
+        model_prediction: numpy array of estimated feature values.
+        """
+        # Check that the data matrix is the right size
+        shape_data = np.shape(X)
+        if len(shape_data) != 2:
+            raise ValueError("Data matrix has too many or too few "
+                             "dimensions.")
+
+        model_prediction = self._predict_features(X)
+
+        return model_prediction
+
+    def score(self, X, y):
+        """Calculate error measure of prediction, assuming that the predicted
+        feature is at the maximum of the reconstructed values.
+
+        To score the reconstructions against expected features defined in the
+        stimulus domain (i.e. in pixels), see score_against_reconstructed().
+
+        Parameters
+        ----------
+        X: numpy matrix of voxel activation from new data
+            [observations,voxels]
+        y: numpy array of stimulus features. [observations, 2]
+
+        Returns
+        -------
+        score_value: the error measurement between the actual
+            feature and predicted features, [observations].
+        """
+        pred_features = self.predict(X)
+        ssres = np.sum((pred_features - y) ** 2, axis=1)
+        sstot = np.sum((y - np.mean(y)) ** 2, axis=1)
+        score_value = 1 - (ssres / sstot)
+
+        return score_value
+
+    def score_against_reconstructed(self, X, y, metric="euclidean"):
+        """Calculates a distance metric between reconstructed features in
+        the 2D stimulus domain (i.e. reconstructions in pixels) given
+        some observations X, and expected features y. Expected features must
+        also be in the pixel stimulus domain.
+
+        To score the reconstructions against the expected maxima, see score().
+
+        Parameters
+        ----------
+        X: numpy matrix of voxel activation from new data
+            [observations, voxels]
+        y: numpy array of the expected stimulus reconstruction values [pixels,
+            observations].
+        metric: string specifying the distance metric, either "euclidean" or
+            "cosine".
+
+        Returns
+        -------
+        score_value: the error measurement between the reconstructed feature
+            values as the expected values, [observations].
+        """
+        yhat = self.predict_feature_responses(X)
+        if metric == "euclidean":
+            score_value = euclidean_distances(y.T, yhat.T)
+        elif metric == "cosine":
+            score_value = cosine_distances(y.T, yhat.T)
+        return score_value[0, :]
+
+    def get_params(self):
+        """Returns model parameters.
+
+        Returns
+        -------
+        params: parameter of this object
+        """
+        return {"n_channels": self.n_channels, "channel_exp": self.channel_exp,
+                "stim_fov": self.stim_fov, "stim_pixels": self.stim_pixels,
+                "stim_radius_px": self.stim_radius_px, "xp": self.xp,
+                "yp": self.yp, "channels": self.channels, "channel_limits":
+                    self.channel_limits}
+
+    def set_params(self, **parameters):
+        """Sets model parameters after initialization.
+
+        Parameters
+        ----------
+            parameters: structure with parameters and change values
+        """
+        for parameter, value in parameters.items():
+            setattr(self, parameter, value)
+        self._check_params()
+        return self
+
+    def _make_2d_cosine(self, x, y, x_center, y_center, s):
+        """Defines a 2D exponentiated cosine (isometric, e.g. constant width
+        in x & y) for use as a basis function. Function goes to zero at the
+        given size constant s. That is, the function is given by if r <= s:
+        f(r) = (0.5 + 0.5*cos(r*pi/s)))**channel_exp else:       0 where r is
+        the Euclidean distance from the center of the function. This will
+        yield a Gaussian-like function, centered at (x_center, y_center).
+
+        Parameters
+        ----------
+        x: x-coordinates of the stimulus space, [npixels, 1] matrix
+        y: y-coordinates of the stimulus space, [npixels, 1] matrix
+        x_center: x-coordinate of basis function centers (sequence, nchannels)
+        y_center: y-coordinate of basis function centers (sequence, nchannels)
+        s: size constant of the 2D cosine function. This is the radius where
+            the function is non-zero.
+
+        Returns
+        -------
+        cos_functions: basis functions defined in the 2D stimulus space.
+            returns a [nchannels, npixels] matrix.
+        """
+        cos_functions = np.zeros((len(x_center), len(x)))
+        for i in range(len(x_center)):
+            myr = np.sqrt((x - x_center[i]) ** 2 + (y - y_center[i]) ** 2). \
+                squeeze()
+            qq = (myr <= s) * 1
+            zp = ((0.5 * (1 + np.cos(myr * np.pi / s))) ** self.channel_exp)
+            cos_functions[i, :] = zp * qq
+        return cos_functions
+
+    def _2d_cosine_sz_to_fwhm(self, size_constant):
+        fwhm = 2 * size_constant \
+               * np.arccos((0.5 ** (1 / self.channel_exp) - 0.5) / 0.5) / np.pi
+        return fwhm
+
+    def _2d_cosine_fwhm_to_sz(self, fwhm):
+        """For an exponentiated 2D cosine basis function, converts the
+        full-width half-maximum (FWHM) of that function to the function's
+        size constant. The size constant is the variable s in the function
+        below:
+            if r <= s:   f(r) = (0.5 + 0.5*cos(r*pi/s)))**channel_exp
+            else:       0 where r is the Euclidean distance from the center of
+        the function.
+
+        Parameters
+        ----------
+        fwhm: a float indicating the full-width half-maximum in stimulus space
+
+        Returns
+        -------
+        sz: the size constant of the exponentiated cosine
+        """
+        sz = (0.5 * np.pi * fwhm) / \
+             (np.arccos((0.5 ** (1 / self.channel_exp) - 0.5) / 0.5))
+        return sz
+
+    def define_basis_functions_sqgrid(self, nchannels, channel_size=None):
+        """Define basis functions (aka channels) arrange in a square grid.
+        Sets the self.channels parameter.
+
+        Parameters
+        ----------
+        nchannels: number of channels in the x (horizontal) direction
+        channel_size: the desired full-width half-maximum (FWHM) of the
+            channel, in stimulus space.
+
+        Returns
+        -------
+        self.channels: defines channels, a [nchannels, npixels] matrix.
+        channel_centers: numpy array of the centers of each channel, given as
+            [nchannels x 2] matrix
+        """
+        # If given a single value for nchannels, expand to make a square
+        if not isinstance(nchannels, list):
+            nchannels = [nchannels, nchannels]
+        chan_xcenters = np.linspace(self.channel_limits[0][0],
+                                    self.channel_limits[0][1], nchannels[0])
+        chan_ycenters = np.linspace(self.channel_limits[1][0],
+                                    self.channel_limits[1][1], nchannels[1])
+        cx, cy = np.meshgrid(chan_xcenters, chan_ycenters)
+        cx = cx.reshape(-1, 1)
+        cy = cy.reshape(-1, 1)
+        if channel_size is None:
+            # To get even coverage, setting the channel FWHM to ~1.1x-1.2x the
+            # spacing between the channels might work. (See Sprague et al. 2013
+            # Methods & Supplementary Figure 3 -- this is for cosine exp = 7,
+            # your mileage may vary for other exponents!).
+            channel_size = 1.2 * (chan_xcenters[1] - chan_xcenters[0])
+        cos_width = self._2d_cosine_fwhm_to_sz(channel_size)
+        # define exponentiated function
+        self.channels = self._make_2d_cosine(self.xp.reshape(-1, 1),
+                                             self.yp.reshape(-1, 1), cx, cy,
+                                             cos_width)
+        self.n_channels = self.channels.shape[0]
+
+        return self.channels, np.hstack([cx, cy])
+
+    def define_basis_functions_trigrid(self, grid_radius, channel_size=None):
+        """Define basis functions (aka channels) arranged in a triangular grid.
+
+        Returns
+        -------
+        self.channels: defines channels, [nchannels, npixels] matrix.
+        channel_centers: numpy array of the centers of each channel
+        """
+        x_dist = np.diff(self.channel_limits[0]) / (grid_radius * 2)
+        y_dist = x_dist * np.sqrt(3) * 0.5
+        trigrid = np.zeros((0, 2))
+        xbase = np.expand_dims(np.arange(self.channel_limits[0][0],
+                                         self.channel_limits[0][1],
+                                         x_dist), 1)
+        for yi, y in enumerate(np.arange(self.channel_limits[1][0],
+                                         self.channel_limits[1][1], y_dist)):
+            if (yi % 2) == 0:
+                xx = xbase.copy()
+                yy = np.ones((xx.size, 1)) * y
+            else:
+                xx = xbase.copy() + x_dist / 2
+                yy = np.ones((xx.size, 1)) * y
+            trigrid = np.vstack(
+                (trigrid, np.hstack((xx, yy))))
+
+        if channel_size is None:
+            # To get even coverage, setting the channel FWHM to ~1.1x-1.2x the
+            # spacing between the channels might work. (See Sprague et al. 2013
+            # Methods & Supplementary Figure 3 -- this is for cosine exp = 7,
+            # your mileage may vary for other exponents!).
+            channel_size = 1.1 * x_dist
+        cos_width = self._2d_cosine_fwhm_to_sz(channel_size)
+        self.channels = self._make_2d_cosine(self.xp.reshape(-1, 1),
+                                             self.yp.reshape(-1, 1),
+                                             trigrid[:, 0],
+                                             trigrid[:, 1], cos_width)
+        self.n_channels = self.channels.shape[0]
+
+        return self.channels, trigrid
+
+    def _define_trial_activations(self, stim_centers, stim_radius=None):
+        """Defines a numpy matrix of predicted channel responses for each
+        trial/observation. Assumes that the presented stimulus is circular in
+        the 2D stimulus space. This can effectively be a single circular
+        pixel if stim_radius=0.5.
+
+        Parameters
+        -------
+        stim_centers: numpy array of 2D stimulus features for each observation,
+            expected dimensions are [observations, 2].
+        stim_radius: scalar value or array-like specifying the radius of the
+            circular stimulus for each observation, [observations]. While
+            this can be read-out from the property self.stim_radius_px,
+            here the user can specify it in case they are retraining the
+            model with new observations.
+
+        Returns
+        -------
+        C: numpy array of predicted channel responses [observations, pixels]
+        """
+        nstim = stim_centers.shape[0]
+        if self.stim_radius_px is None:
+            if stim_radius is None:
+                raise ValueError("No defined stimulus radius. Please set.")
+            else:
+                self.stim_radius_px = stim_radius
+        if not isinstance(self.stim_radius_px, np.ndarray) or not isinstance(
+                self.stim_radius_px, list):
+            self.stim_radius_px = np.ones(nstim) * self.stim_radius_px
+        # Create a mask for every stimulus observation in the stimulus domain
+        stimulus_mask = np.zeros((self.xp.size, nstim))
+        for i in range(nstim):
+            rad_vals = ((self.xp.reshape(-1, 1) - stim_centers[i, 0]) ** 2 +
+                        (self.yp.reshape(-1, 1) - stim_centers[i, 1]) ** 2)
+            inds = np.where(rad_vals < self.stim_radius_px[i])[0]
+            stimulus_mask[inds, i] = 1
+        # Go from the stimulus domain to the channel domain
+        C = self.channels.squeeze() @ stimulus_mask
+        C = C.transpose()
+        # Check that C is full rank
+        if np.linalg.matrix_rank(C) < self.n_channels:
+            warnings.warn("Stimulus matrix is {}, not full rank. May cause "
+                          "issues with stimulus prediction/reconstruction.".
+                          format(np.linalg.matrix_rank(C)), RuntimeWarning)
+        return C
+
+    def _predict_channel_responses(self, X):
+        """Computes predicted channel responses from data
+        (e.g. C2 in Brouwer & Heeger 2009)
+
+        Parameters
+        ----------
+        X: numpy data matrix. [observations, voxels]
+
+        Returns
+        -------
+        channel_response: numpy matrix of channel responses. [channels,
+            observations]
+        """
+        channel_response = np.matmul(np.linalg.pinv(self.W_), X.transpose())
+        return channel_response
+
+    def predict_feature_responses(self, X):
+        """Takes channel weights and transforms them into continuous
+        functions defined in the feature domain.
+
+        Parameters
+        ---------
+        X: numpy matrix of data. [observations, voxels]
+
+        Returns
+        -------
+        pred_response: predict response from all channels. This is the stimulus
+            reconstruction in the channel domain. [pixels, observations]
+        """
+        pred_response = np.matmul(self.channels.transpose(),
+                                  self._predict_channel_responses(X))
+        return pred_response
+
+    def _predict_features(self, X):
+        """Predicts feature value from data in X.
+        Takes the maximum of the reconstructed, i.e. predicted response
+        function.
+
+        Parameters
+        ---------
+        X: numpy matrix of data. [observations, voxels]
+
+        Returns
+        -------
+        pred_features: numpy matrix of predicted stimulus features.
+            [observations, 2]
+        """
+        pred_response = self.predict_feature_responses(X)
+        feature_ind = np.argmax(pred_response, 0)
+        pred_features = np.hstack((self.xp.reshape(-1, 1)[feature_ind],
+                                   self.yp.reshape(-1, 1)[feature_ind]))
+
+        return pred_features
diff --git a/brainiak/utils/utils.py b/brainiak/utils/utils.py
index 08402d779..cda83babd 100644
--- a/brainiak/utils/utils.py
+++ b/brainiak/utils/utils.py
@@ -30,6 +30,7 @@
 __all__ = [
     "array_correlation",
     "center_mass_exp",
+    "circ_dist",
     "concatenate_not_none",
     "cov2corr",
     "from_tri_2_sym",
diff --git a/examples/reconstruct/iem2d_example.ipynb b/examples/reconstruct/iem2d_example.ipynb
new file mode 100644
index 000000000..9a14dbe8c
--- /dev/null
+++ b/examples/reconstruct/iem2d_example.ipynb
@@ -0,0 +1,400 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from brainiak.reconstruct import iem as IEM\n",
+    "import matplotlib.pyplot as plt\n",
+    "import scipy.io"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this example, we will assume that the stimuli are circular checkerboards presented in 2-dimensional visual space. We will build an encoding model that has a grid of 6x6 channels, or basis functions, which also span this 2D space.\n",
+    "\n",
+    "Read the documentation for the module to get further details on the IEM.\n",
+    "\n",
+    "### About the data\n",
+    "The data and content of this notebook are adapted from the IEM tutorial written by Thomas Sprague & John Serences for MATLAB (https://github.com/tommysprague/IEM-tutorial).\n",
+    "\n",
+    "\"Participants viewed peripheral flickering checkerboard stimuli presented at a range of contrasts (0-70%, logarithmically spaced) while performing either a demanding target detection task (contrast change) at the stimulus position (\"attend stimulus\" condition) or at the fixation point (\"attend fixation\" condition). The stimuli appeared randomly on the left or right side of the screen. Targets appeared rarely, and trials in which targets do appear are not included in analyses. Thus, sensory conditions are perfectly equated across the attend stimulus and the attend fixation conditions.\n",
+    "\n",
+    "In addition to this main attention task, paricipants also performed a \"spatial mapping\" task in which they viewed small checkerboard discs presented at different positions on the screen while they performed a demanding fixation task (contrast change detection).\"\n",
+    "\n",
+    "These data were collected by Thomas Sprague & Sirawaj Itthipuripat, for the following paper:\n",
+    "Itthipuripat, S., Sprague, T.,C., Serences, J.T. 2019. Functional MRI and EEG Index Complementary Attentional Modulations. J. Neurosci. 31:6162-6179. Data available at https://osf.io/savfp/."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load the fMRI data\n",
+    "data = scipy.io.loadmat('AL61_Bilat-V1_attnContrast.mat')\n",
+    "trn_conds = data['trn_conds']  # position in space for 128 trials\n",
+    "# flip to cartesian coordinates to make life easier\n",
+    "trn_conds[:,1] = trn_conds[:,1]*-1\n",
+    "trn = data['trn']  # matrix of (trials, voxels)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The test data have different conditions than the training data. There are four independent variables in these data based on the values in the following columns: \n",
+    "- In column 1, whether the stimulus was on the left (1) or right (2) side of the screen. \n",
+    "- In column 2, the logarithmically spaced stimulus contrast from lowest (1) to highest (6). \n",
+    "- In column 3, the task instruction to attend to fixation (1) or the stimulus (2).\n",
+    "- In column 4, whether the target was present (1) or not (0)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1 2] [1 2 3 4 5 6]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Note there are several different conditions in the test data.\n",
+    "tst_conds = data['tst_conds']\n",
+    "tst = data['tst']\n",
+    "attn_conds = np.unique(tst_conds[:, 2])\n",
+    "stim_contrasts = np.unique(tst_conds[:, 1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set up parameters\n",
+    "n_channels = [9, 5]  # channels in the x, y directions\n",
+    "cos_exponent = 5\n",
+    "stimx, stimy = [-17/2, 17/2], [-5, 5]\n",
+    "stim_res = [171, 101]\n",
+    "npixels = stim_res[0] * stim_res[1]\n",
+    "stim_size = 1.449\n",
+    "chanx, chany = [-6, 6], [-3, 3]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "iem_obj = iem.InvertedEncoding2D(stim_xlim=stimx, stim_ylim=stimy,\n",
+    "                                 stimulus_resolution=stim_res,\n",
+    "                                 stim_radius=stim_size,\n",
+    "                                 chan_xlim=chanx, chan_ylim=chany,\n",
+    "                                 channel_exp=7)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The quality and interpretability of your stimulus reconstructions all depend on how you set up the channels, or basis functions, in the model. In order to ensure that you can accurately reconstruct stimuli at all portions in the area where you have presented stimuli, you will want to evenly space your basis functions in that region. You also will likely want to ensure some overlap between the basis functions.\n",
+    "\n",
+    "There are two pre-built functions to create a 2D grid of basis functions, to use a rectangular grid or a triangular grid. A triangular grid is more space-efficient, so let's use that.\n",
+    "\n",
+    "Note you will need to define these basis functions before you can fit the model. Otherwise it will throw an error."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "basis_fcns, basis_centers = iem_obj.define_basis_functions_sqgrid(n_channels)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To visualize these, you will need to reshape the second dimension into the 2D pixel space where the stimuli are represented."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1296x576 with 45 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(basis_centers[:, 0], basis_centers[:, 1], '.')\n",
+    "plt.title('Centers of all basis functions')\n",
+    "plt.xlim(stimx)\n",
+    "plt.ylim(stimy)\n",
+    "plt.show()\n",
+    "\n",
+    "f, ax = plt.subplots(n_channels[1], n_channels[0], figsize=[18, 8])\n",
+    "i = 0\n",
+    "for ii in range(n_channels[1]):\n",
+    "    for jj in range(n_channels[0]):\n",
+    "        ax[ii, jj].imshow(basis_fcns[i, :].reshape(stim_res[1], \n",
+    "                                                   stim_res[0]),\n",
+    "                          extent=[stimx[0], stimx[1], stimy[0], stimy[1]])\n",
+    "        i += 1\n",
+    "plt.suptitle('Images of each basis function', fontsize=25)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To check how well the basis functions cover the stimulus domain, we can sum across all the basis functions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sum_fcns = basis_fcns.sum(axis=0).reshape(stim_res[1], stim_res[0])\n",
+    "plt.imshow(sum_fcns, extent=[stimx[0], stimx[1], stimy[0], stimy[1]])\n",
+    "plt.title('Spatial coverage of basis functions')\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.plot(iem_obj.yp, sum_fcns[:, 51])\n",
+    "plt.title('Cross-section of summed coverage')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next, we want to map channel responses for each voxel. To do this, we fit a standard general linear model (GLM), where the design matrix is the channel activations for each trial. Below, you can see the design matrix of these trial activations in the channel domain (x-axis: trials, y-axis: channels, color: activations)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(128, 45)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHQAAAD7CAYAAAC7fLAqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABbUElEQVR4nO29d5xk13Xf+b33hcqxc/f05AgQGQQIghIzBZKQaEtam5KlFUUFe9eULMlaBdu7lr3WSvLKsqlkWZa4Jq0AghQlBjFTAEgARB5gImamJ3TO3ZXje+/uH/dVdaruqp7BED0Qfp8PPmTX1K169c679557zu/8jlBK8TpeO5Cv9gW8jlcWrxv0NYbXDfoaw+sGfY3hdYO+xvC6QV9juG4GFUI8IIQ4J4QYEUL8yvX6ntexFuJ6nEOFEAZwHng3MAE8C/yQUurMK/5lr2MNzOv0ufcAI0qpSwBCiIeADwAtDWpEIsrqT3I4Mse5bB92FmShinLdtl8kQkE8W1KPCoQLdsYBx0U5zvauWAi4gYIseZYXlFI961+/XgYdAsZX/T0B3Lv6DUKInwZ+GsCOpNj3wV9EvGmJw3+XZuDJPOLMJbxice2nCoGwbeT+3SjbRFkGKIUyJMs3RTGqivTjE6hsDjeX2zjWMBA3H6LSH8ENSeyMg/HNl/Q/S6EfoK2MKg1kJIwQAqTAzRXAa//QXQ98XX16tNXr18ugbaGU+mPgjwHiIq12/caTK//m/7cewrQw0ikm3tNDLQH1mGLvF6sYj7xA6hn9ns3mpTAtZDTC5Q+kSL95hju6JvnKhWMceFygHAfltblgIZChIGKgFywTZUrkyNjGh+5VxvUy6CQwvOrvXf5r1wTl1PGyOQYez+IFLTxbErgwq40oBAjfx1PehpmmnDpeocjwN0oUzvXydLiPgWUXDAPj0D5Ke5N4AYGsKsJPnMMrldYu20qhqlXE3AIYBkIIlJSY+/Yw9oNDOGFwQ4rdX6liv3gZN5Npv4QLgdGVRgSDYBpQqeLMLVzTrL9eBn0WOCSE2Ic25AeBH77mT1UKr1SC508jAINVM1JIhBT6bZ4E5W4Yq+o1xBMvEmuOEWDb1PpiZA5aOGGwihB+IYio1Tbsw8pxcDPZ5t9GPI7bFUPdl2V3IsuuSIYT526h90IYsjl9Df42IWwbVauBp6+jeQmRMF4sggoYyLyFWFhEKX8/b2wToRB4nl5JarUtH5TrYlCllCOE+AjwFfR9/5hS6vT1+K4mPLf9srkeSqFqNaxnzzF4OowwJMr1cBeXaH6YP/ONeBQ8hVetouoOeC5uPo88NcLuXx4EK8yUjNIzfQ43mwPPRUYiiF0DTL63l8LdZSLHQ8TGPeKfexGvWgWlcCenmzPec72Vh0gIjAN7KR3uZvGnihSnYsRfNhj8+jzehctQb/2TrtseqpT6IvDF6/X5rxiU0vvg6r2wMTNME+X6hvUUG454SuFVKnDhUvMlGYthdHdROziAa0qE46EkeAULowJGbe1TpxwHHAcFCNPESCagtxs3GcYxJU5IUioEMIoSs6LA3fqpfdWcop0MYdvIWBRSCUQmjyqVcPP5jo413rG9LB+OcNvPvsRIroflh4cYeLLA4B+c0zNbeXibfI5MJqjfvJvRB4Kkb5un9rkekpfqHP6neqxyXdw2++vrob91EJaNMdiPN9xPeX8aElGQHdwmIRCmSX5fhOUjgjdEpohYNUKLHka2jKpWtbOz1UPhO3WhWcH8uW7iYw7ByTxepar33Q6cpRtjhkpDnxM9/2Z06gUKsfbvDrxOYVvU+5NUuwIU+wwCc2HkQicGlQjTpDAkcQ+UGLYX8ZQgPFNF5EudXavywFXExl0CGUnk5Xm8+cVteb3XJfS3XcRFWt0r3rnhdRkOw8HdTDyQpv97xrl8fIjYFcnAn59tOh5bwYjHEakEC9+9C7PiEZmsYF2awZmd29y40tAOkGUjAjYql8crV1BOvaMHwty7GzcdpdoTxizUsU5d1uOr1bb3QZgmMhqBQABhWXgLi3i1esvf+XX16eeVUnevf33HzVAjmUBEo3hdcZRt4oZNqknF7akJRhL91KMSDOnP2HWDhUAGAmBZCNsC00TZFk4IQOLZBhjG1hfguWuOJmvOt+2gFM7lUbgMtv/Sdk6U649FV4OdY1AhEKZF5oFjzN0NH3nvlzlbHODl//sWDjyc5fTvpDlafRlcF7dcbjlbZDQKB4YpD0Yo9pt0P7OMmF2k989mdFjPdXHahff8a2m+R6mNZ9odjJ1jUKVQrktkokIqHOKj0fcgS5IDC2VEoYyq1lDl8pZBd1WrYWQKBE2J8EKU9sXxDieohwXhmTrB50bwiuU1B/uWEBKzv4f6vj5qCRtlCCLPXkFlc/qY0gn8fR8h9cP0HYr57hyDgj6MP/4i6cch/TF/T0kmEJaF6ErhzXvaMdrk5qhqFefKGGLCJBgIMP6R2ygeqfFdx87zrRePcmysGzkzj9vGoMIyqR3oZ/zdYaq7q5gBl/0L/ZhXBN5MZwaVtqUDBpaJqlTxKn+PDCqEQN56lKm3p6nHwLMV+x5eRkzO4uULfnZD4lWqG4wpTBMRCpF58GYqXZJqErpOu8SevMyur2dxn7K5nD7GwfkqanoOVS5v/H7TRJim3l+VwqtUsS5MsbfcgxMLoKSBMTKOmy90/Ju8Wh2oI2pGR2nAVwo7wqAIgZMIkd/vIdJVrICDkwxizVuo5WrLzMvKWImwLQq7JOV+D9VXpZAJEY+EEefHMMplwv4yvWmMRUjtSAVsMAzMrjQ4DvLKNGahiKpWO3NuGnFbw2gGEdou768wdoRBledhPnuWo+fjeqYIgbe0jFdrfzNUvYa7tMzwn5xFBAOoeJTqkGTxzf1Eprqwl8pwemTLG6vqNZTrYgwPkDuW4r5//Qxnc/2cPXGIfX/jYD1xqu2xQ1g2MhSkevchyj2WPiItFnFfHtle4vwaE+07wqCAdjbWOxxC+HnIECIc0jFP18MrFNb+aKVwl5f1e3N5AqaBG4wjay5uxKb84B3IusIqOARGZnGmZjbuw56LKFUILDt88fJNlPNBgnMG9bjCPnYAWSgjimWcmdnWN1x5KNfFLNQI2BKzUENUav6RZ2M6b1NcY1xgRwcWGkcZY9cAtV1pjFINWarhjYx2tJSZe3dTOtrH/b/5FAU3wCPjh4j+eZz4l89sfCjWfa8MBBCRMEvvPUxuryQ8q4hMu4S+9lLbFNaa6zeM7Ue4OsANE1hYA/8ooxaXsR1X30jH0VGbToYvZQifE/ztH38XwlOEs4rEqUXtXCmlo0LRSDPP2DwSKYVXqyNUkdSLGWKjIYxCDZkv4dad5tiFn7yHWlLQ92wFezKLe+HShpWj6RCtewC8t9zOxDvDdJ1yiYyXEC+d7yia1A4706CrY7Ceq/lB6zlCrSANZDDQ/NMtFCGXo/cPV+g3q+eIMAxEJAyVKnjemoiQcl1UtYo69TISTYlZP3b5/iqDfRmWM32kvTjyQotr2mQmZw+EuOM9Z3nBOIpnRUi+HMDtdOZvgZ1lUCEwBwdQSc0pEOUqzpXxlpSS9TBSKeo37+HS/w6G6aKUYOi/WwSPX8ZdWm45XtVruPM+pcQ0Kb73NsppbdT4aI3A46c3jaWqeo2jv55F2Tbx+YtQruBtY3nt/uIISycGObA0gSp2np5rh51l0Aau9ocJASiUEihPIDr4GOU4SNtGhMPkdhuU+xVWThDMmgTapM3c8xeb+63s7oIjezByZUSlijs5vWVUy52fh/n5FQqNNEDQ0cO7FXaWQZXCmZyCKdH8u1O42RzmC+c5/G96oO7o6Ewm2zYqBCATcdzBLsr3FTg6MMfLT+7DtUTzLLkVhG0j9u9m6u3dpP/hBFdODBK7Ihn8ZBW3k9SX7zjJRFyzIqrVtfv5NrGzDLp67+zQmMI0EYEA7u2HqAUNpONhzeRRi0ttIzSN0GLmLXuYe6MkHllkPJOk66QifrHYnqfrJ7W9sE1owWPyySG6L0B0qooqFNs+DI3fqVwXVdZHtgYz4Wqxcwy63sXvMMMhAgFkPMbU3WGcMIRnFKmah7xYa31DxcrsF4EA9HYxe6/g3zz4V3x8/D6uXOrlpsfG8BaX8FrNLmk0P1eYFsK2cUIW0bEyibNVxPgsbiazKc2kJRpsxlcAO8egSnW2zDQ82QatsVrFXXLY9fkplGkgylVUPo+7bnYZ8Tj09zD9rj4KexS9zyvCUxXMly5y6BOS//HIB7AKDkcKJdyFRX1E8iFME3nkANmbUyz8QAnOR0i9rOj6uyu48wtYp674gQUPr1Vqz39Yje4uHQXL5VG1+nUJC+4cg66GEBi9PTqUFw4ickV9k+u+wQ1DzzTHX54cB+fSlZXhlo2MRnVsVim8bE6z3YMWtSQ4vTWqMZtA0EAWCnDiZQIn9NjN5pUXNKnGBLcMTvH88n5qkzpZrhxHR6m2/D1S/2eaOjlvGCh5dXtkO+y4SJEwTWQsxqWfP4p3qMQ/u+Vb/P6j7+bIn+QRlyY21qyshzSQNx0ifzRBbreBULDrrydQmSxeoYgIhTQ90+fXtpwlPkthdb2LME3tAEUiUK+havXWs3EriO07e5vhxokU+Yd7qyAoLgT5s0tvJDxh6CR3uyXZ5wPljiSYuU/ghh3MvD+bPb2kq3x+y/HSthDDg/pS6g7e4jJeoaDHOg5cy173HZg8O8+gAK5L6rxDdFwS+HKc0OgS7qWxtkcAaVvQ08Xc3ZL/6/2f4suLt/DcuC6x6WR/Fpb2epfv6kV4YBVcIqcVXrG0PRrKq1iaeNVLrhBiGPgE0Ifeev5YKfVRIUQa+CSwF7gC/COl1JabzJrgfMOB2DWonZxqHVUu4+ULyHgcYRp42Vzrs5ofm3Vu3sfy0TB2UWHUPOysQ2Z/gMX76qSes0ifq2I9dwFv/WxtzNBdAwhP6fNsOIgXCzL11jhGBfqeyWNMLerzcmc3SnvDhtRRp2sMHDRwPZZcB/iXSqkXhBAx4HkhxNeADwHfUEr9pl+K/yvAL3f8qb6364xN6hkTi+raklQSFQ2jhEAUS01naA38uK/49kuknxLIcBiZTJC9b5jsIfhn9z7GH+ffiZ23SdvWxpnkuZoqMnJZ/y0ExrFDVLtD5G+uIYoGiStBwtlQ53dJSIThJ9BdT0/060g6e8WcIiHEZ4Hf9/97m1JqWggxADyqlDqy1dgN6TOf35q/tY/Qz05xZSGNdyXC/r8uIk9f1kvgFsuvjMWQiThjH9xDpVcRnhaEZzySJzPI5RwqX2gfO/VnK5aeXSIWA8/Dy2Sv7sjxCi/D19UpEkLsBe4Angb6lFLT/j/NoJfkVmOaFdxBwhs9wLqDVXC5ONODt2gTXhLIQg21jldk9PVCPAq2BdUa3qhfhuo4BDIKZQjCsx7R8Qrq5ZE1NE4jmcC5eR+eLfEsSejkBO7ScjONpZSCShWlPFQLvqwMBvURSkqo17dmBH6H9tRrNqgQIgr8FfBzSqmcWBW+U0opIVqHyNdUcMu0EqalX/cpj87EJObEJAceWYnMtIq+FN+4l8WbTepxRXBBMPRnBVQ+jzMzS9efzq3+wg1nTPfwbhZ+ucze5BK7whme/607SX7b0Puj56KqbZywvh5UOIiyTWSmgDc+9aqV6DdwTQYVQlhoY/65Uuoz/suzQoiBVUvu3Oaf4EPpCmuE3Biua3ODIucXsbNxnLCBVXBQxeKaRPVWMCcXsT69h9FQmku2YPD0gg5CNMYJgdnXi4pFwDIR5Sru+GTzbKqWs1As6UBBubLm2mUwiDiwh8n3dFEPg2fDvs8sI0an2rPjGwH7w/vxIgHcoIk1m8O7PN62JOOqDSr0VPxT4KxS6ndW/dPngB8DftP/38929IFXyVB3z19Enl8pPdhOza8zOUXyEyve6oZvFxKVTlDviVCPmFi5OubCEqJe1xGizYIcQiCCAUp74iQemOZIco7BYIavn/4uEsUKslJdOde2HK8Ln0p7ElRTBrWYIGlL7Ok5KHtbHsGu5djyFuBbwElW7uO/Qu+jDwO7gVH0sWVpq8/alFN0HdDg3wohUG57mqUMBhHBACIapb67m8m3RvTneLDn4Uldy9JyoIGRiOPtH8SJBajHTCbfJnGTDtQl3U8bpP+/b29xoQIjmQTbajIhAfBXhy9P/8Er6xQppR5Hp2Rb4TtjnTZoOi3QDOQjJKv3+VYQpolMpVBDPSghND1lZhFZdUCAagzf7HOkocUwDIkxuYBUioCUGPfsw00AhkK1qZlqMhn975HhMDIe2/p72amRomtFo6R+/27ceBAlBOZSEe/iFZRTR9XbHFdSKeYfPMjQhy4RNmssViKofzOAeWma4f800nyr04I3LCwbGY+y+MBB6lFQUtD9Ugnz+AX2/8ZLzfepurM5gXx9xZvn4hWLHUnovDYN6ieNxXIOs1JDWSa4LsZAP8pnwm8aWFceqlIhOVLh/NcPUO3y8IIe9oMGwYWD9L5Qxh5dxBkdb81T8pPViUtl6jGLelRS7g8gvucNRC/mkJkCztjE1g6bUjR3MSFXcrAdbI+vTYOCprNMzzSJ2rIrTX24C3PeRuQKmunXyglTCi+fR37rOMPfAnH3G8gejvKP//WXmK4l+Xz0zfR/uwdrbLL1eM/FK5UQT7xIMBYjtHuQqXd0kb21TveTSeJjYayp2fYFxM1/85CBgN7vXXfFk96MUrzT0mfXBY0YbSSMqlS3FekxkglEIk7+jgGEC+HxAnIhizu/0J5w3ZCSG+yj3h9j+XCQeligTEifrRP44rPtL8DfP6v3HWX6zQGqPS4q5DL2E79yg6TPrgcaMdpOaztXwc1kIZMlNDoOQqBMC1cK7SWvel+D2ySCAc1KyOZRrqsTABdKmOMBzOFbqSYFlR5FdcqgySAWAiOd0uJUkRBkcnj5whrWRD1uUhl0SA9l6IkUGdvkev9+GLRTNBLbht6zNpz31IoKmFo3Tu7bTe62HpYPGTgRxf5PZZAzi7izc81lOPWZE6Qa+kfVKh4rHvXoTx2ifKTCR+56lP/22e9h7+eLyJMXm85Q9IsvceyxMJjmll7632uDikAAo79XU0kMCbMLeH7Ep0lW23SwwLv/NqpdNrWoxKgprKJHZFriWSDz5Q2lDauJYDIcxuzvA59mE5pVKBnkv1rfTXwULYWziv3XspirBV4bBr0K+idooafcXYPUwwInIOj9JojJmY4YeMK0GPkRmztuusz7e07yH558kGO/tUzoW3N4+fymqqDN7+5KUznURz1mIDzo/ZtzeLlCcwW42ojwa8OgV+nYqWyO2Ik5VDCACpqIfBHVIKC1+Uzl1NnzecWl04f4/Xd1gVSM/mAfQ49EMU5d2rq6DVD5PIFxm6V391MaUhi3HSU6ruj+7JnOdCA2wWvDoJ1inaG8SgVGLmtnxrZRxsYoUiNUKENBfXQol5vB+dAjpwmPDHJhuAfiLuWjFaonA0QCNhR1Xajm7loIy9SG8rNJXrGMZBEn0k9toE44USYTidPz1RDiGiiefy8MKgKBZr2nl8trxt8qh6dRfrDywkq2xb3vFjKHghTfl6e8GOLgnznYYws4o+N45TLi0hiHf7cMhgQpUYvLuupNeZhDg2TePMz8nQLrUI7kQ1Hi53N4J8/rQqlsneFPjCBCQZ9TvKyPQ/7e2dB+ENEIqlprm9iHG8WgvvdpDg2gQppkvWU19bqxwrZhoJf8sTRmwcUsOpinL+sb37hBm3yOcDyMqqJathA1iTLEmmS8qtdwJlpoOwuho1NVD7NgUsqG6K4oRH2VQZTSXnA7uJ6OJ3eAG8KgwrSQkRAz7xumsAuMiiBx2SP5N5uQxdYMlsh4jLn7e3jDT59ivhJlKhen99/v1somW+UmlUI8fYrUcYv0i3tQZgVRd1HFcvt91o9UhT43y/DnVzi+7jb2+2aKbRvn5xvCoMp18coVuk6UiI3byJpHYKGsjdmusEd5eLk8XScLvPDJWxAOGFWFsTiF10Z7FtD7XQ2MuSVEKk55f5rqLWnq4YP0fnW0PfuvGZc18O6/jdJAgOWjBl2nXcKfebrTW7BC9A4FNQN/pvX7bgiDNugg4tsvNaMrbU3RWBaF1NGaZ0/S/yxa4csw8Gxr8xm2XgVMaZVrMxKiMGCSOQJib5Hu40nYzKCrZ7CQCNtm4bYw2aMuH3n7l/nDr7yHA59pPbTlx5mmFg5JxjV/ahOD7uxYbiONtB0uqxCYQ4M4u7rIHgzjGYKeR/3WH43ldbPPlQZGTxfTP3iQ7BGXe+66wNlPH2Xg8Tzi5AWUUhjdXahICBUOwIXRDSkto7sLEYtSH0whS3XE+Ss6duzUMXcNoWJhan1R7Jk87tlWNfyb/66GyjZS8tXiJ15Dsdx2NSKGxDMlTkDoRLJhgGUjIxFkKgm2hVpa9iXb1u5PQkqcEKiIy5HoLCeDR/FsAyuVBClxe1MY2SKMTmvd+A3XJlGGZhFKU3u++M0N3Ll5mAPjbG1be2njt25JW2l8/Y6eoevhz6xGOeFm+gfNmKyln1dVdzAH+qge7mf8HQHqe6oMftYieqWAev70hrGrJVpVuQKGQeHdNzF/m8H/8Y8+w3946v30fd2i6xuXtae9/rthpdbVc5vnXDHYp407OaubEVyD6smNU6y0FXwHo1kqv5ohKLVQogwF9RJXq625YapYxJ4t0HXapjQXJDKex1gq4AiB0d0NvWkW70zj2tDzXAa5kG06PMKyiYyXcK0I/+HR7yN5yiQ2WkJVKr6keR/1wTT5vSESI0WMmWXc6VXiVq4L9brOw4JWSFvtzPnlEg3xqteOxkInUKplFEXalu5v0tuFLJQ0w32VcmcjDRY7Q7NvS6OBj7e7l6U3xNn1EyPsiyzy6H+7l/S5IHJqeuX7nj1J7FmIfXLlO110IXHpaB9zd9oMvmucyS8N0/OiTWBpubk8NpZKb7qFJ+M7YDIS0pGoYoltKY+tw44zaDM6EovpI0cm29FTqxwHGQ6xfEc3mYOSysEqg583ib+cwTt3cfO9RynklWm6c2Uu9B7ipYEDePfVqKZD7J4/BFOzW55VvVKJ8IkJds+kKJ0aYGg6h7FUwHWczsofPC3B4xWKzb+vBTvOoE1lTH+fxDDAa8/ZVZ4CKalFBeVdDu84eo7jT99CeDqI3ERivFFcrGp1mJql56U0uWWLwntq1GM2bjSAYdktxwI6/WWaqFweLuQInXF01bkh1y6pLb9cL7ONY9HVqp5s+Ngd6RStZr21e2L9c6VyXYQUukI7HNI3djm7pfNhHDnIyId6iF2B1LkqgQszqHxBU1VqNZ3O2oT7IwIB5j61lzcPXOHRT99F96k6gS+9sIrz04a1P9BPfX8/1nQGlS/qbk7bmJ03llPUYNELodtN2bY+amRzrT1b30FSjtIV2vm8PlMePYCXClMYDhJcqBN8aQwvl2saWFSqhKcEoQUXM1/VVWm+DJ0MhzF6u1GJKMoyEKNTa7s7uC7Ziym+XAiRnlXYmU1qPzdZdlW9jlGoQrUG9U0UW64CO3OG+pDBIGLXAF4yQi0ZIHRuVsvNtEtA+6SwiZ+5k+ItFT52///gV8//QyL/MUHg/Ez7cJ0QmPv2kL+1l+XDJvWoYt9nsojphc6C6f5nNHUatpBVv1pctxnqt2d+DphUSj3odyR8COgCngd+VCl1Vck9r1bHWFhC5ouEFoJ+bWYHH+VLzKRfdjCLQT6c+ymilwzSo1N4uS00FnzIQIDqnjTTbzYIHMzSFS5TfyRJYHHz/bSJRsX2sf240QC1uE1oNIO6PN5sYNcxrkJk45VYcv8FcBaI+3//FvCflVIPCSH+CPgJ4L9e1Sev76HSKRodJi5mCCyGSIzaBBbLeLPz7Q/zQoBhUElbWPvzvGvPOQbsLJ/vegf2bFiTntvMNmGZVAZjVFIGpT5Jl5cglMnr6NQ2tHZX+qF+hzorCSF2AR8Hfh34BeB7gXmg3285eR/wa0qp79nqc64XL7cRoZHJhI7QSIlazrRvtezTKtVALxMPpCkcrjO8Z4HxsW6O/kGx/dLrFxqpPQPMvCVJcVBRT7vsf9gleGFW5087uO/Nwiq/9+jqh+F6Lbn/BfglVs7qXUBGKdXwwSfQ/bg3Xuz6Cu7rgNVMBBGw/caqm99IYdkI20J2p8FxYXKW1Egc4VnMxOLIoqGPUi0+QwQCyFgUd/8g9biNMZVHmZLQgkctJnFDElnfnC3fTI/FolCu+KnBRqvLzh2ma6kPfRCYU0o9L4R423bHr+/BfbXXscnFrcmmePk8tN86MbpSeH1pxt+VIrCkSJ8uEHtqlPAXFpvnYW+TY4wcHiR/ay+pfzHK/7378/zQX/8M6ZOC7r88Ttw3jHLqOK0MKoRW4+zrJnNrmshEBWsmixqf0g/lNmK+1zJD7we+TwjxPiCI3kM/CiSFEKY/Szvvvd0oG9jVj5MK6x9ULOkMRQc0E3Pvbqp7uhh/d4DwtCBxuU7k+bGtG9c1hjcUPXf1UEsGiE54BBfrmLMZzWD3m7ZuiUyO6MUglz+/nx8e+Bn6n1JEJsqbJxBWQylUuYJcyhK/YGEsF3Ww4ipUOa+lPvRXgV8F8GfoLyql/okQ4lPAD6I93c4quAXIUBCZiJM7miY/bNB12sSeD8L84tZOgc8ZquzrZvaeAF/+kf/IL49/gOOPH+bgRFr3tG6XcrJtRDRCaSBMPSxJnMshF3M44xOd3QzAXViExSUGX7q6xcYrlfRxbGa2Lad3K7wi59BVBn1QCLEfbcw0cBz4EaXUlmtG9HC/6vm1nyXyQoj02TrhkUVYzqLKlbY1kdX3v5GloxbRSQ+jplACgkt17NkCanx6o7jU+ms3Tb9kT+i2XFLiFYobsjU7Ddc1UqSUehR41P//l4B7tjM+blUY7l1mNhrCKjl4l8c6jm3md5nkj9YxKhaxCYfIF19EOfWOEsgyGEQO9GnFsHodbynzqusPXSt2ROivMBoh+KsR9uVnYX5JZyo6RH4PvOe2UzyWOEjpQpQD34zoGdaBYcSBPZz96RRWThBYFuz6wqxWGunQqCIQWNFq+A52INwKO8KgouYgy3XK+9MU7+ulHhX0P5FBzi7pot0tkD6j+IZ9G7ImsHOC8j0HCE4WkGNTa3m3rb43VyR1Jo1ZBrugOyttC66LanrTr0ws9lqxIwyqnDpeyGL6Pou7332GXxr8Mj9q/wI9LwYxZue3NEriz54i+Ukb756bKOwKMv4ui/TpFN3VGtJxtoz7OuMTdP833/ERArdd998N1319RIyvBTvCoCiQV6bZ+wXJlZNH+HDqGINPLyHnlnE6WMaUU8ccmSI1HSY6nsBcKKBm5nUHpe1cRrsSwvXwy/3VkX24UZt6zNSN0Kdm2jeO9RMIme+/newBSXlfjeCYzf6PT+pyik4aD7XAzjAo6Hzg4hKRZyGC5t12vIitKikQlzooxWvlyKwWqmgBGQw2W1IqP42mPIWwLapdQWpJk0pSEpoMgWXBqkB8IwIlwmHNwsjmdSjSMMjtkTg3F/jQsef4ZPxOvFgI0apPaYeB+h1j0OuORhYkGNDatYUWbTw2i+KEQuTfdwu5PQbVewqEnogy+I1F1JUJ3GyOwJNnCRgGcUPqCrPV0SRp4LzlDczfGsR7W4ZazWTP70qsySWc0XH2/PdziFCIp0PH2FfO4M7M4a0jkMlwGBEKIkIhvIa45Cbt3/7+GNSHCGtGg+zpQlRqnQUPPA+r4CHrBvFIhcWDIaCLoc+W8EaLbfOzRrFOIBNgfjEMSlBLgLkc1CvLwmL771dKFyz5seCttoYb16DbzRUqpWdOd4ryQJTMQZvgsiL2cJvMh1J4lQqBR07QlznC+VvjvOveU/zz7/07fv78R7BHx7f+Xs+FZ0+RfsGg6/mDOF0h8rsC2JnQpjJsG76/VFqrdf+a1Fi4msO8UjC7QKhUwc7EkOVNAhAtHhZVdzDHFxj+wi6ef/5Wfjh9G/vOTzXDdMKykZEQzk17qaVsQuN5ZLbYFJlSroucmcfOhkgtRpGZ/Jq+Z8b+3RSP9jD+gCByxSA27pF89FLrdlvXQ43zuuIqoi/N3KHf/3ozcpe7sAgLi3B5lfPk1400QoC4rr+sreIIeS7O5BShySkaAuWrDy3CthDRKJlDYYqDgm4ZJzRtwpi/pK9eXsfXul/CMqn3J1i41eSh93+UX7rwvzD54gDJ4zHE4tK2jrg7hlP0puD7dJOAYABMA296tqNMhTBNZDTC5IdupjjskTqyROWb3Qz/9QyqAwEMYZpwxzGWbopSGBYIF/Y+NKkT4R2yJZpcYtvW/UhNU0vQ1Wod6fMhBDIaRSYT1Pb2YOYqyHxZdzjcJJ58Y7H+XkU09bc7OJMaXWldq+kp3eWpWsVtEwhpwBzop76vD1l2kJUa3qUxnIlJ5PjE9o5s6z/3Kse94lDVqu6pCdtacpXj4GayDPzBcyD9hnj1K7jttPQa410Xcfws6Rclaakb9jidjBWC/HcfopqQhBZcwhMFvBPnOg4BTv3Afn7+Iw/z0PQ9vDzez9F/P4iamr3mpnY7xqBrcBXbQEuFrw6/q6MmPY092jR1MZTrEr2cJxSxMfIV5FIerxUvVxoYh/ZRGU5Q2GVj1BTpR64Qv+Lw77/wgwQXJOlFBdnCSm+35pcKjESc+m37qaRtymlJz3MZxOScZm61wM40aCtcS5rqWnuOCbFSEhgOaUJ2oYj34hkEW0S1fGcrf5Pu9tR39wzLpRCJCz1Ej09w4AtbyKOjSxJFKsnUm0OU9tc5dnCcxfoeuurujWlQGQ7D/t0s35Zk8VZB73Me0dES4vi59ikuIZC3HKG0J87kB+swHWDwcY/YiTktK96JeoppIdNJzbrL57WTUyppakgnqTL/7Bt/apTohST1r6for3vIC5dxy+0zO8p18Wbn2fM3Nl40SDU+QPfIBN5SZtMxO9qgGAZe2KLcLZF7CyznotTDUXpm+1DL2bYBbC9sU0ka3LP3Aqci/WSmUgRnE5gLsfaNePwjjDBNVMCCgtQG2i6LoaHbOz1DI5fTcda0EVTwS/dNaEtP2dEG9fJ5xPFzDBX2kh9Lof7pDO8cOMdfHvluuk4NkXj4uc1LDZVCPP8yXS+HWBjZS+BYmIW31BAqQqL3KNHHzuGubumx4cu1UIczPauLoEz/Vm1DXfrVwI42KPjOzmKG6CWDS8/38YneLrouQXim3jbdpeo13JyLdWWWpDlANRkiNuYSnNe9QxESGbCQ3V14yRgyk0eVy7hLy2sCCspjFS10xZhGdxf0pJl7czeBvGb5mRenO2Mq+lVzRm83BGxUNqc1Hzo5t26BHW9QQKfGZufY+9IWb9rM8fFcnOkZ5PQMA99a9TJ+uC6ZoHjLIMtHLVLnYgRnS4hsboPnu2HPFgL34BDzt0f42C//F/7n0n38zWP3sP8zgxiLS+2Zhn6jvtItQ1RSBokLUYzFPN7lvwcG7QhXc9Rx6niZLJFT04Sm48jlvOYCr9c/aBxXVu+hSmFcnqGvkObH5c8TyHnsH69ij0zr/mp+2+nqG4bJ7bap9AiGvpHFmFzAmZ1D1R28fIHw6WlCQRuWs3jV2sp3mhaVd91GYchk6TaP5BlJ/zfmdPRri1m8sw3aIF8buoe1Vyi2F99fBREINHV9qNc3Vn/5mRRvfGJDfLX5GYbhy+JYCNfVfVz8z2isHL2nVt6/OuAuwiHywzbZI+DtLlE5FSacDcMsK3t0q/Sdr+CS322SPaT4vjc/z+e4i+4Xo5iLAdjCoDsmlru+WEmGw3BwNxd+LImbcogky3R9LEL0udH2bHhpIIMBln7gNgq7BJUej/iIZOBTF9YU/G6JRrvJRiOfanXbCiWNkn8RDEDAxlvU2kgdsQobOvTBICoRReSKeAuLzfj2jRfL9TxE1cHOSGrKpFgP01d2Vwp4OhhvlTzsvIFnSexC50W3jdIIGYui6nWoO3ie6siYRlcaEYtSPNaHUfMIXlrQgf427MXG98pwGNGdxouHETOLOojRaTdhdrBBvUoFzo0w/OuXV73odnaG87tARD7zDBFoeqgdqXcJgYxGEOkUtaEU1nQGljusURWC2q17WbwpyM//zMM8V9jHNz/+RnqfSyKeOtH2gZCxGO6hXczcHyN3xGHo6zGioyV4/kzHD+O1tptMAn8CvAEdRv0wcI5t9uBuBxkMaJHgckXnOjskQptDg7j9KSbeFcfOKLpOV7TTspXOrlJ45QqGH1ede2s/tcQAvS9UsGfzuC+PbDk2cGWRnmqS3/yzf4RRgd4zVazZLK5htPV8VbmMObVE73MmsTGb+MsZRCaPs42E6LXO0I8CX1ZK/aAQwgbC6A6FV9+Dex2EYWiCVKORG5WO9yC3L0n2cJT7v/84z0zvYcFI059Lwez8lgVQmoRVR7geS7cq+g7PsVjtIxk0CFwwttxLncujiMujDD/lK5tFI3i1ejNnqpRapYS29jO8SgVvYhI5MUmEtQn4hkCV8pQ/dpOffQ3tJhPAi8B+tepDhBDnuNYe3Ou/y8904LrbckxkJIKIRnAODCDLDsZ8Bm8509HhvbGfMdCLFwsiM/6YgI3IFbW6Zxtm/urGrqV9CWZ+rELAdgj8TZLkuRLi21sdrP3fEAwi9u8mc0uahdsFvc97hKcqfOOJ//MVd4r2oWP+/58Q4ja0QMa/4Gp7cK/5FQZGOrniYZbKbbssND/XNDG6u/B6U/ocUneQz7+MqjsdkbYbtE3QuVbvwmUtwhEIaO33wR6tpdsJVqXmPFMQCVWJBWoUrCTKEJ2RxKRESd0LxrMVnim0sNVml38NM/Ru4CngfqXU00KIjwI54GeUUslV71tWSqW2+qzVM7RBtlr8vpuoJgUoSJ+tEnjyrGbCb1WrYtkYXSnG/8kBjv7Dc3hKcH6xh12/6sD0XHtKifS7PxzdqztEKJBjs2uJWleTimsEJxoPSqW6veKmBqfYkFo30FN83f3kKz5DJ4AJpVRDZ/vT6P1y+z24V0G5LqpSJX65ghPRlxecLuA19p12Y0tlUuccTnxDr/JWHkTmUkdlEcJfEWRWswaE6+GVymu/t4WwlAyHEXuGyB9NYWcczEINeeriSkvLhtZti1rVhobvwjt2AxBadAifX8S9OLqmwYGq11CbkKtX41oquGeEEONCiCNKqXPorr5n/P9+jO324G7AP3LIbx1v9tXuON3kubi5HMEvPMOeL6y83GlJkbB0VElNTHckNgz6IZCpJIt3pFl6sIwaCxOaDTA8Fmvf4ACQ6RS1vT30/YQ+np08N8yuL/cQnZzZvMfpFrhWL/dngD/3PdxLwI8DEnhYCPET+D24r/E7mmgc9vPfdRAAq+gSOjvTEftdBoPIrjRjP7yX4i0V5JxN7Iqk9w+fbs6E5ixusRI0oj7e3kFE3dXNcsYm8apVvIVFup4wiI11YZRyyFINdznTvsEB4M0vYJXL5H9jPwCHsjWs8QWcyjZFqnxck0GVUi8CG9ZxrlMPbuFTQcpd2ilwbUEwFFh5g78HotRGxWvDANuiuMvjrYcv8FxsmGIt0fhgncrq6dYC/Y5eut1MZu1NtS3cqI2su8iK1J/px4PVxBTm3IL+XqU6FphqNKmzv7xSEvGqayxcK1qqcULrG+IH7AF9jPGXtUanweX7hpCOwix7RF4Yx1lNq/S9ZxEKQb2OqtdxF5cwUinoTjHy72Pcv+8SJ+YHKD/Vzd4/PLu2GrzR1MfPwzZeF4EAcvcQxaPdGFUPo+RgHr+g2QbX6f7eeLHcLZgEG4QwhKZfUq0RXHKQdQ9ZdTfqAnrumuIgGQ5j3HQYZUqUbaJGwzxaOYyxZJGa8o8c6xyiZmBfCKrvfSO1hEFwyUE4CjtX93m29baSNDISQaZTqEoV6rX26mYdYmcadLsCh0JqUaeZWaxVov7tbo/s62H8gW6Ci4rwnMOh/3xxzRFlK59a2DbB/2OKfzb0JL/20oMEnowx+Mcv4lWqeB0YRgz2kb2th+BCHStTQZy9iKq+Bg0qg7oOsnzvQTxLEJopY8wsb66P19DWZUXVZP6tg8y/ySV60SQy7ZH+3JmWUR1vYYnBb+qiJVEsa/GnSBixexDqDiJfxMvmWpKfVd0h9yfD/Fbqh+iZcomM+UqhncZd5xeJvwSiXEVVKvpY9gpgxxkUSzc/zxywcIPgmWGiNQcm5Zbx18ZYtyvG4q2K33rHJ/l3PQ+ydCFO+mtBRLmCWm/QfB6eO9WcyQ0vutoXxai6mIZElMvQiszuucT/4qmmBOmWa4rPHxKG1LHcWq3Z1KAtGpErf/xKQfEmb99xTlEj/plK6UqwarVlw5yW8HuuyL4e3O44MldGlKs4UzOd70+rPGXlujqQ7rkb22dtI7fKHcfIHopQGJKYJRj8zCW8XL5tTFkEAsj9uzn/4W4YKnN0cJaF/76H9DNzfOX8f7xBnCI/quIuLOien8ODEA6gwjbW5Rm8THZz4zYoJaPjMCYQQ4OocBBx103IXBk1OtG+os1zV2601JEjYZrbF9RYDUernJll3UivET3qCK6HWYZqwWI6HyNYU4gtkvw7b4b6EJaN3L+biz/SQ31PlZt2T7P4x3tIPzWDc2V8a6P49JH5H72D7AFI3bLA8qluDv3JLMwudKQw0mAtCNsGKfCyuatvkrOqsR6wbW+2yQn2nT+UuvGOLcp1YSnLwFMpyucDjKf3MXA2i8rmtnY8hMCIRxGJONFJB6toUBnrYWDK8Zl1m8d0jVQKersY/0Avsg52RtF9PIu4NOHnIbfQ2jVNRCiEc9sBqt02gcU61lIJ9+zIqphsB4b0V4XV+dLt6CHtWIPiubjz8wT+dr7ZYlLR/igiDAMRjeJ2xwlfXCZSqeKMT7WnrwgBXUmKh9K874eeZLKc5NuX9hGZixA63z4xIEIhZDrJ3F1hCns9oldCxMdsIucNVCdM+9X92jwFSlyVsNXONejVwL8p3tIyMpfX+cwOHBgZiSCTCea+q59Kt+CLf/5mwrOKQ2fzyNEJ3C2C5DIYRN18gMm3Jjj4Dy6Qv1zBnAow8HgWY2qxba2psGxkKIh3YBjhurosMZvT+d+rwI416Jp6TMfpXHwfNGUlFoWIVhpRY1Nb0ieFYegsiwHCg8Qll9BcFWNmWTtgYosjk5R4tokThqOxWY5X9xJcEBiTCzoq1bYkQoAUKEvqtMY1lj7uTKdIiJXmqb1R7Nk8anSybYK7EWstvv92Jt8O73vTiwCc/j9vJXRpCff8xS3HylAIGY+Rv3cPpV6Dwi7B0DerBE9P4MwtbPrdTX2FcAj8YuBGUfB2jktAx4VQN55TVC4jlMIGTTLuIMGtBZpcwlNlUicjfMm5A4DDMzlEqaIT0eEQwjR1eqtxxvTHeuUyAOGJImYxiFW0sBdKKNdD3HmManeI5cMWyQt1ImdncadnNQG7kTttRJRWa97jc3XjMWq70+CBdXZM02pWR6DaGb7xmW3etzMN2qnCVquhjgNPnaD7Kej2X/MAgkFkKonXl8aJ2JjnPVRxnQpYox7z+dNYgAV4fln89Fvi5G6t8YV3/Ce+97F/zvCn+okUiritvOZV4UiEQA30UjgYZ+p+A+HCgUI/xsxi53oKDdkdw9CshS2MurMM6jd1FYahl9cOlx9hmoibD1HeFWX6TSaJEeg6vgyXJ5uZGa9Wh+UMolLFNE1dElHXLSGNQ/sp708z8Q4TN+ix77MOgfGMXqKVwisUGfraIr3Hw3zoW7/A/stVAiOTuFn92SIQQIaCiEgEL5dfu18rhZiYJpYtcGBKU6vklanmatAR/KgVHbTc2jEGbfbHNrWDwsycb9QOliLDoDwUJbPfIn7HAnm3m8SlEJZtrbzPp7awPsokBF4sSLHPpPuWOVLBMpknd2NlQ823KMfBPX0OCaQf0685q8YLv8e3CgUQlcqGtF0zbuszK64qp7J61m+BHWFQYVlkv/cWQj85xUIhQj4X4vBHI8jzY22bAMhAAJGIs3zEopqEyvPd9JxwsU5daTsW0DPo7GW6R0OIb8VQMkBi9nRnPdb88V6pBOUyYnn5mlsuXyt2hEFRikDG5dLlPkTJwCoIZCHXESdHKYWo1YlMe9hZgVlRRMZLK/KpHcArlxG1Gqxr8wz6nCgsUx+DXBcvm29d0thCHkfGYojdg1SGYpS7TFIvLcFiprMKb8BIJrSkam8KmSvhzS3glSs7fw9VjoP95Wc5/JWVM1iny5KqVnGrVWIPPbXy2rYvYHOtIpmIIeIxSoe6MSsu1qlRVLHUkWK12D3Ile/v4uC7LvGnez/Ng3/0S/S+ECfwjfYV3kgD7+AwpaEws/cYxEeS9DxhIm+ogt8dcCZuotE5uFqD5Szh8wocF7dQ3CgQtQpGVxpSCea/qx83CMF5xeXP7+f9gV9i6Fsl7MllXeHdamw8DsMDzHxXmuwRRXxEYucUg9+sE5wtwfxS29rWnWXQ642GFy2E9no386KF0MonlqlzsW4Jkc/rWGtQR5Y3Oz6IWJR6b5yFN7oYZUn/k4r4N5dxfWkaBzZ9cEU4RGk4Tvb+Cv/q7i/xG3/7D0ieFQQfO9Vx79GdGSnaDI2SgkBA72ed9BXzYfb3UTsyyNT9IUq7HPZ8QREay+OdennL7wPteFXedgtLxywGvneUS0/tZvBbDuFnLmqt/NVDGvryA70I10Pl8rppu+siu9IAeItLLUnYDWVR+npwU2HM2aymk7bYc3d0pEhIidHbC+kEIpPHKxQ7K05SnnYcIhHqe3oQnsIcndPjW3m4no7VCndFJ2FNj871NSeN9FUjIe1B1TURLiuqnesvqV7TZ9CRlULlRmgQpXyGYuuIV0OIskFNuRqW0c6YobEhdeQH/iVzb6uTesai+6USxomRjsr+3LfdyeLNQf6Xf/oN5uoxHv+jN5I+VWpdMb1K6Fi5rqa6RELQ04XbFcUcX1hprL4ePgVFmOaO6KR0XWaoEOLngZ9EO5Yn0aUQA2yzB7eouyTPF1EyQuJyBWsmg1vroDIHsCczdJHk4599B7Iu2HW2hDW93LpP5zpvVikPVZGITB6z7qDyBb1X+eE+erpQAVtnQS6O45UrqDbebWPZzHzPMapJQSUt6D1eJ/TcJd1DvJ13K0Qz9uuFg4haXbfv6vABupaGsEPAzwI3KaXKQoiHgQ8C72ObPbhVtQZPnSDlnzy2s9S4Fy5hXIC9j/ovSEOXsK8X2t/EwI1ShNXqlsI0EakkxUNd1OIGSkJ6PqP37UobhW3bRqSSzH5vldt2T/BP+p/mVxP/hIOjaUSh2IFBJfR2URqOU02aWCWPyMy8fpiup0FXjQ8JIerocvxp4B3AD/v//nHg1+ikqbrP2FNvOEhpKIxZdLFyNa282U6bqCHydPMw4z9dx6lYkDM59Bdl5MmL7YPgDZrlTQdwIzai6qBKNSIvjBHx+TzuwpK+jjbwKlWYnuXg78bJRYb53cg+Dl5eQo1NbUl/WfkAFzU6SWhukXAgoPfVQrFjvu+1lBNOCiF+GxgDysBX0Uts5qp6cAsJUuIGTWpRCQKkY2GurpZuUDyTiWZ6yssXULUawjRxwgY3DUywUI4wH4rihkwMv6AIAGlg9nZDOKRfq1RXmuVJgReycMImphDIfGVjDlQIhGU3/2yZMG/EjJ85iQEYbD926xWLW4pLbYVrWXJTwAfQpfkZ4FPAA52O39CD23PxSiWMp8+Qek4TkvHUmpsmQ7qBztg/Hsa1wKjB0KN5ePYkztQ0oYVFak/HiasscZXByxVw/fHST59d+Nl97LtnnKVymOWXBzj4Kws6n1l1Ec+dwW5I4KzPbAiBEYvBrn79MDguanyqM77wdxDXsuS+C7islJoHEEJ8Bt2X++p6cPvYqlJZ1R1UqUL8iodngnRAZop6BviFRE3d+vVjXQ9VqZK4AJfkMEYVEhOs8G2FaMrI6UjQxnmlajVkvtTk1XqupyvaEnG8vYNkj8UILTjYy1XE6YsdFezKcBgRi1K6aw/Cg8B8qakH+J2uDx0D3iSECKOX3HcCzwGPsN0e3B1C1Wu48/NEH14xWscx33oNd7lG+mPfJr3+H5ts/eRKi45qdWPyu6ELuAoyGEQN9zH57gQPfPDb/NWpOwiMxNg/ley4gru+u5u5D5dx6gbWiQSDT9oYi8vb7zbMte2hTwshPg28gHZMj6OX0L8FHhJC/Af/tT+92u/YEldDppIGxsG9OD0xakkLK+cgH3+xmUD2ljPNGbo+UyMCAeTBvYx+XxfVLg835nL09/J4Zy5gjM8y9DWDxyfuZe+Cg72cx1tfwd3gSYUCeLEgxkIOZ3Qcb2kZs16n92ONGeordnbggLXCtVZw/1vg3657eds9uLeNVUx0GQogbEtrANbrm+9pfnzWTYYp9Qco9UgCWYNUVxocBzyd19xsRgnTpN4dpnZLiZuGZrgjOc4TD92LoTxd6X18mfhx/V5Fi4yPkKhYGDcepJawCfqlg42+ZoEvzjXH3vAV3AmjW70p/KCuyO5QrKKBxZ+4j8W7XYIzJpEJRc9DJ5rErVZodncwTWq372PmZ6oUs0GMBZuDf5FDnL3Y+qFYVQilLBMsU7d4rulKcFWutC8+smwtFWsYmhV4FUtqAzs6lgvoZU9t3UqxFQJ5RWDeILCs/z9tPkNVq80UlDXfR3E2jpkzsDMCWa3rmdWoNPP7qOG5awuhfBiplO6s5HrNOK05OICKR6j3RjFKDvLcqA4K+DHeraRpZCyG6O/BTUVwIxaBl6c6qlJbjR0xQzvOtrRCJxGhrdBoCtAY6/NzRSCACAb0DW3DEmhchzAMcj9wN8vHJLu/a4wLE70c/t2q3hNXVZa3HG6aiKMHGX9/msqtZd6wa4qF39tL/ORik6y2Gjt/hraDT6LekMtsY8BGFVtlT5LFm2zSZ2uErmTwrozrmdqilaOq1XTw3nEQuwfxuqNMvjWEWYaBb+UxJxdx1mvY+o5V8tQyoYUoi5PD9OcUxtycPsP29OjeL5tsKcp1kbOLDDwVojgaYDyxn74zi7C4vK2H9MYwaKOQxzeocJyOCrkA3SN7V4KFW2zi755hweqnx00QmJpdI4ABrK328ssvvO4oy0eDvO0DL3Ah10N2dohUzYWpaX1NUj9ojeJg98x5zNOKrm+gaSTBADIRh1Qc4ThQLq81aENl09XFWfKxeWJAjKtjB95YS26jXGA7aSs/cyJiMdzuBMZSTitp5goIKZCxGAz2UuuNEBhdQuXyOmnt3xcjHkdEwjh7ehF1Fzkxr7My5TLeW25n+WiQmz58micuHqD7K0G6nprFHbm8MqtW6fStXlmMeBzRnWb5nn4qSUHvs7nmUaYT3PhLLlxd/lGpNbzYNYudNHWhkBCoTRQ23VwOcjmYnlkpZ5QGwrRQpsAzIGrWMEwXZdByT284Q00WX08SHA9Vq+MZoAyhuchbtGJuRJToTuGFLHj20y3fd2PN0OuF1bUobbI6wrS0BkMgoPdE19M8o4YI1ia8XGGaVL7nDjIHLLq+b4LpR3Yx/P98e03CfUuO0+03sXBXnPqDGd41fI7/cufDN9gM9VNaMhLST3K7yrNVMHp6oDfN4l1pnBD0Pp1FLmS1NE4rrGKlC8vG2DVAbShF9mCI5IUy1tQy7vik3id9w63mNLVq0tNQHGuk3JSnCE0UEE6EmW/sovussyV9dMNvWsqRHAkw980Un+++F3i45ft2rEGFZeqZ0J1GFkq+dh8dHR/UYDfLtyRI/tg4h+LzPOXdSep8ADk51d4rDgYoHell7k6Lfe+5zOWv7KP3BZPgwpKWR1WrktxCsKENZuNBDIe10UsrdBXvpbPYL8Gur2zzZiiFMzqOMTrOwKP6pc0KI3esQVWthudq1UtvtbxM24EKcXmSrkyB8kwfpwID9J2d1s7OOmPKWAx1cDdGpoBazmhyWbFE6Pgoe8aSlJ4bYs/Egma7F9cmyYVlc/4/34HZXabrs2ESI0XUc6dAeSjHa5LUNo1Y3XUzM/cn6DpdJTCRxbs0dk2RowZ2rEGbosGui4xGdeM4AFfr9W1VQ9JwZKyxCU2WTibAMJpnwQbHVRgSJ2IhqwHI+7fCc5sdk6wzvhPUylmRgq69y7yxb4xvd91JeNbWN7NDoQsnFqDUr4hNmFhLAV3J/QpgRztFwjSRyQQL7z9M5r1FUIJ6NsCx355HzS60L2SKRBCDfYz8RB9uQP/O3V92CH37vO4fCgjT0rNqM2em0W4LfE7RSpzX6OtFmKYuIazVttVbtCHFrirVbcev4QY9tihPQa1OeM4h/3IUgEABrY9X185Go32G7OvRY7I5HTutVsF1EaUK0Svg2VojKLC0ErgXto3R003lSD/ZfTaJyzVdsX36wsoN9lRTWXN9Vycvk9V1obsHEdUaZHKaEtOBYVW9hpu59iV2PXa0QRuS44EvPcvuL628vPpZFqEQMhohd9cgANHzEYyFZZyZWR1Mn5yi549WwnSrU1syHqdwxxAzP1LhqTf/Hvc+/r9hnUixZzTSlDvdKqAukwlUX5qpd6QJLCuSF+KYF6Y2ZU20xLX2B1+HnW3QDqDKZTzXJXbC71WwnMXzHRgZDuuOTEO9iHIN5he1+KHvfKh8nuipWfr+oo+3PvOLDJx3CM7qYLw52E/lcD8Tb7epDdUZ/JJB7ErJd3z8fTKbQzgOA48ZyEoNsZzT24A0MAf6cHtTZG6KERurYo8vNjUZ1v6ALQx5FZGxG8egjSyI6Ud3anU8Py6qHGdN6UFziG0hwmEq/TqVZTsu0jB0OWBVC0J6l0cJXR4ltGqcEgIVj5DfbbPv/jH+9+FH+JWLH0I6YSLHV1peNTm9i0tr4q7CNFHxCJWBMMvHBBAglY8i5he3t8/6jtI2OmXtbKeoAREIIKMRLn/kKPXDZYKhGs7JBAf+68WtxRwbkZ1kAufwENP3hUGCrMOuv57Am5nbdGzjO+lO44UDGAtZvRrkCx0doRqJdBmPoUplPbbDCrJOcEM6RWvgKcwiVHIWxapBtLjRSdkAP47q5XIY+S7sfAjPFAjXT7vJzTsUNQqJ8avLXN/A4tA+pOdpGufY5KYPRCOR3liChWUibzuGG9a6D+ZcTgfxO0Sz4KlR6LSJ5sYNYdDGzR38Hd3zp9HUze1wb1HVKurEy3SfWlFZcRuqIh1CmCbe3gEuf38cJdDyNJ9QcOFS27EyEkamk5z9uRBH90zjKcHo1/aw6zc6NKgQOgXX5TeoUgrOt37rDWHQJnwDbmdPAVZSWH4QHc/TwfQODGp0d0E6ydT39FGPglGB8Iwi6qt7bgUZDCJ7usneO8TSUQMKLi+fHCZ20aDvdAd7aYNeGtZdMES+iHLcLW/AjWXQq9WdFRJhW8hEXBdG1Wt4uQ6LhVMJKruTBN87h3QMnEe7SJ2vYDxxErdNMECEQjgDKWbfKHnjW87y/CNHtYbSwy92plMkNKFMRMI6FJrNtU1S3DgGlQbirpsoDYZYvMkkPKPo/brmtbZl20mBOryXsXcmKN1WpqcrT/APDhMeWcY9N7LlWDU+RXA5C7+zl2BAIpwa1kwez29/uZWT42ZzyLNXOPSxPhY+u5sD87OIQgmn0xZYnouqebgLS1tGs1ZjZxjU75gEbOlBeqbEswRuSOEGAEMiBvswTEN/RqWGOzbR+ocbAmVCIFSnN1Jg2e5ChWzMgf7mW9yl5Q2qn16lAtUqwRf1jPNSUUShQ0m3Ro+Zc3kEVy84tZ2g/Y44tiRCA+q+/T+ul9S5xTUUkDVolP1ZZjMvOfEr99H1tmnCVo1zVwa46d/N4i1lNsZ5fdnypuR4sYzcu4ux7+/HMwEBez63pAt7N5vx6xLhwjSby/93uqL7qo8tQoiPAQ8Cc0qpN/ivpWnRZ1sIIdBtnN+Hbo7xIaXUC22vznUROX0TleMgQyHq9xylmrKoJCWJy1XsFy8221atfmLTL7ssGAMoE5LzoCpVxEAv6pb91OM2wvEIPjeCV66sBAIayORJne/R1BFALhf0vthoHuCTt5oP1zp5Nu1UNfQYtuupXR90suT+D+D3gU+seu1XaN1n+73AIf+/e9GFvve2+wJVd5q0SGHZyESMsQcCyP0F3rXvPF/9xp0cnOzSHQHXOSLhv36a8F/7fwiBZ9vUbtvNzBttyrscRM3i6Fg3cn5pg3KmOz9P+K9X4q6O/xkNdiGGoduMbOb8vIoaC5uhrUGVUt8UQuxd9/IHgLf5///jwKNog34A+ITfk/spIUSy0Ry20wtSTh0vm2f/p/PU4wFeStzO/vE8amq2fVNXn1MbOjHOntm0rsb2FGp6TvcY2wz+Um50p3X1WT7vhxYrbWeeDAbh6H7m706QfUeZ0PNhEpdcYt84q1N07ZyY/j687hQT701jlqD7RBn7yvzmnaTa4Gqdos36bA8Bq3mIjQruDQbdtAd3wwl47hSmf4Eti382g1KapT4zq2eZkCjDaGsYYUgIBVGmAaUSwgbDNBGRMJgm3tJy63oUw8BJBCjuEvzwzc/yPxffglWQxCNhpFK6kKpS3bzeJhjATQQp7nUxCpLolI01G9j4vg5xzV6uUkoJsZlqz5bj1lZwXwcYiTgiEsEd7EIWKlp7vtWN9cvovSvjKw3TbzvC9HcniH7PDG/tG+HrH72f1MtFePrkWi+4VMJ46gz7TkV47uMHOVq6DJ6idnQXheEA83dB93FIP7+Iujy+IVTojE0ip2c5ej6ujyalcrMPWqP8v63GxCpcrUE367M9CQyvet+2K7ivCdJABgNNMalGVkYWqzopvll0qKFfdMsR6qkg1ZSJExRYBcXU5W4+k4vQt+hi5Ksbjx7+Mo8XRlkmaqAbzzYQnsLOeYQnTYJLdUS5itfKKJ6LqmrW/EZO76qamw5xtQb9HK37bH8O+IgQ4iG0M5Tdzv55rZC2hezv1UW1QRN5ZRpveRnVJuEsTAsZCTHyj+KEjmX44QPP8UfPvpVjv52j99PzuMvLwObnSGFaeAeGmLkvTrlPoQw4+D8XMc+MEvyCHtuOYNI8AknRPItfl74tQoi/RDtA3UKICXSB72/Sus/2F9FHlhH0seXHO7kIISXizpuZeHeCelShTDjwlxnE2EzzZm5xgTpOe2Q/bjxAOWkTWKhgTi3hFUudae66Ll65wvDXapRfTPDJ9LvYPeHC7AJeoX0pn3LqGONz9CuFEwuAQI/tVFPevwZwV865V4lOvNwf2uSfNiQwfe/2n2/7KqSksDdK4m0zHE7OEzMrnPjm7UQWw9DGoDIaRUYjFPbGqcUkbkBgZw0dEqy133uEZeu9q+5gPvKCLhTyx3R8KFGqyRT0j7Tbjwo1z7rXdhTaEaE/Jx7AMwXW73czkU9g5GqEL5/XgkttcOHf3swH3/UEn/zqPuIj0P+3o35NZ/t4qdnfx9Lb9xGerROYzGqZmm3MKmAj0fpVxo4wqFAQyDiELi3B/CJuJovbEEv0pVQ3VZyuCSYrSaysIJjxcBcWkdEI5t7duN06d2lcmNCMgXUeplIK6Sik6zUTx8I0MXq6UdEwXiKMMb2Et5zp6AFZ+UFi+xmhVwg7IpYbF2l1r3zXmhsmYzFEwEbEoqhCSTs3LYLuDRrnaoPX33ob0/cFGHr7OCGzTv7/2UXo8nLrzkqNCm6ltEpKV5q57ztI7iB03T5H/TO99D65hDdypSM+UMPDlqEgyvU6k4m9Cux8Csq6H60q1WZ6qqlj2+LGbCApC0FgPENvIM1ccRglYdeVOVjepGdoo3uvaSD8tiDpl8uElgLkp/roPVNCLGZay5L7taeVuw9STVuUuwQ9zxcwRme11pHjbG7MRhHzHUep9IUpDJkElzzij42gCsWrVijbOQZdh2YQfrt7mlK45y8SOH+R/i/pm9aOqiIsv3dZMAiAfPoUYU8R8YPzm8mKC9NCJBNMvzlAZU+NWw5OMFXbR+9yEbWU2Trt5beWXLolzvJRGLpzmtFLvcTPpBFKbewv0yF2zpK7nvXnP8EyGNBCUNuJlvT34Q51M/nOBPUI7Hq0gj2V2zyZ3ZgthoGMRqjesZ/52wME3zlP+bEeuk7XCX3z5Y0pOV/qRuzZhRcO4MZt7PFlVC6PiEag7mgBqs0UxYTAHBpExSM4qTBGoQoXRjtSINv5S24L6Cbmuh1js+WjEBjJJCIaweuKIyZmN/ZJM028gEktoajHPJyQgWXpn9rc4/xyPzeXa6bFlOeinABuUFKPw309Ezya6KYeloQNudGjbejt+g+KBNyG5nw8prtErXaQ1kOpZs2qwO/Rdq33bMfO0FbwjTn3g0dZvMfhi+/+KB/86C/S/5+f3PC+ZrMBKddoyZtDg3hdcebvSRHIKaKfenqjo9UwSiiIKld8tc7qms8Htl4xXuESh/W4IWfoBvhx09hYnXrY5gdSP03XlRb7Y6MU0dHN6mQ4jEA7PMpxkLkSsfEoZrH1sqbqurReui7uXUcpDQSQjiKwWMd89myzzHErCNPC6E5TvnkI4YF0PaxTo7o5e6chvYYAFnTcguvGMihaHNj+ynP0fwXNjdgKDeZ8eoXP6i1ncGfnsK+MbTlU2hYylWTke0PsfeMES6UQU+fSHH45Br7e0FbfK6MRqkcHufyPJTgCo2RxKNOHqGyRMF9/DcHAykzvUEpuxxnU6OmBVJzlu3oQHiRfmIPlbEf9RI2uNOW79zN3l426M0f4KzGSI1Xki5eb5K+tkuQyElkpbqrUIZtn7xfKVJ8aIFZXdC2XV9pUbgWlW1QGzk5y4C+GEJ5COErHpsude69epdoklV93ifLrBREM4CbC5PdIhAvxi2GMcoek5GCQYr9F9eYyv3/7p/jZCx8mkLWx1mvfbvYRlokIBql2hbFyVeRSFuPZs4RW7Z+d7oiqXsOZmcWYndNHIttG1eu6onwb0SNhmhippCZYO06TV7Xp+3ecU9SoA4lFm096x/oK0sCIRhDxGCoegcWMThh30nYSVo5KtqWFJFd/7zZ7ZMMKP6r4pgMsHzGJjXsEF+pYT5xq3yReCIyD+8jd2sOtv/ISxxeGmD3fw8FPljFeOMdXy392gzhFjYTvNsruVo91cznI53VafZsPq4xGEeEQ3q4eZKEKc4ttZ0RzbCyG7EpRPthDPWYSO7OIKJZRxRJWwSGwZGDlXcxCrWVNTSOEKSJh7ZXX6oi6g513+eb4AYoLYUJzEqNUZ6tJuPMMeq1Y06/a6XxGCQH7higNxxh9UBAeTzD0WBRzZEqnxrZaIfyxs/em2P9j5/nJ/m/yC3/yU3Sdcgh+8XmMx46TfnTlGjaKI2snSiQT1Ia7sGZziPklnLFJrCtjDH1thcnQkvWwCq8Ng64+8KtV/arbGNNIpajeuR8zX8PIlhG5EuHzNYa/3E0gU8YancfLF1p/pWky8S/vodKtSL4MoSWPrpcKXPyfh/mF1BEGnihjzWQ3DTsafb14w73IbAlRquD58nW26+lYbqn0HaWg7Bw0C5hWCpmEH1lSLlsmjEU8ytKxAMFFi8iMhX1mAm86S2RyRsdwt9q7DYOh94zxQ0PP8O/S30f6GYvoly7Q84LTPDNuuesn4+QORIlMWZhZG7WwqBn7ma0r2tph5zlFvmGE6QcCOq3r8KNItdv3kd0XIL8Xdj1SJXB5AWdssnWvT8vG6E43S/Sy7zhEdr9k/3svcfLMbg4+VMc+N9VavFiIZgGvuVhEVGuoQhHSSZRtIcammkrWLS83EEDGon41XH3b1d03VqRos9jnFpDRKCIZp9xtUY8KlNH+5jSPFr090N3N0lFJZV+VgVCWk1b76nDvxTMIIVChEMSi2phBayN7r9XwRoX4K4ydaVDloerbOKtZNt6xvZR7gpT6DJIjdYb+ahJvcQlnqyffL3tYfsd+Zt7u8gv3/y11ZfCZX3s3Ry/k8E6ex2lzXJKhEOrIPqpdQUp9FqmXMoiJqY5Y89cDO8+gndyE1cVEnnaCzLksslTHLIWxZ/JaTGM9Sczv21LvjVHpDWDlHOzHThK/WMQNRPm9pfeBBwdeXkbML61dpn2pmvzdu6ikDOpRweDnx3GnZjEWsgQrNaxCCLmY0dGgFr9DBoNgWZpNX65sn7/UAXaeQTuAMIxmu4xGMZHjx2Y3bR4ndE/t/M3dLB8xKB6uEZiw2fN3uvFc6hnwI74t01gyGKC+u4fx98Lwvhne2nOFF0/ejhwdx1nVbWnToKAQiGgEEQyiwkFkrvC6QQH/iKIVL1VD8rsdpIE52E/5pgHKaYmswZ6/EgRn823DcMKykckEoz91iNL+Gu+/7SX+9vnbKD/UT+/IaPumOX4rTJJx3EQI4SnkZe0wXQ/cWAYVDSGm9mfMDbAt6hED6YCdVUROTOuzXyCg02vBgI4KrRdhlAJhW1R6PELJCmXXIjRu0vP4DKpSwehKQ3daZ1GWsy27MwnTxAtaKMtA1FxUsdRM7QnTWmHLb/c3tbpFO+7YcjVoKEjD5jFSuSJpAzqTYUQjuEf3MHd3jMwbHAYfEcQuFeClcxuIZ0YiDn54ziuWUJUq1XfextIxix//yS/y8ZE3Yf5Nip4n5nAvXFp7Dat6f+vVxdEzPxSEXf14IQs5NocqlTpuuvNKV3D/v8D3AjW0uPKPK6Uy/r/9KrpNswv8rFJqu/rNGyBjMWQ8Ru1gH27AIHRuFpUrrC2T2CThLCwbY3iQ+kCS5YMhEhfL2JPLqIlplONgZMvEpkJ4tkl4rozMlXXv0JUboI3hKVS1pvto+98VWCgTnZD83vG3Y14JMjjt6PZZ6x+oVlLkvmFlsYysO+Crh14r2s5QIcR3AwV0IW/DoO8B/k4p5Qghfktfs/plIcRNwF+im9kNAl8HDiu1Nb+/3Qw1Du6jdKib0Q8IAukyPQ+FiV7K4714pu0PNJIJlt97jNk3wX953yf4uS//KP1PCJJfOde+bgY/ABAIwECvJnxPz11z37JXAlc9Q1tVcCulvrrqz6fQ/UJBV3A/pJSqApeFECNo4357W1frt2Z0exMs3B4nmPUIzdbY/QULoYJEzsygcpunxIyD+ygf6GLsARMvWSf1jCB9Cv7dmR9j//kq9vjy5kVIPmVFxmN4PUnkUh5VLMHcYpNb1EkB1KuFV8Ip+jBaQAN0tfZTq/6t8x7ca/5RajXLvjDZw6AuSaJX6kROXsLNZLf2LIXAS0bI77L47vtOcUt0kk+88ACp81XMv3uhfYxVSEQwgIpFqHVHCJRrUC7jLmc3hA9lOKyPTr4m/rbkZ3xnDL/ThA7GX7s/c00GFUL8a/TR68+3O3bLCm7PxRu5QmjM5vBLMVSlgiqWOguVKYU4NULvxRCzT/YzYwwxOHNOH+TX3zBfshXP0wntWk3nVJeziFwBe3IGr1ZvKVkjTJPJ/+12yn2K4Jwgfc4h9NWX2ieufeQ/cAe1/3WJhekE9pzJwT8ax52b35b8aitcS1P1D6GdpXeqlY34FavgXqNmuU005Wva1pbKpjHXJJ09n6O7esY1luK+Ht2FyTCQNbCyAjuvMEtbiEH6Hja3HMKJ2igpKPVIsgsxzCUTOyuaTWk3vdSGV9zAJkmZqzKoEOIB4JeAtyqlVoc7Pgf8hRDid9BO0SHgmav5juuG1dRIT3VcQ6IZ8kOMP9CN8u/a7k9P4Vwe1X8otSnfSIaCyHSKl3/O4o37rhAzq0x89VYOffhFf6yH00bZ2uhO4w52rUjCbnJXr7aC+1eBAPA1rTXFU0qpf6aUOi2EeBg4g16K/3k7D/c7DuVtq6ZWRiKIYABhWahanb7ny6hGgGNpedPlVQaDiH3DzLytGycscAMQOgmnXzqKrMPg2drmuVZf9ax+303UEiauJQjN1wmMLUHdWdHMbYGrreDetFG6UurXgV9v97mvGrbjeDTir+EQypCISg35rRPNiM6mz4UQukPT3iS8d4mecBlLulR+e5DIiSnc+YUtqaDCMBChEPO3Bin3KdygouulAN2n8itVbZuNfU1Eiq4jGrUwwtDlhiKZ0OUVUqAmpjdfsqWBkUrg7R3ADVk4UYvxd5q43TWMgEvs8TC9f/hk67E++9AcGkCFAqigRXkoRn63iWcKlISTv/sLN1CC+5WCHxI0err1347Tcbl+I85q7BrAi4cRdRdcD7XFcrcGvrcsiyWsUAg7Eka+bTfK8ggG63j2FmP94ilnfKJZ4RYIHya7z8KzaGoTtsKNYdCGl+gH5TsuJYhGEf09XPrhflAQyED/E1nEqZG2xwMZjSJ7ujjzi7285+6TPDO9h+LZLg7+9nlN4mpHGZEGRiKO2jMAdRdVq3Pw/z2nM0Se/g0drY2NCrdnTtP3vNFsqXV6k7ffGAZVqyTFtyP5Uq9DrkDXab3bWQUPYzGv9eY3gxBNZRUVtEmeMnkkdzuBRUHXpFb6almZ7cd81Z3HKA2FKQwaWAVF+kROd13KF/Fyhc2DD34CQO0dwkkEcIIG4ZfGV7pe+EepdrhBDNp5n83VaJxHI5+ea77WXgDKQqaTqHAQL2wz+JmLuIvLTUNs9jjpPdZm8rtjVO4s8dO3fouHr9wFJyzIFzW3d6vvNQzo7Wbu3gTFIaglPQ5l+zAuetuq5t4+G+s1DuXU8RaWYH4JYyGHqlQ66hyoXBevUqXv+QrxR0M8tnCYSt0keyyG6ku3JY4p10Xki8QmHOpxxeE3TDDzpijFe/dpLaUOiGfwukE3QilNvyyVUcVy+94wq8bhudiTWeKjdeaKUVxXUklKvLDdnsmoFKpex8o5eAGPW5JTlPsU5W6fbtMhdsSxRQgxDxSBhVf7WjpEN6/+te5RSvWsf3FHGBRACPFcq3PVTsROvtbXl9zXGF436GsMO8mgf/xqX8A2sGOvdcfsoa/jlcFOmqGv4xXA6wZ9jWFHGFQI8YAQ4pwQYsRv7LMjIIQYFkI8IoQ4I4Q4LYT4F/7rvyaEmBRCvOj/975X+1obeNX3UCGEgW5v+m40S/BZ4IeUUu1Jt9cZfseLAaXUC0KIGPA88A/QGvsFpdRvv5rX1wo7YYbeA4wopS4ppWrAQ2h+76sOpdR0o3ebUioPnGUTWupOwU4w6GbdmHYUfLL5HcDT/ksfEUKcEEJ8TAiR2nzkdxY7waA7HkKIKPBXwM8ppXLoJn0HgNvRbcD+06t3dWuxEwz66nZjagMhhIU25p8rpT4DoJSaVUq5SikP+O/obWNHYCcY9FngkBBinxDCBj6I5ve+6vD7of4pcFYp9TurXh9Y9bZ/CJz6Tl/bZnjVGQt+BdtHgK+gK+o/ppTajDLzncb9wI8CJ4UQL/qv/Svgh4QQt6NFwa4A//TVuLhWeNWPLa/jlcVOWHJfxyuI1w36GsPrBn2N4XWDvsbwukFfY3jdoK8xvG7Q1xj+f72x36eOwUg5AAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "C = iem_obj._define_trial_activations(trn_conds)\n",
+    "plt.imshow(C)\n",
+    "print(C.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Whenever you run the fit() function, the trial-wise channel activations will be created automatically, and the GLM will be fit on the training data and feature labels. Using this, we can then predict the feature responses on a set of test data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 79,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "iem_obj = iem_obj.fit(trn, trn_conds)\n",
+    "stim_reconstructions = iem_obj.predict_feature_responses(tst)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Average feature reconstructions across trials\n",
+    "\n",
+    "In this experiment, we are not specifically interested in separating trials by whether stimuli were on the left or the right. Instead, we're interested in how the activation in the model-based reconstruction varies with the experimental manipulation of contrast and attended location. For the sake of visualization and quantification, we can simply average across the trials of interest. Below we separated the trials by contrast and attention location, but averaged across trials where the stimulus appeared on the left side of the screen and the target was not present (to ensure that overall contrast is identical across averaged trials)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vmin, vmax = 0, 0\n",
+    "mean_recons = np.zeros((stim_contrasts.size, attn_conds.size, npixels))\n",
+    "\n",
+    "for aa, attn_cond in enumerate(attn_conds):\n",
+    "    for ss, contrast in enumerate(stim_contrasts):\n",
+    "        thisidx = np.argwhere((tst_conds[:, 0] == 1) &\n",
+    "                              (tst_conds[:, 1] == contrast) &\n",
+    "                              (tst_conds[:, 2] == attn_cond) &\n",
+    "                              (tst_conds[:, 3] == 0))\n",
+    "        rs = np.mean(stim_reconstructions[:, thisidx], axis=1)\n",
+    "        if rs.min() < vmin:\n",
+    "            vmin = rs.min()\n",
+    "        if rs.max() > vmax:\n",
+    "            vmax = rs.max()\n",
+    "        mean_recons[ss, aa, :] = rs.squeeze()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finally, we plot the data as a function of:\n",
+    " \n",
+    "1) whether subjects were attending to the stimulus or fixation, and\n",
+    "2) the contrast of the stimulus (across six levels)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x1152 with 12 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "f, ax = plt.subplots(6, 2, figsize=(10,16))\n",
+    "for aa, attn_cond in enumerate(attn_conds):\n",
+    "    for ss, contrast in enumerate(stim_contrasts):\n",
+    "        ax[ss, aa].imshow(mean_recons[ss, aa, :].\\\n",
+    "                          reshape(stim_res[1], stim_res[0]),\n",
+    "                          origin='lower', interpolation='none',\n",
+    "                          cmap='inferno',\n",
+    "                          extent=[stimx[0], stimx[1], stimy[0], stimy[1]],\n",
+    "                          vmin=vmin, vmax=vmax)\n",
+    "        if contrast == stim_contrasts[0]:\n",
+    "            if attn_cond == 1:\n",
+    "                ax[ss, aa].set_title('Attend fixation')\n",
+    "            elif attn_cond == 2:\n",
+    "                ax[ss, aa].set_title('Attend stimulus')\n",
+    "        if attn_cond == 1:\n",
+    "            ax[ss, aa].set_ylabel('Contrast value {}'.format(contrast))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "These data suggest that increasing the contrast leads to stronger activation of the stimulus. They also suggest that the effect of attention is greatest at low contrast levels -- e.g. at contrast level 3, we see a clear enhancement when the participant is attending to the stimulus compared to when they are attending fixation.\n",
+    "\n",
+    "However, since this is single-participant data, these effects should be quantified across a group of subjects.\n",
+    "\n",
+    "Full results from these manipulations across a group of subjects can be seen in Itthipuripat, Sprague, Serences 2019."
+   ]
+  }
+ ],
+ "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.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/reconstruct/iem_example_synthetic_RF_data.ipynb b/examples/reconstruct/iem_example_synthetic_RF_data.ipynb
index 95c43f09c..4c7236207 100644
--- a/examples/reconstruct/iem_example_synthetic_RF_data.ipynb
+++ b/examples/reconstruct/iem_example_synthetic_RF_data.ipynb
@@ -33,13 +33,13 @@
     "\n",
     "range_stop = 360\n",
     "feature_resolution = 360\n",
-    "iem_obj = IEM.InvertedEncoding(n_channels, cos_exponent, stimulus_mode='circular', range_start=range_start, \n",
+    "iem_obj = IEM.InvertedEncoding1D(n_channels, cos_exponent, stimulus_mode='circular', range_start=range_start, \n",
     "                               range_stop=range_stop, channel_density=feature_resolution)\n",
     "\n",
     "# You can also try the half-circular space. Here's the associated code:\n",
     "# range_stop = 180  # since 0 and 360 degrees are the same, we want to stop shy of 360\n",
     "# feature_resolution = 180\n",
-    "# iem_obj = IEM.InvertedEncoding(n_channels, cos_exponent, stimulus_mode='halfcircular', range_start=range_start, \n",
+    "# iem_obj = IEM.InvertedEncoding1D(n_channels, cos_exponent, stimulus_mode='halfcircular', range_start=range_start, \n",
     "#                                range_stop=range_stop, channel_density=feature_resolution, verbose=True)\n",
     "\n",
     "stim_vals = np.linspace(0, feature_resolution - (feature_resolution/6), 6).astype(int)"
@@ -204,7 +204,7 @@
     {
      "data": {
       "text/plain": [
-       "InvertedEncoding(channel_exp=5, n_channels=6, range_start=0, range_stop=360)"
+       "InvertedEncoding1D(channel_exp=5, n_channels=6, range_start=0, range_stop=360)"
       ]
      },
      "execution_count": 5,
diff --git a/tests/reconstruct/test_iem.py b/tests/reconstruct/test_iem.py
index 4370dc827..eb4ec6e3a 100644
--- a/tests/reconstruct/test_iem.py
+++ b/tests/reconstruct/test_iem.py
@@ -11,11 +11,18 @@
 #  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
+#
+# Copyright 2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# Authors: David Huberdeau (Yale University) &
+# Peter Kok (Yale University), 2018 &
+# Vy Vo (Intel Corp., UCSD), 2019
 
 import pytest
 import numpy as np
 import logging
-from brainiak.reconstruct.iem import InvertedEncoding
+from brainiak.reconstruct.iem import InvertedEncoding1D, InvertedEncoding2D
 from brainiak.utils.fmrisim import generate_1d_gaussian_rfs, \
     generate_1d_rf_responses
 from scipy.stats import circmean
@@ -25,67 +32,369 @@
 
 # Simple test: can an instance be instantiated?
 def test_can_instantiate():
-    s = InvertedEncoding()
-    assert s, "Invalid InvertedEncoding instance"
+    s = InvertedEncoding1D()
+    assert s, "Invalid InvertedEncoding1D instance"
+    s2 = InvertedEncoding2D(stim_xlim=[0, 1], stim_ylim=[0, 1],
+                            stimulus_resolution=[1, 1])
+    assert s2, "Invalid InvertedEncoding2D instance"
 
 
-# Simple test for checking range values.
+# Test for checking range values.
 def test_instantiate_improper_range():
     with pytest.raises(ValueError):
-        s = InvertedEncoding(6, 5, 'halfcircular', range_start=20,
-                             range_stop=0)
-        assert s, "Invalid InvertedEncoding instance"
+        s = InvertedEncoding1D(6, 5, 'halfcircular', range_start=20,
+                               range_stop=0)
+        assert s, "Invalid InvertedEncoding1D instance"
+    with pytest.raises(ValueError):
+        s2 = InvertedEncoding2D(stim_xlim=[0, -1], stim_ylim=[0, -1],
+                                stimulus_resolution=[10, 10])
+        assert s2, "Invalid InvertedEncoding2D instance"
+    with pytest.raises(ValueError):
+        s2 = InvertedEncoding2D(stim_xlim=[0], stim_ylim=[-1, 0],
+                                stimulus_resolution=10)
+        assert s2, "Invalid InvertedEncoding2D instance"
+
+
+# Test for n_observations < n_channels
+def test_data_amount():
+    x = np.random.rand(5, 1000)
+    s = InvertedEncoding1D()
+    with pytest.raises(ValueError):
+        s.fit(x, np.random.rand(5))
+        assert s, "Invalid data"
+    s2 = InvertedEncoding2D(stim_xlim=[-1, 1], stim_ylim=[-1, 1],
+                            stimulus_resolution=10)
+    with pytest.raises(ValueError):
+        s2.fit(x, np.random.rand(5))
+
 
+# Test number of data dimensions
+def test_data_dimensions():
+    x = np.random.rand(5, 10, 2)
+    s = InvertedEncoding1D()
+    with pytest.raises(ValueError):
+        s.fit(x, np.random.rand(5))
+    s2 = InvertedEncoding2D(stim_xlim=[-1, 1], stim_ylim=[-1, 1],
+                            stimulus_resolution=10)
+    with pytest.raises(ValueError):
+        s2.fit(x, np.random.rand(5))
+
+
+# TESTS FOR 2D MODEL #
+# Test to check that stimulus resolution is used properly
+def test_2d_stimulus_resolution():
+    s2 = InvertedEncoding2D(stim_xlim=[-1, 1], stim_ylim=[-1, 1],
+                            stimulus_resolution=10)
+    assert len(s2.stim_pixels[0] == 10)
+    assert len(s2.stim_pixels[1] == 10)
+    s2 = InvertedEncoding2D(stim_xlim=[-1, 1], stim_ylim=[-2, 2],
+                            stimulus_resolution=[10, 20])
+    assert len(s2.stim_pixels[0] == 10)
+    assert len(s2.stim_pixels[1] == 20)
+
+
+# Test that 2D channels can be set by the user
+def test_2d_custom_channels():
+    nchan = 8
+    res = 10
+    npix = res*res
+    channels = np.random.rand(nchan, npix)*2 - 1
+    bds = [-1, 1]
+    s = InvertedEncoding2D(stim_xlim=bds, stim_ylim=bds,
+                           stimulus_resolution=res, chan_xlim=bds,
+                           chan_ylim=bds, channels=channels)
+    assert s, "Unable to define custom InvertedEncoding2D channels"
+
+
+# Test that channel definition should be consistent.
+def test_cannot_instantiate_2d_channels():
+    # Channel definition over wrong number of pixels (5 instead of 100)
+    with pytest.raises(ValueError):
+        s = InvertedEncoding2D(stim_xlim=[-1, 1], stim_ylim=[-1, 1],
+                               stimulus_resolution=10,
+                               channels=np.random.rand(5, 5))
+        assert s, "Invalid InvertedEncoding2D instance"
+
+
+# Test that you cannot modify properties in an inconsistent way.
+def test_modify_2d_properties():
+    nchan = 8
+    res = 10
+    npix = res*res
+    channels = np.random.rand(nchan, npix)*2 - 1
+    bds = [-1, 1]
+    s = InvertedEncoding2D(stim_xlim=bds, stim_ylim=bds,
+                           stimulus_resolution=res, chan_xlim=bds,
+                           chan_ylim=bds, channels=channels)
+    with pytest.raises(ValueError):
+        s = s.set_params(n_channels=nchan - 1)
+        assert s, "Invalid InvertedEncoding2D instance"
+    with pytest.raises(ValueError):
+        s = s.set_params(xp=np.random.rand(npix - 10))
+        assert s, "Invalid InvertedEncoding2D instance"
+    with pytest.raises(ValueError):
+        s = s.set_params(stim_fov=[[0, 1], [0, -1]])
+        assert s, "Invalid InvertedEncoding2D instance"
+    with pytest.raises(ValueError):
+        s = s.set_params(stim_fov=[[0, 1]])
+        assert s, "Invalid InvertedEncoding2D instance"
+    with pytest.raises(ValueError):
+        s = s.set_params(stim_fov=[[0], [0, 1]])
+        assert s, "Invalid InvertedEncoding2D instance"
+
+
+# Test that you can get object properties
+def test_get_2d_params():
+    bds = [-1, 1]
+    res = 10
+    s = InvertedEncoding2D(stim_xlim=bds, stim_ylim=bds,
+                           stimulus_resolution=res)
+    param_out = s.get_params()
+    assert np.all(param_out.get('stim_fov')[0] == bds)
+    assert param_out.get('xp').size == res*res
+
+
+# Test helper function to create 2D cosine
+def test_2d_cos():
+    nchan = 8
+    res = 10
+    npix = res*res
+    bds = [-1, 1]
+    sz = 2
+    s = InvertedEncoding2D(stim_xlim=bds, stim_ylim=bds,
+                           stimulus_resolution=res,
+                           channels=np.random.rand(nchan, npix))
+    sz = s._2d_cosine_fwhm_to_sz(1)
+    fcn = s._make_2d_cosine(s.xp.reshape(-1, 1), s.yp.reshape(-1, 1),
+                            np.linspace(bds[0], bds[1], nchan),
+                            np.linspace(bds[0], bds[1], nchan), sz)
+    assert fcn.shape == (nchan, npix)
+    # Test that masking works -- basis function should have fewer non-zero
+    # elements than specified by the size constant
+    xd = np.diff(s.xp)[0][0]
+    nval = (np.nonzero(fcn[0, :])[0]).size
+    assert nval*(xd**2) <= sz**2
+
+
+# Test size conversion functions
+def test_2d_cos_size_fcns():
+    bds = [-1, 1]
+    s = np.random.rand()
+    imodel = InvertedEncoding2D(stim_xlim=bds, stim_ylim=bds,
+                                stimulus_resolution=10)
+    fwhm = imodel._2d_cosine_sz_to_fwhm(s)
+    s2 = imodel._2d_cosine_fwhm_to_sz(fwhm)
+    assert np.isclose(s, s2)
+    fwhm2 = imodel._2d_cosine_sz_to_fwhm(s2)
+    assert np.isclose(fwhm, fwhm2)
+
+
+def test_square_basis_grid():
+    nchan = 8
+    bds = [-1, 1]
+    s = InvertedEncoding2D(stim_xlim=bds, stim_ylim=bds,
+                           stimulus_resolution=10)
+    _, centers = s.define_basis_functions_sqgrid(nchannels=nchan)
+    assert centers.shape[0] == nchan*nchan
+    xspacing = np.round(np.diff(centers[:, 0]), 5)
+    yspacing = np.round(np.diff(centers[:, 1]), 5)
+    assert xspacing[0] == xspacing[28] == xspacing[-1]
+    assert yspacing[0] == yspacing[25] == yspacing[-1]
+
+
+def test_triangular_basis_grid():
+    grid_rad = 3
+    n_channels = (grid_rad*2 + 1) * (grid_rad*2)
+    bds = [-1, 1]
+    s = InvertedEncoding2D(stim_xlim=bds, stim_ylim=bds,
+                           stimulus_resolution=10)
+    _, centers = s.define_basis_functions_trigrid(grid_rad)
+    assert centers.shape[0] == n_channels
+    xspacing = np.round(np.diff(centers[:, 0]), 4)
+    assert xspacing[0] == xspacing[np.random.randint(n_channels)] == \
+        xspacing[-1]
+    ysp = xspacing[0] * np.sqrt(3) * 0.5
+    yspacing = np.diff(centers[:, 1])
+    yspace = yspacing[yspacing > 0.0]
+    assert np.all((ysp - yspace) < 1e-5)
+
+
+# Define some data to use in the following tests.
+nobs, nvox, ntest = 100, 1000, 5
+xlim, ylim = [[-6, 6], [-3, 3]]
+res = [100, 100]
+sxx, syy = np.meshgrid(np.linspace(xlim[0], xlim[1], 10),
+                       np.linspace(ylim[0], ylim[1], 10))
+yd = np.hstack((sxx.reshape(-1, 1), syy.reshape(-1, 1)))
+Xd = np.zeros((nobs, nvox))
+for i, l in enumerate(np.linspace(-1, 1, 10)):
+    Xd[i*10:i*10+10, :] = np.random.normal(loc=l, scale=1.5,
+                                           size=(10, nvox))
+X2d = np.zeros((ntest, nvox))
+for i, l in enumerate(np.linspace(-1, 1, 5)):
+    X2d[i, :] = np.random.normal(loc=l, scale=1.5,
+                                 size=(1, nvox))
+
+
+# Test that 2D model raises error if design matrix C cannot be defined
+def test_fit_invalid_2d():
+    # C=None and stim_radius=None here, cannot define C
+    i2 = InvertedEncoding2D(stim_xlim=xlim, stim_ylim=ylim,
+                            stimulus_resolution=res, stim_radius=None)
+    i2.define_basis_functions_sqgrid(nchannels=[12, 6])
+    with pytest.raises(ValueError):
+        i2.fit(Xd, yd)
+
+
+# Test attempt to fit with list of varying stimulus radii
+def test_fit_2d_radius_list():
+    i2 = InvertedEncoding2D(stim_xlim=xlim, stim_ylim=ylim,
+                            stimulus_resolution=res,
+                            stim_radius=np.random.rand(nobs))
+    i2.define_basis_functions_sqgrid(nchannels=[12, 6])
+    i2.fit(Xd, yd)
+
+
+# Test with custom C input
+def test_fit_custom_channel_activations():
+    i2 = InvertedEncoding2D(stim_xlim=xlim, stim_ylim=ylim,
+                            stimulus_resolution=res,
+                            stim_radius=12)
+    i2.define_basis_functions_sqgrid(nchannels=[12, 6])
+    # Define C by expanding y & adding noise to avoid singular W matrix error
+    C0 = np.repeat(np.expand_dims(yd[:, 0], 1), 12*3, axis=1) + \
+        np.random.rand(nobs, 12*3)
+    C1 = np.repeat(np.expand_dims(yd[:, 1], 1), 12*3, axis=1) + \
+        np.random.rand(nobs, 12*3)
+    i2.fit(Xd, yd, np.hstack((C0, C1)))
+    assert np.all(i2.W_)
+
+
+iem_2d = InvertedEncoding2D(stim_xlim=xlim, stim_ylim=ylim,
+                            stimulus_resolution=res, stim_radius=12)
+iem_2d.define_basis_functions_sqgrid(nchannels=[12, 6])
+
+
+# Test if valid data can be fit.
+def test_can_fit_2d_data():
+    iem_2d.fit(Xd, yd)
+
+
+# Show that a data matrix with improper format (dimensions) breaks the
+# algorithm.
+def test_cannot_fit_2d_data():
+    with pytest.raises(ValueError):
+        iem_2d.fit(Xd.transpose(), yd)
 
+
+# Ill conditioned data matrix will raise error
+def test_ill_conditioned_2d_train_data():
+    with pytest.raises(ValueError):
+        Xt = np.ones((nobs, nvox))
+        y = np.random.rand(nobs, 2)
+        iem_2d.fit(Xt, y)
+
+
+# Ill conditioned channel activations C will raise warning
+def test_ill_conditioned_2d_channel_activations():
+    with pytest.warns(RuntimeWarning):
+        C = iem_2d._define_trial_activations(np.ones((nobs, 2)))
+        assert np.linalg.matrix_rank(C) == 1
+
+
+# Ill conditioned weight matrix will raise error
+def test_ill_conditioned_2d_weights():
+    with pytest.raises(ValueError):
+        Xt = np.random.rand(nobs, nvox)
+        y = np.random.rand(nobs, 2)
+        iem_2d.fit(Xt, y)
+
+
+# Not enough observations will trigger error
+def test_insufficient_2d_data():
+    with pytest.raises(ValueError):
+        Xt = np.random.rand(10, nvox)
+        y = np.random.rand(10, 2)
+        iem_2d.fit(Xt, y)
+
+
+# Test case when # of observations are not matched btwn data & labels
+def test_mismatched_2d_observations():
+    with pytest.raises(ValueError):
+        iem_2d.fit(Xd, yd[:-50, :])
+
+
+# Test prediction capability from valid (fabricated) data
+def test_can_predict_from_2d_data():
+    iem_2d.fit(Xd, yd)
+    preds = iem_2d.predict(X2d)
+    assert preds.shape == (ntest, 2)
+
+
+# Show that prediction is invalid when input data is wrong size
+def test_cannot_predict_from_2d_data():
+    iem_2d.fit(Xd, yd)
+    with pytest.raises(ValueError):
+        _ = iem_2d.predict(X2d.T)
+
+
+# Show proper scoring function with valid (fabricated) test data
+def test_can_score_2d():
+    iem_2d.fit(Xd, yd)
+    score = iem_2d.score(X2d, yd[:ntest, :])
+    assert score.shape == (ntest,)
+    score = iem_2d.score_against_reconstructed(X2d,
+                                               np.random.rand(res[0]*res[1],
+                                                              ntest))
+    assert score.shape == (ntest,)
+    score = iem_2d.score_against_reconstructed(X2d,
+                                               np.random.rand(res[0]*res[1],
+                                                              ntest),
+                                               metric="cosine")
+    assert score.shape == (ntest,)
+
+
+# Test scoring with invalid data formatting
+def test_cannot_score_2d():
+    iem_2d.fit(Xd, yd)
+    with pytest.raises(ValueError):
+        score = iem_2d.score(X2d.transpose(), yd[ntest, :])
+        assert score
+
+
+# TESTS FOR 1D MODEL #
 # Test to check stimulus resolution input
-def test_stimulus_resolution():
-    s = InvertedEncoding(6, 5, stimulus_resolution=360)
+def test_1d_stimulus_resolution():
+    s = InvertedEncoding1D(6, 5, stimulus_resolution=360)
     assert s.stim_res == 360
 
 
 # Provide invalid data so that channels cannot be created.
-def test_cannot_instantiate_channels():
+def test_cannot_instantiate_1d_channels():
     with pytest.raises(ValueError):
-        s = InvertedEncoding(n_channels=0)
-        assert s, "Invalid InvertedEncoding instance"
+        s = InvertedEncoding1D(n_channels=0)
+        assert s, "Invalid InvertedEncoding1D instance"
 
 
 # Provide invalid stimulus mode
 def test_stimulus_mode():
     with pytest.raises(ValueError):
-        s = InvertedEncoding(6, 5, 'random')
-        assert s, "Invalid InvertedEncoding instance"
+        s = InvertedEncoding1D(6, 5, 'random')
+        assert s, "Invalid InvertedEncoding1D instance"
 
 
 # Provide mismatching range and stimulus_mode input
 def test_range_stimulus_mode_circ():
     with pytest.raises(ValueError):
-        s = InvertedEncoding(6, 5, 'circular', 0, 180)
-        assert s, "Invalid InvertedEncoding instance"
+        s = InvertedEncoding1D(6, 5, 'circular', 0, 180)
+        assert s, "Invalid InvertedEncoding1D instance"
 
 
 # Provide mismatching range & stimulus mode, with half circular
 def test_range_stimulus_mode_halfcirc():
     with pytest.raises(ValueError):
-        s = InvertedEncoding(6, 5, 'halfcircular', -10, 350)
-        assert s, "Invalid InvertedEncoding instance"
-
-
-# Test for n_observations < n_channels
-def test_data_amount():
-    x = np.random.rand(5, 1000)
-    s = InvertedEncoding()
-    with pytest.raises(ValueError):
-        s.fit(x, np.random.rand(5))
-        assert s, "Invalid data"
-
-
-# Test number of data dimensions
-def test_data_dimensions():
-    x = np.random.rand(5, 10, 2)
-    s = InvertedEncoding()
-    with pytest.raises(ValueError):
-        s.fit(x, np.random.rand(5))
+        s = InvertedEncoding1D(6, 5, 'halfcircular', -10, 350)
+        assert s, "Invalid InvertedEncoding1D instance"
 
 
 # Define some data to use in the following tests.
@@ -102,13 +411,13 @@ def test_data_dimensions():
 
 # Test if valid data can be fit.
 def test_can_fit_data():
-    Invt_model = InvertedEncoding()
+    Invt_model = InvertedEncoding1D()
     Invt_model.fit(X, y)
 
 
 # Test if valid data can be fit in circular space.
 def test_can_fit_circular_space():
-    s = InvertedEncoding(6, 5, 'circular', range_stop=360)
+    s = InvertedEncoding1D(6, 5, 'circular', range_stop=360)
     s.fit(X, y)
 
 
@@ -116,12 +425,12 @@ def test_can_fit_circular_space():
 # algorithm.
 def test_cannot_fit_data():
     with pytest.raises(ValueError):
-        Invt_model = InvertedEncoding()
+        Invt_model = InvertedEncoding1D()
         Invt_model.fit(X.transpose(), y)
 
 
 def test_ill_conditioned_train_data():
-    Invt_model = InvertedEncoding()
+    Invt_model = InvertedEncoding1D()
     with pytest.raises(ValueError):
         X = np.array([[0, 0, 0], [1, 1, 1]])
         Invt_model.fit(X, np.array([0, 0, 0]))
@@ -132,20 +441,20 @@ def test_extra_data_dimensions():
     with pytest.raises(ValueError):
         n, dim1, dim2 = 300, 3, 3
         X = np.random.rand(n//3, dim1, dim2)
-        Invt_model = InvertedEncoding()
+        Invt_model = InvertedEncoding1D()
         Invt_model.fit(X, y)
 
 
 # Test case when # of observations are not matched btwn data & labels
 def test_mismatched_observations():
     with pytest.raises(ValueError):
-        Invt_model = InvertedEncoding()
+        Invt_model = InvertedEncoding1D()
         Invt_model.fit(X, y[:-50])
 
 
 # Test prediction capability from valid (fabricated) data
 def test_can_predict_from_data():
-    Invt_model = InvertedEncoding()
+    Invt_model = InvertedEncoding1D()
     Invt_model.fit(X, y)
     m_reconstruct = []
     for j in np.arange(dim):
@@ -157,7 +466,7 @@ def test_can_predict_from_data():
 
 # Show that prediction is invalid when input data is wrong size
 def test_cannot_predict_from_data():
-    Invt_model = InvertedEncoding()
+    Invt_model = InvertedEncoding1D()
     Invt_model.fit(X, y)
     with pytest.raises(ValueError):
         _ = Invt_model.predict(X2[0:n_, :].transpose())
@@ -165,7 +474,7 @@ def test_cannot_predict_from_data():
 
 # Show proper scoring function with valid (fabricated) test data
 def test_can_score():
-    Invt_model = InvertedEncoding()
+    Invt_model = InvertedEncoding1D()
     Invt_model.fit(X, y)
     score = Invt_model.score(X2, y)
     logger.info('Scores: ' + str(score))
@@ -174,7 +483,7 @@ def test_can_score():
 # Test scoring with invalid data formatting
 def test_cannot_score():
     with pytest.raises(ValueError):
-        Invt_model = InvertedEncoding()
+        Invt_model = InvertedEncoding1D()
         Invt_model.fit(X, y)
         score = Invt_model.score(X2.transpose(), y)
         logger.info('Scores: ' + str(score))
@@ -182,16 +491,16 @@ def test_cannot_score():
 
 # Test stimulus resolution that is not even multiple
 def test_stimulus_resolution_odd():
-    Invt_model = InvertedEncoding(stimulus_resolution=59)
+    Invt_model = InvertedEncoding1D(stimulus_resolution=59)
     with pytest.raises(NotImplementedError):
         Invt_model.fit(X, y)
 
 
 # Test stimulus masking
 def test_stimulus_mask():
-    Invt_model = InvertedEncoding(6, 5, range_start=-10,
-                                  range_stop=170,
-                                  stimulus_resolution=60)
+    Invt_model = InvertedEncoding1D(6, 5, range_start=-10,
+                                    range_stop=170,
+                                    stimulus_resolution=60)
     chans, _ = Invt_model._define_channels()
     Invt_model.set_params(channels_=chans)
     with pytest.warns(RuntimeWarning):
@@ -202,9 +511,9 @@ def test_stimulus_mask():
 
 # Test stimulus masking with different range
 def test_stimulus_mask_shift_positive():
-    Invt_model = InvertedEncoding(6, 5, range_start=10,
-                                  range_stop=190,
-                                  stimulus_resolution=60)
+    Invt_model = InvertedEncoding1D(6, 5, range_start=10,
+                                    range_stop=190,
+                                    stimulus_resolution=60)
     chans, _ = Invt_model._define_channels()
     Invt_model.set_params(channels_=chans)
     with pytest.warns(RuntimeWarning):
@@ -215,8 +524,9 @@ def test_stimulus_mask_shift_positive():
 
 # Test ability to get model parameters from object
 def test_can_get_params():
-    s = InvertedEncoding()
+    s = InvertedEncoding1D()
     param_out = s.get_params()
+    assert param_out.get('channel_exp') == 5
     logger.info('Returned Parameters: ' +
                 str(param_out.get('n_channels')) +
                 ', ' + str(param_out.get('range_start')) +
@@ -225,7 +535,7 @@ def test_can_get_params():
 
 # Test ability to set model parameters of an object instance
 def test_can_set_params():
-    s = InvertedEncoding()
+    s = InvertedEncoding1D()
     s.set_params(n_channels=10,
                  stimulus_mode='circular',
                  range_start=-90,