diff --git a/.gitattributes b/.gitattributes index 6bd9e830adff8dc0906c2ddc927f1c02e17383af..c3fec2c0336ddb8009700dc66bfbb565e805797d 100644 --- a/.gitattributes +++ b/.gitattributes @@ -60,3 +60,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text llmeval-env/bin/python3.10 filter=lfs diff=lfs merge=lfs -text llmeval-env/bin/python3 filter=lfs diff=lfs merge=lfs -text llmeval-env/bin/python filter=lfs diff=lfs merge=lfs -text +llmeval-env/lib/python3.10/site-packages/scipy/optimize/_highs/_highs_wrapper.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/fft/_basic.py b/llmeval-env/lib/python3.10/site-packages/scipy/fft/_basic.py new file mode 100644 index 0000000000000000000000000000000000000000..a3fc021c9ef9b7c2a40bf7b5138158df8e276ae6 --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/scipy/fft/_basic.py @@ -0,0 +1,1630 @@ +from scipy._lib.uarray import generate_multimethod, Dispatchable +import numpy as np + + +def _x_replacer(args, kwargs, dispatchables): + """ + uarray argument replacer to replace the transform input array (``x``) + """ + if len(args) > 0: + return (dispatchables[0],) + args[1:], kwargs + kw = kwargs.copy() + kw['x'] = dispatchables[0] + return args, kw + + +def _dispatch(func): + """ + Function annotation that creates a uarray multimethod from the function + """ + return generate_multimethod(func, _x_replacer, domain="numpy.scipy.fft") + + +@_dispatch +def fft(x, n=None, axis=-1, norm=None, overwrite_x=False, workers=None, *, + plan=None): + """ + Compute the 1-D discrete Fourier Transform. + + This function computes the 1-D *n*-point discrete Fourier + Transform (DFT) with the efficient Fast Fourier Transform (FFT) + algorithm [1]_. + + Parameters + ---------- + x : array_like + Input array, can be complex. + n : int, optional + Length of the transformed axis of the output. + If `n` is smaller than the length of the input, the input is cropped. + If it is larger, the input is padded with zeros. If `n` is not given, + the length of the input along the axis specified by `axis` is used. + axis : int, optional + Axis over which to compute the FFT. If not given, the last axis is + used. + norm : {"backward", "ortho", "forward"}, optional + Normalization mode. Default is "backward", meaning no normalization on + the forward transforms and scaling by ``1/n`` on the `ifft`. + "forward" instead applies the ``1/n`` factor on the forward transform. + For ``norm="ortho"``, both directions are scaled by ``1/sqrt(n)``. + + .. versionadded:: 1.6.0 + ``norm={"forward", "backward"}`` options were added + + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + See the notes below for more details. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. See below for more + details. + plan : object, optional + This argument is reserved for passing in a precomputed plan provided + by downstream FFT vendors. It is currently not used in SciPy. + + .. versionadded:: 1.5.0 + + Returns + ------- + out : complex ndarray + The truncated or zero-padded input, transformed along the axis + indicated by `axis`, or the last one if `axis` is not specified. + + Raises + ------ + IndexError + if `axes` is larger than the last axis of `x`. + + See Also + -------- + ifft : The inverse of `fft`. + fft2 : The 2-D FFT. + fftn : The N-D FFT. + rfftn : The N-D FFT of real input. + fftfreq : Frequency bins for given FFT parameters. + next_fast_len : Size to pad input to for most efficient transforms + + Notes + ----- + FFT (Fast Fourier Transform) refers to a way the discrete Fourier Transform + (DFT) can be calculated efficiently, by using symmetries in the calculated + terms. The symmetry is highest when `n` is a power of 2, and the transform + is therefore most efficient for these sizes. For poorly factorizable sizes, + `scipy.fft` uses Bluestein's algorithm [2]_ and so is never worse than + O(`n` log `n`). Further performance improvements may be seen by zero-padding + the input using `next_fast_len`. + + If ``x`` is a 1d array, then the `fft` is equivalent to :: + + y[k] = np.sum(x * np.exp(-2j * np.pi * k * np.arange(n)/n)) + + The frequency term ``f=k/n`` is found at ``y[k]``. At ``y[n/2]`` we reach + the Nyquist frequency and wrap around to the negative-frequency terms. So, + for an 8-point transform, the frequencies of the result are + [0, 1, 2, 3, -4, -3, -2, -1]. To rearrange the fft output so that the + zero-frequency component is centered, like [-4, -3, -2, -1, 0, 1, 2, 3], + use `fftshift`. + + Transforms can be done in single, double, or extended precision (long + double) floating point. Half precision inputs will be converted to single + precision and non-floating-point inputs will be converted to double + precision. + + If the data type of ``x`` is real, a "real FFT" algorithm is automatically + used, which roughly halves the computation time. To increase efficiency + a little further, use `rfft`, which does the same calculation, but only + outputs half of the symmetrical spectrum. If the data are both real and + symmetrical, the `dct` can again double the efficiency, by generating + half of the spectrum from half of the signal. + + When ``overwrite_x=True`` is specified, the memory referenced by ``x`` may + be used by the implementation in any way. This may include reusing the + memory for the result, but this is in no way guaranteed. You should not + rely on the contents of ``x`` after the transform as this may change in + future without warning. + + The ``workers`` argument specifies the maximum number of parallel jobs to + split the FFT computation into. This will execute independent 1-D + FFTs within ``x``. So, ``x`` must be at least 2-D and the + non-transformed axes must be large enough to split into chunks. If ``x`` is + too small, fewer jobs may be used than requested. + + References + ---------- + .. [1] Cooley, James W., and John W. Tukey, 1965, "An algorithm for the + machine calculation of complex Fourier series," *Math. Comput.* + 19: 297-301. + .. [2] Bluestein, L., 1970, "A linear filtering approach to the + computation of discrete Fourier transform". *IEEE Transactions on + Audio and Electroacoustics.* 18 (4): 451-455. + + Examples + -------- + >>> import scipy.fft + >>> import numpy as np + >>> scipy.fft.fft(np.exp(2j * np.pi * np.arange(8) / 8)) + array([-2.33486982e-16+1.14423775e-17j, 8.00000000e+00-1.25557246e-15j, + 2.33486982e-16+2.33486982e-16j, 0.00000000e+00+1.22464680e-16j, + -1.14423775e-17+2.33486982e-16j, 0.00000000e+00+5.20784380e-16j, + 1.14423775e-17+1.14423775e-17j, 0.00000000e+00+1.22464680e-16j]) + + In this example, real input has an FFT which is Hermitian, i.e., symmetric + in the real part and anti-symmetric in the imaginary part: + + >>> from scipy.fft import fft, fftfreq, fftshift + >>> import matplotlib.pyplot as plt + >>> t = np.arange(256) + >>> sp = fftshift(fft(np.sin(t))) + >>> freq = fftshift(fftfreq(t.shape[-1])) + >>> plt.plot(freq, sp.real, freq, sp.imag) + [, + ] + >>> plt.show() + + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def ifft(x, n=None, axis=-1, norm=None, overwrite_x=False, workers=None, *, + plan=None): + """ + Compute the 1-D inverse discrete Fourier Transform. + + This function computes the inverse of the 1-D *n*-point + discrete Fourier transform computed by `fft`. In other words, + ``ifft(fft(x)) == x`` to within numerical accuracy. + + The input should be ordered in the same way as is returned by `fft`, + i.e., + + * ``x[0]`` should contain the zero frequency term, + * ``x[1:n//2]`` should contain the positive-frequency terms, + * ``x[n//2 + 1:]`` should contain the negative-frequency terms, in + increasing order starting from the most negative frequency. + + For an even number of input points, ``x[n//2]`` represents the sum of + the values at the positive and negative Nyquist frequencies, as the two + are aliased together. See `fft` for details. + + Parameters + ---------- + x : array_like + Input array, can be complex. + n : int, optional + Length of the transformed axis of the output. + If `n` is smaller than the length of the input, the input is cropped. + If it is larger, the input is padded with zeros. If `n` is not given, + the length of the input along the axis specified by `axis` is used. + See notes about padding issues. + axis : int, optional + Axis over which to compute the inverse DFT. If not given, the last + axis is used. + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see `fft`). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + See :func:`fft` for more details. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + plan : object, optional + This argument is reserved for passing in a precomputed plan provided + by downstream FFT vendors. It is currently not used in SciPy. + + .. versionadded:: 1.5.0 + + Returns + ------- + out : complex ndarray + The truncated or zero-padded input, transformed along the axis + indicated by `axis`, or the last one if `axis` is not specified. + + Raises + ------ + IndexError + If `axes` is larger than the last axis of `x`. + + See Also + -------- + fft : The 1-D (forward) FFT, of which `ifft` is the inverse. + ifft2 : The 2-D inverse FFT. + ifftn : The N-D inverse FFT. + + Notes + ----- + If the input parameter `n` is larger than the size of the input, the input + is padded by appending zeros at the end. Even though this is the common + approach, it might lead to surprising results. If a different padding is + desired, it must be performed before calling `ifft`. + + If ``x`` is a 1-D array, then the `ifft` is equivalent to :: + + y[k] = np.sum(x * np.exp(2j * np.pi * k * np.arange(n)/n)) / len(x) + + As with `fft`, `ifft` has support for all floating point types and is + optimized for real input. + + Examples + -------- + >>> import scipy.fft + >>> import numpy as np + >>> scipy.fft.ifft([0, 4, 0, 0]) + array([ 1.+0.j, 0.+1.j, -1.+0.j, 0.-1.j]) # may vary + + Create and plot a band-limited signal with random phases: + + >>> import matplotlib.pyplot as plt + >>> rng = np.random.default_rng() + >>> t = np.arange(400) + >>> n = np.zeros((400,), dtype=complex) + >>> n[40:60] = np.exp(1j*rng.uniform(0, 2*np.pi, (20,))) + >>> s = scipy.fft.ifft(n) + >>> plt.plot(t, s.real, 'b-', t, s.imag, 'r--') + [, ] + >>> plt.legend(('real', 'imaginary')) + + >>> plt.show() + + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def rfft(x, n=None, axis=-1, norm=None, overwrite_x=False, workers=None, *, + plan=None): + """ + Compute the 1-D discrete Fourier Transform for real input. + + This function computes the 1-D *n*-point discrete Fourier + Transform (DFT) of a real-valued array by means of an efficient algorithm + called the Fast Fourier Transform (FFT). + + Parameters + ---------- + x : array_like + Input array + n : int, optional + Number of points along transformation axis in the input to use. + If `n` is smaller than the length of the input, the input is cropped. + If it is larger, the input is padded with zeros. If `n` is not given, + the length of the input along the axis specified by `axis` is used. + axis : int, optional + Axis over which to compute the FFT. If not given, the last axis is + used. + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see `fft`). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + See :func:`fft` for more details. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + plan : object, optional + This argument is reserved for passing in a precomputed plan provided + by downstream FFT vendors. It is currently not used in SciPy. + + .. versionadded:: 1.5.0 + + Returns + ------- + out : complex ndarray + The truncated or zero-padded input, transformed along the axis + indicated by `axis`, or the last one if `axis` is not specified. + If `n` is even, the length of the transformed axis is ``(n/2)+1``. + If `n` is odd, the length is ``(n+1)/2``. + + Raises + ------ + IndexError + If `axis` is larger than the last axis of `a`. + + See Also + -------- + irfft : The inverse of `rfft`. + fft : The 1-D FFT of general (complex) input. + fftn : The N-D FFT. + rfft2 : The 2-D FFT of real input. + rfftn : The N-D FFT of real input. + + Notes + ----- + When the DFT is computed for purely real input, the output is + Hermitian-symmetric, i.e., the negative frequency terms are just the complex + conjugates of the corresponding positive-frequency terms, and the + negative-frequency terms are therefore redundant. This function does not + compute the negative frequency terms, and the length of the transformed + axis of the output is therefore ``n//2 + 1``. + + When ``X = rfft(x)`` and fs is the sampling frequency, ``X[0]`` contains + the zero-frequency term 0*fs, which is real due to Hermitian symmetry. + + If `n` is even, ``A[-1]`` contains the term representing both positive + and negative Nyquist frequency (+fs/2 and -fs/2), and must also be purely + real. If `n` is odd, there is no term at fs/2; ``A[-1]`` contains + the largest positive frequency (fs/2*(n-1)/n), and is complex in the + general case. + + If the input `a` contains an imaginary part, it is silently discarded. + + Examples + -------- + >>> import scipy.fft + >>> scipy.fft.fft([0, 1, 0, 0]) + array([ 1.+0.j, 0.-1.j, -1.+0.j, 0.+1.j]) # may vary + >>> scipy.fft.rfft([0, 1, 0, 0]) + array([ 1.+0.j, 0.-1.j, -1.+0.j]) # may vary + + Notice how the final element of the `fft` output is the complex conjugate + of the second element, for real input. For `rfft`, this symmetry is + exploited to compute only the non-negative frequency terms. + + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def irfft(x, n=None, axis=-1, norm=None, overwrite_x=False, workers=None, *, + plan=None): + """ + Computes the inverse of `rfft`. + + This function computes the inverse of the 1-D *n*-point + discrete Fourier Transform of real input computed by `rfft`. + In other words, ``irfft(rfft(x), len(x)) == x`` to within numerical + accuracy. (See Notes below for why ``len(a)`` is necessary here.) + + The input is expected to be in the form returned by `rfft`, i.e., the + real zero-frequency term followed by the complex positive frequency terms + in order of increasing frequency. Since the discrete Fourier Transform of + real input is Hermitian-symmetric, the negative frequency terms are taken + to be the complex conjugates of the corresponding positive frequency terms. + + Parameters + ---------- + x : array_like + The input array. + n : int, optional + Length of the transformed axis of the output. + For `n` output points, ``n//2+1`` input points are necessary. If the + input is longer than this, it is cropped. If it is shorter than this, + it is padded with zeros. If `n` is not given, it is taken to be + ``2*(m-1)``, where ``m`` is the length of the input along the axis + specified by `axis`. + axis : int, optional + Axis over which to compute the inverse FFT. If not given, the last + axis is used. + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see `fft`). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + See :func:`fft` for more details. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + plan : object, optional + This argument is reserved for passing in a precomputed plan provided + by downstream FFT vendors. It is currently not used in SciPy. + + .. versionadded:: 1.5.0 + + Returns + ------- + out : ndarray + The truncated or zero-padded input, transformed along the axis + indicated by `axis`, or the last one if `axis` is not specified. + The length of the transformed axis is `n`, or, if `n` is not given, + ``2*(m-1)`` where ``m`` is the length of the transformed axis of the + input. To get an odd number of output points, `n` must be specified. + + Raises + ------ + IndexError + If `axis` is larger than the last axis of `x`. + + See Also + -------- + rfft : The 1-D FFT of real input, of which `irfft` is inverse. + fft : The 1-D FFT. + irfft2 : The inverse of the 2-D FFT of real input. + irfftn : The inverse of the N-D FFT of real input. + + Notes + ----- + Returns the real valued `n`-point inverse discrete Fourier transform + of `x`, where `x` contains the non-negative frequency terms of a + Hermitian-symmetric sequence. `n` is the length of the result, not the + input. + + If you specify an `n` such that `a` must be zero-padded or truncated, the + extra/removed values will be added/removed at high frequencies. One can + thus resample a series to `m` points via Fourier interpolation by: + ``a_resamp = irfft(rfft(a), m)``. + + The default value of `n` assumes an even output length. By the Hermitian + symmetry, the last imaginary component must be 0 and so is ignored. To + avoid losing information, the correct length of the real input *must* be + given. + + Examples + -------- + >>> import scipy.fft + >>> scipy.fft.ifft([1, -1j, -1, 1j]) + array([0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j]) # may vary + >>> scipy.fft.irfft([1, -1j, -1]) + array([0., 1., 0., 0.]) + + Notice how the last term in the input to the ordinary `ifft` is the + complex conjugate of the second term, and the output has zero imaginary + part everywhere. When calling `irfft`, the negative frequencies are not + specified, and the output array is purely real. + + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def hfft(x, n=None, axis=-1, norm=None, overwrite_x=False, workers=None, *, + plan=None): + """ + Compute the FFT of a signal that has Hermitian symmetry, i.e., a real + spectrum. + + Parameters + ---------- + x : array_like + The input array. + n : int, optional + Length of the transformed axis of the output. For `n` output + points, ``n//2 + 1`` input points are necessary. If the input is + longer than this, it is cropped. If it is shorter than this, it is + padded with zeros. If `n` is not given, it is taken to be ``2*(m-1)``, + where ``m`` is the length of the input along the axis specified by + `axis`. + axis : int, optional + Axis over which to compute the FFT. If not given, the last + axis is used. + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see `fft`). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + See `fft` for more details. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + plan : object, optional + This argument is reserved for passing in a precomputed plan provided + by downstream FFT vendors. It is currently not used in SciPy. + + .. versionadded:: 1.5.0 + + Returns + ------- + out : ndarray + The truncated or zero-padded input, transformed along the axis + indicated by `axis`, or the last one if `axis` is not specified. + The length of the transformed axis is `n`, or, if `n` is not given, + ``2*m - 2``, where ``m`` is the length of the transformed axis of + the input. To get an odd number of output points, `n` must be + specified, for instance, as ``2*m - 1`` in the typical case, + + Raises + ------ + IndexError + If `axis` is larger than the last axis of `a`. + + See Also + -------- + rfft : Compute the 1-D FFT for real input. + ihfft : The inverse of `hfft`. + hfftn : Compute the N-D FFT of a Hermitian signal. + + Notes + ----- + `hfft`/`ihfft` are a pair analogous to `rfft`/`irfft`, but for the + opposite case: here the signal has Hermitian symmetry in the time + domain and is real in the frequency domain. So, here, it's `hfft`, for + which you must supply the length of the result if it is to be odd. + * even: ``ihfft(hfft(a, 2*len(a) - 2) == a``, within roundoff error, + * odd: ``ihfft(hfft(a, 2*len(a) - 1) == a``, within roundoff error. + + Examples + -------- + >>> from scipy.fft import fft, hfft + >>> import numpy as np + >>> a = 2 * np.pi * np.arange(10) / 10 + >>> signal = np.cos(a) + 3j * np.sin(3 * a) + >>> fft(signal).round(10) + array([ -0.+0.j, 5.+0.j, -0.+0.j, 15.-0.j, 0.+0.j, 0.+0.j, + -0.+0.j, -15.-0.j, 0.+0.j, 5.+0.j]) + >>> hfft(signal[:6]).round(10) # Input first half of signal + array([ 0., 5., 0., 15., -0., 0., 0., -15., -0., 5.]) + >>> hfft(signal, 10) # Input entire signal and truncate + array([ 0., 5., 0., 15., -0., 0., 0., -15., -0., 5.]) + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def ihfft(x, n=None, axis=-1, norm=None, overwrite_x=False, workers=None, *, + plan=None): + """ + Compute the inverse FFT of a signal that has Hermitian symmetry. + + Parameters + ---------- + x : array_like + Input array. + n : int, optional + Length of the inverse FFT, the number of points along + transformation axis in the input to use. If `n` is smaller than + the length of the input, the input is cropped. If it is larger, + the input is padded with zeros. If `n` is not given, the length of + the input along the axis specified by `axis` is used. + axis : int, optional + Axis over which to compute the inverse FFT. If not given, the last + axis is used. + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see `fft`). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + See `fft` for more details. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + plan : object, optional + This argument is reserved for passing in a precomputed plan provided + by downstream FFT vendors. It is currently not used in SciPy. + + .. versionadded:: 1.5.0 + + Returns + ------- + out : complex ndarray + The truncated or zero-padded input, transformed along the axis + indicated by `axis`, or the last one if `axis` is not specified. + The length of the transformed axis is ``n//2 + 1``. + + See Also + -------- + hfft, irfft + + Notes + ----- + `hfft`/`ihfft` are a pair analogous to `rfft`/`irfft`, but for the + opposite case: here, the signal has Hermitian symmetry in the time + domain and is real in the frequency domain. So, here, it's `hfft`, for + which you must supply the length of the result if it is to be odd: + * even: ``ihfft(hfft(a, 2*len(a) - 2) == a``, within roundoff error, + * odd: ``ihfft(hfft(a, 2*len(a) - 1) == a``, within roundoff error. + + Examples + -------- + >>> from scipy.fft import ifft, ihfft + >>> import numpy as np + >>> spectrum = np.array([ 15, -4, 0, -1, 0, -4]) + >>> ifft(spectrum) + array([1.+0.j, 2.+0.j, 3.+0.j, 4.+0.j, 3.+0.j, 2.+0.j]) # may vary + >>> ihfft(spectrum) + array([ 1.-0.j, 2.-0.j, 3.-0.j, 4.-0.j]) # may vary + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def fftn(x, s=None, axes=None, norm=None, overwrite_x=False, workers=None, *, + plan=None): + """ + Compute the N-D discrete Fourier Transform. + + This function computes the N-D discrete Fourier Transform over + any number of axes in an M-D array by means of the Fast Fourier + Transform (FFT). + + Parameters + ---------- + x : array_like + Input array, can be complex. + s : sequence of ints, optional + Shape (length of each transformed axis) of the output + (``s[0]`` refers to axis 0, ``s[1]`` to axis 1, etc.). + This corresponds to ``n`` for ``fft(x, n)``. + Along any axis, if the given shape is smaller than that of the input, + the input is cropped. If it is larger, the input is padded with zeros. + if `s` is not given, the shape of the input along the axes specified + by `axes` is used. + axes : sequence of ints, optional + Axes over which to compute the FFT. If not given, the last ``len(s)`` + axes are used, or all axes if `s` is also not specified. + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see `fft`). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + See :func:`fft` for more details. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + plan : object, optional + This argument is reserved for passing in a precomputed plan provided + by downstream FFT vendors. It is currently not used in SciPy. + + .. versionadded:: 1.5.0 + + Returns + ------- + out : complex ndarray + The truncated or zero-padded input, transformed along the axes + indicated by `axes`, or by a combination of `s` and `x`, + as explained in the parameters section above. + + Raises + ------ + ValueError + If `s` and `axes` have different length. + IndexError + If an element of `axes` is larger than the number of axes of `x`. + + See Also + -------- + ifftn : The inverse of `fftn`, the inverse N-D FFT. + fft : The 1-D FFT, with definitions and conventions used. + rfftn : The N-D FFT of real input. + fft2 : The 2-D FFT. + fftshift : Shifts zero-frequency terms to centre of array. + + Notes + ----- + The output, analogously to `fft`, contains the term for zero frequency in + the low-order corner of all axes, the positive frequency terms in the + first half of all axes, the term for the Nyquist frequency in the middle + of all axes and the negative frequency terms in the second half of all + axes, in order of decreasingly negative frequency. + + Examples + -------- + >>> import scipy.fft + >>> import numpy as np + >>> x = np.mgrid[:3, :3, :3][0] + >>> scipy.fft.fftn(x, axes=(1, 2)) + array([[[ 0.+0.j, 0.+0.j, 0.+0.j], # may vary + [ 0.+0.j, 0.+0.j, 0.+0.j], + [ 0.+0.j, 0.+0.j, 0.+0.j]], + [[ 9.+0.j, 0.+0.j, 0.+0.j], + [ 0.+0.j, 0.+0.j, 0.+0.j], + [ 0.+0.j, 0.+0.j, 0.+0.j]], + [[18.+0.j, 0.+0.j, 0.+0.j], + [ 0.+0.j, 0.+0.j, 0.+0.j], + [ 0.+0.j, 0.+0.j, 0.+0.j]]]) + >>> scipy.fft.fftn(x, (2, 2), axes=(0, 1)) + array([[[ 2.+0.j, 2.+0.j, 2.+0.j], # may vary + [ 0.+0.j, 0.+0.j, 0.+0.j]], + [[-2.+0.j, -2.+0.j, -2.+0.j], + [ 0.+0.j, 0.+0.j, 0.+0.j]]]) + + >>> import matplotlib.pyplot as plt + >>> rng = np.random.default_rng() + >>> [X, Y] = np.meshgrid(2 * np.pi * np.arange(200) / 12, + ... 2 * np.pi * np.arange(200) / 34) + >>> S = np.sin(X) + np.cos(Y) + rng.uniform(0, 1, X.shape) + >>> FS = scipy.fft.fftn(S) + >>> plt.imshow(np.log(np.abs(scipy.fft.fftshift(FS))**2)) + + >>> plt.show() + + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def ifftn(x, s=None, axes=None, norm=None, overwrite_x=False, workers=None, *, + plan=None): + """ + Compute the N-D inverse discrete Fourier Transform. + + This function computes the inverse of the N-D discrete + Fourier Transform over any number of axes in an M-D array by + means of the Fast Fourier Transform (FFT). In other words, + ``ifftn(fftn(x)) == x`` to within numerical accuracy. + + The input, analogously to `ifft`, should be ordered in the same way as is + returned by `fftn`, i.e., it should have the term for zero frequency + in all axes in the low-order corner, the positive frequency terms in the + first half of all axes, the term for the Nyquist frequency in the middle + of all axes and the negative frequency terms in the second half of all + axes, in order of decreasingly negative frequency. + + Parameters + ---------- + x : array_like + Input array, can be complex. + s : sequence of ints, optional + Shape (length of each transformed axis) of the output + (``s[0]`` refers to axis 0, ``s[1]`` to axis 1, etc.). + This corresponds to ``n`` for ``ifft(x, n)``. + Along any axis, if the given shape is smaller than that of the input, + the input is cropped. If it is larger, the input is padded with zeros. + if `s` is not given, the shape of the input along the axes specified + by `axes` is used. See notes for issue on `ifft` zero padding. + axes : sequence of ints, optional + Axes over which to compute the IFFT. If not given, the last ``len(s)`` + axes are used, or all axes if `s` is also not specified. + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see `fft`). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + See :func:`fft` for more details. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + plan : object, optional + This argument is reserved for passing in a precomputed plan provided + by downstream FFT vendors. It is currently not used in SciPy. + + .. versionadded:: 1.5.0 + + Returns + ------- + out : complex ndarray + The truncated or zero-padded input, transformed along the axes + indicated by `axes`, or by a combination of `s` or `x`, + as explained in the parameters section above. + + Raises + ------ + ValueError + If `s` and `axes` have different length. + IndexError + If an element of `axes` is larger than the number of axes of `x`. + + See Also + -------- + fftn : The forward N-D FFT, of which `ifftn` is the inverse. + ifft : The 1-D inverse FFT. + ifft2 : The 2-D inverse FFT. + ifftshift : Undoes `fftshift`, shifts zero-frequency terms to beginning + of array. + + Notes + ----- + Zero-padding, analogously with `ifft`, is performed by appending zeros to + the input along the specified dimension. Although this is the common + approach, it might lead to surprising results. If another form of zero + padding is desired, it must be performed before `ifftn` is called. + + Examples + -------- + >>> import scipy.fft + >>> import numpy as np + >>> x = np.eye(4) + >>> scipy.fft.ifftn(scipy.fft.fftn(x, axes=(0,)), axes=(1,)) + array([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j], # may vary + [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j], + [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j], + [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]]) + + + Create and plot an image with band-limited frequency content: + + >>> import matplotlib.pyplot as plt + >>> rng = np.random.default_rng() + >>> n = np.zeros((200,200), dtype=complex) + >>> n[60:80, 20:40] = np.exp(1j*rng.uniform(0, 2*np.pi, (20, 20))) + >>> im = scipy.fft.ifftn(n).real + >>> plt.imshow(im) + + >>> plt.show() + + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def fft2(x, s=None, axes=(-2, -1), norm=None, overwrite_x=False, workers=None, *, + plan=None): + """ + Compute the 2-D discrete Fourier Transform + + This function computes the N-D discrete Fourier Transform + over any axes in an M-D array by means of the + Fast Fourier Transform (FFT). By default, the transform is computed over + the last two axes of the input array, i.e., a 2-dimensional FFT. + + Parameters + ---------- + x : array_like + Input array, can be complex + s : sequence of ints, optional + Shape (length of each transformed axis) of the output + (``s[0]`` refers to axis 0, ``s[1]`` to axis 1, etc.). + This corresponds to ``n`` for ``fft(x, n)``. + Along each axis, if the given shape is smaller than that of the input, + the input is cropped. If it is larger, the input is padded with zeros. + if `s` is not given, the shape of the input along the axes specified + by `axes` is used. + axes : sequence of ints, optional + Axes over which to compute the FFT. If not given, the last two axes are + used. + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see `fft`). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + See :func:`fft` for more details. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + plan : object, optional + This argument is reserved for passing in a precomputed plan provided + by downstream FFT vendors. It is currently not used in SciPy. + + .. versionadded:: 1.5.0 + + Returns + ------- + out : complex ndarray + The truncated or zero-padded input, transformed along the axes + indicated by `axes`, or the last two axes if `axes` is not given. + + Raises + ------ + ValueError + If `s` and `axes` have different length, or `axes` not given and + ``len(s) != 2``. + IndexError + If an element of `axes` is larger than the number of axes of `x`. + + See Also + -------- + ifft2 : The inverse 2-D FFT. + fft : The 1-D FFT. + fftn : The N-D FFT. + fftshift : Shifts zero-frequency terms to the center of the array. + For 2-D input, swaps first and third quadrants, and second + and fourth quadrants. + + Notes + ----- + `fft2` is just `fftn` with a different default for `axes`. + + The output, analogously to `fft`, contains the term for zero frequency in + the low-order corner of the transformed axes, the positive frequency terms + in the first half of these axes, the term for the Nyquist frequency in the + middle of the axes and the negative frequency terms in the second half of + the axes, in order of decreasingly negative frequency. + + See `fftn` for details and a plotting example, and `fft` for + definitions and conventions used. + + + Examples + -------- + >>> import scipy.fft + >>> import numpy as np + >>> x = np.mgrid[:5, :5][0] + >>> scipy.fft.fft2(x) + array([[ 50. +0.j , 0. +0.j , 0. +0.j , # may vary + 0. +0.j , 0. +0.j ], + [-12.5+17.20477401j, 0. +0.j , 0. +0.j , + 0. +0.j , 0. +0.j ], + [-12.5 +4.0614962j , 0. +0.j , 0. +0.j , + 0. +0.j , 0. +0.j ], + [-12.5 -4.0614962j , 0. +0.j , 0. +0.j , + 0. +0.j , 0. +0.j ], + [-12.5-17.20477401j, 0. +0.j , 0. +0.j , + 0. +0.j , 0. +0.j ]]) + + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def ifft2(x, s=None, axes=(-2, -1), norm=None, overwrite_x=False, workers=None, *, + plan=None): + """ + Compute the 2-D inverse discrete Fourier Transform. + + This function computes the inverse of the 2-D discrete Fourier + Transform over any number of axes in an M-D array by means of + the Fast Fourier Transform (FFT). In other words, ``ifft2(fft2(x)) == x`` + to within numerical accuracy. By default, the inverse transform is + computed over the last two axes of the input array. + + The input, analogously to `ifft`, should be ordered in the same way as is + returned by `fft2`, i.e., it should have the term for zero frequency + in the low-order corner of the two axes, the positive frequency terms in + the first half of these axes, the term for the Nyquist frequency in the + middle of the axes and the negative frequency terms in the second half of + both axes, in order of decreasingly negative frequency. + + Parameters + ---------- + x : array_like + Input array, can be complex. + s : sequence of ints, optional + Shape (length of each axis) of the output (``s[0]`` refers to axis 0, + ``s[1]`` to axis 1, etc.). This corresponds to `n` for ``ifft(x, n)``. + Along each axis, if the given shape is smaller than that of the input, + the input is cropped. If it is larger, the input is padded with zeros. + if `s` is not given, the shape of the input along the axes specified + by `axes` is used. See notes for issue on `ifft` zero padding. + axes : sequence of ints, optional + Axes over which to compute the FFT. If not given, the last two + axes are used. + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see `fft`). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + See :func:`fft` for more details. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + plan : object, optional + This argument is reserved for passing in a precomputed plan provided + by downstream FFT vendors. It is currently not used in SciPy. + + .. versionadded:: 1.5.0 + + Returns + ------- + out : complex ndarray + The truncated or zero-padded input, transformed along the axes + indicated by `axes`, or the last two axes if `axes` is not given. + + Raises + ------ + ValueError + If `s` and `axes` have different length, or `axes` not given and + ``len(s) != 2``. + IndexError + If an element of `axes` is larger than the number of axes of `x`. + + See Also + -------- + fft2 : The forward 2-D FFT, of which `ifft2` is the inverse. + ifftn : The inverse of the N-D FFT. + fft : The 1-D FFT. + ifft : The 1-D inverse FFT. + + Notes + ----- + `ifft2` is just `ifftn` with a different default for `axes`. + + See `ifftn` for details and a plotting example, and `fft` for + definition and conventions used. + + Zero-padding, analogously with `ifft`, is performed by appending zeros to + the input along the specified dimension. Although this is the common + approach, it might lead to surprising results. If another form of zero + padding is desired, it must be performed before `ifft2` is called. + + Examples + -------- + >>> import scipy.fft + >>> import numpy as np + >>> x = 4 * np.eye(4) + >>> scipy.fft.ifft2(x) + array([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j], # may vary + [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j], + [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j], + [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j]]) + + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def rfftn(x, s=None, axes=None, norm=None, overwrite_x=False, workers=None, *, + plan=None): + """ + Compute the N-D discrete Fourier Transform for real input. + + This function computes the N-D discrete Fourier Transform over + any number of axes in an M-D real array by means of the Fast + Fourier Transform (FFT). By default, all axes are transformed, with the + real transform performed over the last axis, while the remaining + transforms are complex. + + Parameters + ---------- + x : array_like + Input array, taken to be real. + s : sequence of ints, optional + Shape (length along each transformed axis) to use from the input. + (``s[0]`` refers to axis 0, ``s[1]`` to axis 1, etc.). + The final element of `s` corresponds to `n` for ``rfft(x, n)``, while + for the remaining axes, it corresponds to `n` for ``fft(x, n)``. + Along any axis, if the given shape is smaller than that of the input, + the input is cropped. If it is larger, the input is padded with zeros. + if `s` is not given, the shape of the input along the axes specified + by `axes` is used. + axes : sequence of ints, optional + Axes over which to compute the FFT. If not given, the last ``len(s)`` + axes are used, or all axes if `s` is also not specified. + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see `fft`). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + See :func:`fft` for more details. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + plan : object, optional + This argument is reserved for passing in a precomputed plan provided + by downstream FFT vendors. It is currently not used in SciPy. + + .. versionadded:: 1.5.0 + + Returns + ------- + out : complex ndarray + The truncated or zero-padded input, transformed along the axes + indicated by `axes`, or by a combination of `s` and `x`, + as explained in the parameters section above. + The length of the last axis transformed will be ``s[-1]//2+1``, + while the remaining transformed axes will have lengths according to + `s`, or unchanged from the input. + + Raises + ------ + ValueError + If `s` and `axes` have different length. + IndexError + If an element of `axes` is larger than the number of axes of `x`. + + See Also + -------- + irfftn : The inverse of `rfftn`, i.e., the inverse of the N-D FFT + of real input. + fft : The 1-D FFT, with definitions and conventions used. + rfft : The 1-D FFT of real input. + fftn : The N-D FFT. + rfft2 : The 2-D FFT of real input. + + Notes + ----- + The transform for real input is performed over the last transformation + axis, as by `rfft`, then the transform over the remaining axes is + performed as by `fftn`. The order of the output is as for `rfft` for the + final transformation axis, and as for `fftn` for the remaining + transformation axes. + + See `fft` for details, definitions and conventions used. + + Examples + -------- + >>> import scipy.fft + >>> import numpy as np + >>> x = np.ones((2, 2, 2)) + >>> scipy.fft.rfftn(x) + array([[[8.+0.j, 0.+0.j], # may vary + [0.+0.j, 0.+0.j]], + [[0.+0.j, 0.+0.j], + [0.+0.j, 0.+0.j]]]) + + >>> scipy.fft.rfftn(x, axes=(2, 0)) + array([[[4.+0.j, 0.+0.j], # may vary + [4.+0.j, 0.+0.j]], + [[0.+0.j, 0.+0.j], + [0.+0.j, 0.+0.j]]]) + + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def rfft2(x, s=None, axes=(-2, -1), norm=None, overwrite_x=False, workers=None, *, + plan=None): + """ + Compute the 2-D FFT of a real array. + + Parameters + ---------- + x : array + Input array, taken to be real. + s : sequence of ints, optional + Shape of the FFT. + axes : sequence of ints, optional + Axes over which to compute the FFT. + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see `fft`). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + See :func:`fft` for more details. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + plan : object, optional + This argument is reserved for passing in a precomputed plan provided + by downstream FFT vendors. It is currently not used in SciPy. + + .. versionadded:: 1.5.0 + + Returns + ------- + out : ndarray + The result of the real 2-D FFT. + + See Also + -------- + irfft2 : The inverse of the 2-D FFT of real input. + rfft : The 1-D FFT of real input. + rfftn : Compute the N-D discrete Fourier Transform for real + input. + + Notes + ----- + This is really just `rfftn` with different default behavior. + For more details see `rfftn`. + + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def irfftn(x, s=None, axes=None, norm=None, overwrite_x=False, workers=None, *, + plan=None): + """ + Computes the inverse of `rfftn` + + This function computes the inverse of the N-D discrete + Fourier Transform for real input over any number of axes in an + M-D array by means of the Fast Fourier Transform (FFT). In + other words, ``irfftn(rfftn(x), x.shape) == x`` to within numerical + accuracy. (The ``a.shape`` is necessary like ``len(a)`` is for `irfft`, + and for the same reason.) + + The input should be ordered in the same way as is returned by `rfftn`, + i.e., as for `irfft` for the final transformation axis, and as for `ifftn` + along all the other axes. + + Parameters + ---------- + x : array_like + Input array. + s : sequence of ints, optional + Shape (length of each transformed axis) of the output + (``s[0]`` refers to axis 0, ``s[1]`` to axis 1, etc.). `s` is also the + number of input points used along this axis, except for the last axis, + where ``s[-1]//2+1`` points of the input are used. + Along any axis, if the shape indicated by `s` is smaller than that of + the input, the input is cropped. If it is larger, the input is padded + with zeros. If `s` is not given, the shape of the input along the axes + specified by axes is used. Except for the last axis which is taken to be + ``2*(m-1)``, where ``m`` is the length of the input along that axis. + axes : sequence of ints, optional + Axes over which to compute the inverse FFT. If not given, the last + `len(s)` axes are used, or all axes if `s` is also not specified. + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see `fft`). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + See :func:`fft` for more details. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + plan : object, optional + This argument is reserved for passing in a precomputed plan provided + by downstream FFT vendors. It is currently not used in SciPy. + + .. versionadded:: 1.5.0 + + Returns + ------- + out : ndarray + The truncated or zero-padded input, transformed along the axes + indicated by `axes`, or by a combination of `s` or `x`, + as explained in the parameters section above. + The length of each transformed axis is as given by the corresponding + element of `s`, or the length of the input in every axis except for the + last one if `s` is not given. In the final transformed axis the length + of the output when `s` is not given is ``2*(m-1)``, where ``m`` is the + length of the final transformed axis of the input. To get an odd + number of output points in the final axis, `s` must be specified. + + Raises + ------ + ValueError + If `s` and `axes` have different length. + IndexError + If an element of `axes` is larger than the number of axes of `x`. + + See Also + -------- + rfftn : The forward N-D FFT of real input, + of which `ifftn` is the inverse. + fft : The 1-D FFT, with definitions and conventions used. + irfft : The inverse of the 1-D FFT of real input. + irfft2 : The inverse of the 2-D FFT of real input. + + Notes + ----- + See `fft` for definitions and conventions used. + + See `rfft` for definitions and conventions used for real input. + + The default value of `s` assumes an even output length in the final + transformation axis. When performing the final complex to real + transformation, the Hermitian symmetry requires that the last imaginary + component along that axis must be 0 and so it is ignored. To avoid losing + information, the correct length of the real input *must* be given. + + Examples + -------- + >>> import scipy.fft + >>> import numpy as np + >>> x = np.zeros((3, 2, 2)) + >>> x[0, 0, 0] = 3 * 2 * 2 + >>> scipy.fft.irfftn(x) + array([[[1., 1.], + [1., 1.]], + [[1., 1.], + [1., 1.]], + [[1., 1.], + [1., 1.]]]) + + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def irfft2(x, s=None, axes=(-2, -1), norm=None, overwrite_x=False, workers=None, *, + plan=None): + """ + Computes the inverse of `rfft2` + + Parameters + ---------- + x : array_like + The input array + s : sequence of ints, optional + Shape of the real output to the inverse FFT. + axes : sequence of ints, optional + The axes over which to compute the inverse fft. + Default is the last two axes. + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see `fft`). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + See :func:`fft` for more details. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + plan : object, optional + This argument is reserved for passing in a precomputed plan provided + by downstream FFT vendors. It is currently not used in SciPy. + + .. versionadded:: 1.5.0 + + Returns + ------- + out : ndarray + The result of the inverse real 2-D FFT. + + See Also + -------- + rfft2 : The 2-D FFT of real input. + irfft : The inverse of the 1-D FFT of real input. + irfftn : The inverse of the N-D FFT of real input. + + Notes + ----- + This is really `irfftn` with different defaults. + For more details see `irfftn`. + + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def hfftn(x, s=None, axes=None, norm=None, overwrite_x=False, workers=None, *, + plan=None): + """ + Compute the N-D FFT of Hermitian symmetric complex input, i.e., a + signal with a real spectrum. + + This function computes the N-D discrete Fourier Transform for a + Hermitian symmetric complex input over any number of axes in an + M-D array by means of the Fast Fourier Transform (FFT). In other + words, ``ihfftn(hfftn(x, s)) == x`` to within numerical accuracy. (``s`` + here is ``x.shape`` with ``s[-1] = x.shape[-1] * 2 - 1``, this is necessary + for the same reason ``x.shape`` would be necessary for `irfft`.) + + Parameters + ---------- + x : array_like + Input array. + s : sequence of ints, optional + Shape (length of each transformed axis) of the output + (``s[0]`` refers to axis 0, ``s[1]`` to axis 1, etc.). `s` is also the + number of input points used along this axis, except for the last axis, + where ``s[-1]//2+1`` points of the input are used. + Along any axis, if the shape indicated by `s` is smaller than that of + the input, the input is cropped. If it is larger, the input is padded + with zeros. If `s` is not given, the shape of the input along the axes + specified by axes is used. Except for the last axis which is taken to be + ``2*(m-1)`` where ``m`` is the length of the input along that axis. + axes : sequence of ints, optional + Axes over which to compute the inverse FFT. If not given, the last + `len(s)` axes are used, or all axes if `s` is also not specified. + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see `fft`). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + See :func:`fft` for more details. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + plan : object, optional + This argument is reserved for passing in a precomputed plan provided + by downstream FFT vendors. It is currently not used in SciPy. + + .. versionadded:: 1.5.0 + + Returns + ------- + out : ndarray + The truncated or zero-padded input, transformed along the axes + indicated by `axes`, or by a combination of `s` or `x`, + as explained in the parameters section above. + The length of each transformed axis is as given by the corresponding + element of `s`, or the length of the input in every axis except for the + last one if `s` is not given. In the final transformed axis the length + of the output when `s` is not given is ``2*(m-1)`` where ``m`` is the + length of the final transformed axis of the input. To get an odd + number of output points in the final axis, `s` must be specified. + + Raises + ------ + ValueError + If `s` and `axes` have different length. + IndexError + If an element of `axes` is larger than the number of axes of `x`. + + See Also + -------- + ihfftn : The inverse N-D FFT with real spectrum. Inverse of `hfftn`. + fft : The 1-D FFT, with definitions and conventions used. + rfft : Forward FFT of real input. + + Notes + ----- + For a 1-D signal ``x`` to have a real spectrum, it must satisfy + the Hermitian property:: + + x[i] == np.conj(x[-i]) for all i + + This generalizes into higher dimensions by reflecting over each axis in + turn:: + + x[i, j, k, ...] == np.conj(x[-i, -j, -k, ...]) for all i, j, k, ... + + This should not be confused with a Hermitian matrix, for which the + transpose is its own conjugate:: + + x[i, j] == np.conj(x[j, i]) for all i, j + + + The default value of `s` assumes an even output length in the final + transformation axis. When performing the final complex to real + transformation, the Hermitian symmetry requires that the last imaginary + component along that axis must be 0 and so it is ignored. To avoid losing + information, the correct length of the real input *must* be given. + + Examples + -------- + >>> import scipy.fft + >>> import numpy as np + >>> x = np.ones((3, 2, 2)) + >>> scipy.fft.hfftn(x) + array([[[12., 0.], + [ 0., 0.]], + [[ 0., 0.], + [ 0., 0.]], + [[ 0., 0.], + [ 0., 0.]]]) + + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def hfft2(x, s=None, axes=(-2, -1), norm=None, overwrite_x=False, workers=None, *, + plan=None): + """ + Compute the 2-D FFT of a Hermitian complex array. + + Parameters + ---------- + x : array + Input array, taken to be Hermitian complex. + s : sequence of ints, optional + Shape of the real output. + axes : sequence of ints, optional + Axes over which to compute the FFT. + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see `fft`). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + See `fft` for more details. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + plan : object, optional + This argument is reserved for passing in a precomputed plan provided + by downstream FFT vendors. It is currently not used in SciPy. + + .. versionadded:: 1.5.0 + + Returns + ------- + out : ndarray + The real result of the 2-D Hermitian complex real FFT. + + See Also + -------- + hfftn : Compute the N-D discrete Fourier Transform for Hermitian + complex input. + + Notes + ----- + This is really just `hfftn` with different default behavior. + For more details see `hfftn`. + + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def ihfftn(x, s=None, axes=None, norm=None, overwrite_x=False, workers=None, *, + plan=None): + """ + Compute the N-D inverse discrete Fourier Transform for a real + spectrum. + + This function computes the N-D inverse discrete Fourier Transform + over any number of axes in an M-D real array by means of the Fast + Fourier Transform (FFT). By default, all axes are transformed, with the + real transform performed over the last axis, while the remaining transforms + are complex. + + Parameters + ---------- + x : array_like + Input array, taken to be real. + s : sequence of ints, optional + Shape (length along each transformed axis) to use from the input. + (``s[0]`` refers to axis 0, ``s[1]`` to axis 1, etc.). + Along any axis, if the given shape is smaller than that of the input, + the input is cropped. If it is larger, the input is padded with zeros. + if `s` is not given, the shape of the input along the axes specified + by `axes` is used. + axes : sequence of ints, optional + Axes over which to compute the FFT. If not given, the last ``len(s)`` + axes are used, or all axes if `s` is also not specified. + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see `fft`). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + See :func:`fft` for more details. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + plan : object, optional + This argument is reserved for passing in a precomputed plan provided + by downstream FFT vendors. It is currently not used in SciPy. + + .. versionadded:: 1.5.0 + + Returns + ------- + out : complex ndarray + The truncated or zero-padded input, transformed along the axes + indicated by `axes`, or by a combination of `s` and `x`, + as explained in the parameters section above. + The length of the last axis transformed will be ``s[-1]//2+1``, + while the remaining transformed axes will have lengths according to + `s`, or unchanged from the input. + + Raises + ------ + ValueError + If `s` and `axes` have different length. + IndexError + If an element of `axes` is larger than the number of axes of `x`. + + See Also + -------- + hfftn : The forward N-D FFT of Hermitian input. + hfft : The 1-D FFT of Hermitian input. + fft : The 1-D FFT, with definitions and conventions used. + fftn : The N-D FFT. + hfft2 : The 2-D FFT of Hermitian input. + + Notes + ----- + The transform for real input is performed over the last transformation + axis, as by `ihfft`, then the transform over the remaining axes is + performed as by `ifftn`. The order of the output is the positive part of + the Hermitian output signal, in the same format as `rfft`. + + Examples + -------- + >>> import scipy.fft + >>> import numpy as np + >>> x = np.ones((2, 2, 2)) + >>> scipy.fft.ihfftn(x) + array([[[1.+0.j, 0.+0.j], # may vary + [0.+0.j, 0.+0.j]], + [[0.+0.j, 0.+0.j], + [0.+0.j, 0.+0.j]]]) + >>> scipy.fft.ihfftn(x, axes=(2, 0)) + array([[[1.+0.j, 0.+0.j], # may vary + [1.+0.j, 0.+0.j]], + [[0.+0.j, 0.+0.j], + [0.+0.j, 0.+0.j]]]) + + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def ihfft2(x, s=None, axes=(-2, -1), norm=None, overwrite_x=False, workers=None, *, + plan=None): + """ + Compute the 2-D inverse FFT of a real spectrum. + + Parameters + ---------- + x : array_like + The input array + s : sequence of ints, optional + Shape of the real input to the inverse FFT. + axes : sequence of ints, optional + The axes over which to compute the inverse fft. + Default is the last two axes. + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see `fft`). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + See :func:`fft` for more details. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + plan : object, optional + This argument is reserved for passing in a precomputed plan provided + by downstream FFT vendors. It is currently not used in SciPy. + + .. versionadded:: 1.5.0 + + Returns + ------- + out : ndarray + The result of the inverse real 2-D FFT. + + See Also + -------- + ihfftn : Compute the inverse of the N-D FFT of Hermitian input. + + Notes + ----- + This is really `ihfftn` with different defaults. + For more details see `ihfftn`. + + """ + return (Dispatchable(x, np.ndarray),) diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/fft/_fftlog.py b/llmeval-env/lib/python3.10/site-packages/scipy/fft/_fftlog.py new file mode 100644 index 0000000000000000000000000000000000000000..8960242989c7c1d062af4fe1960c2384abaab94f --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/scipy/fft/_fftlog.py @@ -0,0 +1,223 @@ +"""Fast Hankel transforms using the FFTLog algorithm. + +The implementation closely follows the Fortran code of Hamilton (2000). + +added: 14/11/2020 Nicolas Tessore +""" + +from ._basic import _dispatch +from scipy._lib.uarray import Dispatchable +from ._fftlog_backend import fhtoffset +import numpy as np + +__all__ = ['fht', 'ifht', 'fhtoffset'] + + +@_dispatch +def fht(a, dln, mu, offset=0.0, bias=0.0): + r'''Compute the fast Hankel transform. + + Computes the discrete Hankel transform of a logarithmically spaced periodic + sequence using the FFTLog algorithm [1]_, [2]_. + + Parameters + ---------- + a : array_like (..., n) + Real periodic input array, uniformly logarithmically spaced. For + multidimensional input, the transform is performed over the last axis. + dln : float + Uniform logarithmic spacing of the input array. + mu : float + Order of the Hankel transform, any positive or negative real number. + offset : float, optional + Offset of the uniform logarithmic spacing of the output array. + bias : float, optional + Exponent of power law bias, any positive or negative real number. + + Returns + ------- + A : array_like (..., n) + The transformed output array, which is real, periodic, uniformly + logarithmically spaced, and of the same shape as the input array. + + See Also + -------- + ifht : The inverse of `fht`. + fhtoffset : Return an optimal offset for `fht`. + + Notes + ----- + This function computes a discrete version of the Hankel transform + + .. math:: + + A(k) = \int_{0}^{\infty} \! a(r) \, J_\mu(kr) \, k \, dr \;, + + where :math:`J_\mu` is the Bessel function of order :math:`\mu`. The index + :math:`\mu` may be any real number, positive or negative. Note that the + numerical Hankel transform uses an integrand of :math:`k \, dr`, while the + mathematical Hankel transform is commonly defined using :math:`r \, dr`. + + The input array `a` is a periodic sequence of length :math:`n`, uniformly + logarithmically spaced with spacing `dln`, + + .. math:: + + a_j = a(r_j) \;, \quad + r_j = r_c \exp[(j-j_c) \, \mathtt{dln}] + + centred about the point :math:`r_c`. Note that the central index + :math:`j_c = (n-1)/2` is half-integral if :math:`n` is even, so that + :math:`r_c` falls between two input elements. Similarly, the output + array `A` is a periodic sequence of length :math:`n`, also uniformly + logarithmically spaced with spacing `dln` + + .. math:: + + A_j = A(k_j) \;, \quad + k_j = k_c \exp[(j-j_c) \, \mathtt{dln}] + + centred about the point :math:`k_c`. + + The centre points :math:`r_c` and :math:`k_c` of the periodic intervals may + be chosen arbitrarily, but it would be usual to choose the product + :math:`k_c r_c = k_j r_{n-1-j} = k_{n-1-j} r_j` to be unity. This can be + changed using the `offset` parameter, which controls the logarithmic offset + :math:`\log(k_c) = \mathtt{offset} - \log(r_c)` of the output array. + Choosing an optimal value for `offset` may reduce ringing of the discrete + Hankel transform. + + If the `bias` parameter is nonzero, this function computes a discrete + version of the biased Hankel transform + + .. math:: + + A(k) = \int_{0}^{\infty} \! a_q(r) \, (kr)^q \, J_\mu(kr) \, k \, dr + + where :math:`q` is the value of `bias`, and a power law bias + :math:`a_q(r) = a(r) \, (kr)^{-q}` is applied to the input sequence. + Biasing the transform can help approximate the continuous transform of + :math:`a(r)` if there is a value :math:`q` such that :math:`a_q(r)` is + close to a periodic sequence, in which case the resulting :math:`A(k)` will + be close to the continuous transform. + + References + ---------- + .. [1] Talman J. D., 1978, J. Comp. Phys., 29, 35 + .. [2] Hamilton A. J. S., 2000, MNRAS, 312, 257 (astro-ph/9905191) + + Examples + -------- + + This example is the adapted version of ``fftlogtest.f`` which is provided + in [2]_. It evaluates the integral + + .. math:: + + \int^\infty_0 r^{\mu+1} \exp(-r^2/2) J_\mu(k, r) k dr + = k^{\mu+1} \exp(-k^2/2) . + + >>> import numpy as np + >>> from scipy import fft + >>> import matplotlib.pyplot as plt + + Parameters for the transform. + + >>> mu = 0.0 # Order mu of Bessel function + >>> r = np.logspace(-7, 1, 128) # Input evaluation points + >>> dln = np.log(r[1]/r[0]) # Step size + >>> offset = fft.fhtoffset(dln, initial=-6*np.log(10), mu=mu) + >>> k = np.exp(offset)/r[::-1] # Output evaluation points + + Define the analytical function. + + >>> def f(x, mu): + ... """Analytical function: x^(mu+1) exp(-x^2/2).""" + ... return x**(mu + 1)*np.exp(-x**2/2) + + Evaluate the function at ``r`` and compute the corresponding values at + ``k`` using FFTLog. + + >>> a_r = f(r, mu) + >>> fht = fft.fht(a_r, dln, mu=mu, offset=offset) + + For this example we can actually compute the analytical response (which in + this case is the same as the input function) for comparison and compute the + relative error. + + >>> a_k = f(k, mu) + >>> rel_err = abs((fht-a_k)/a_k) + + Plot the result. + + >>> figargs = {'sharex': True, 'sharey': True, 'constrained_layout': True} + >>> fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4), **figargs) + >>> ax1.set_title(r'$r^{\mu+1}\ \exp(-r^2/2)$') + >>> ax1.loglog(r, a_r, 'k', lw=2) + >>> ax1.set_xlabel('r') + >>> ax2.set_title(r'$k^{\mu+1} \exp(-k^2/2)$') + >>> ax2.loglog(k, a_k, 'k', lw=2, label='Analytical') + >>> ax2.loglog(k, fht, 'C3--', lw=2, label='FFTLog') + >>> ax2.set_xlabel('k') + >>> ax2.legend(loc=3, framealpha=1) + >>> ax2.set_ylim([1e-10, 1e1]) + >>> ax2b = ax2.twinx() + >>> ax2b.loglog(k, rel_err, 'C0', label='Rel. Error (-)') + >>> ax2b.set_ylabel('Rel. Error (-)', color='C0') + >>> ax2b.tick_params(axis='y', labelcolor='C0') + >>> ax2b.legend(loc=4, framealpha=1) + >>> ax2b.set_ylim([1e-9, 1e-3]) + >>> plt.show() + + ''' + return (Dispatchable(a, np.ndarray),) + + +@_dispatch +def ifht(A, dln, mu, offset=0.0, bias=0.0): + r"""Compute the inverse fast Hankel transform. + + Computes the discrete inverse Hankel transform of a logarithmically spaced + periodic sequence. This is the inverse operation to `fht`. + + Parameters + ---------- + A : array_like (..., n) + Real periodic input array, uniformly logarithmically spaced. For + multidimensional input, the transform is performed over the last axis. + dln : float + Uniform logarithmic spacing of the input array. + mu : float + Order of the Hankel transform, any positive or negative real number. + offset : float, optional + Offset of the uniform logarithmic spacing of the output array. + bias : float, optional + Exponent of power law bias, any positive or negative real number. + + Returns + ------- + a : array_like (..., n) + The transformed output array, which is real, periodic, uniformly + logarithmically spaced, and of the same shape as the input array. + + See Also + -------- + fht : Definition of the fast Hankel transform. + fhtoffset : Return an optimal offset for `ifht`. + + Notes + ----- + This function computes a discrete version of the Hankel transform + + .. math:: + + a(r) = \int_{0}^{\infty} \! A(k) \, J_\mu(kr) \, r \, dk \;, + + where :math:`J_\mu` is the Bessel function of order :math:`\mu`. The index + :math:`\mu` may be any real number, positive or negative. Note that the + numerical inverse Hankel transform uses an integrand of :math:`r \, dk`, while the + mathematical inverse Hankel transform is commonly defined using :math:`k \, dk`. + + See `fht` for further details. + """ + return (Dispatchable(A, np.ndarray),) diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/fft/_fftlog_backend.py b/llmeval-env/lib/python3.10/site-packages/scipy/fft/_fftlog_backend.py new file mode 100644 index 0000000000000000000000000000000000000000..0f262b22af74a888633069b96ab408cd4a936f32 --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/scipy/fft/_fftlog_backend.py @@ -0,0 +1,197 @@ +import numpy as np +from warnings import warn +from ._basic import rfft, irfft +from ..special import loggamma, poch + +from scipy._lib._array_api import array_namespace, copy + +__all__ = ['fht', 'ifht', 'fhtoffset'] + +# constants +LN_2 = np.log(2) + + +def fht(a, dln, mu, offset=0.0, bias=0.0): + xp = array_namespace(a) + + # size of transform + n = a.shape[-1] + + # bias input array + if bias != 0: + # a_q(r) = a(r) (r/r_c)^{-q} + j_c = (n-1)/2 + j = xp.arange(n, dtype=xp.float64) + a = a * xp.exp(-bias*(j - j_c)*dln) + + # compute FHT coefficients + u = xp.asarray(fhtcoeff(n, dln, mu, offset=offset, bias=bias)) + + # transform + A = _fhtq(a, u, xp=xp) + + # bias output array + if bias != 0: + # A(k) = A_q(k) (k/k_c)^{-q} (k_c r_c)^{-q} + A *= xp.exp(-bias*((j - j_c)*dln + offset)) + + return A + + +def ifht(A, dln, mu, offset=0.0, bias=0.0): + xp = array_namespace(A) + + # size of transform + n = A.shape[-1] + + # bias input array + if bias != 0: + # A_q(k) = A(k) (k/k_c)^{q} (k_c r_c)^{q} + j_c = (n-1)/2 + j = xp.arange(n, dtype=xp.float64) + A = A * xp.exp(bias*((j - j_c)*dln + offset)) + + # compute FHT coefficients + u = xp.asarray(fhtcoeff(n, dln, mu, offset=offset, bias=bias, inverse=True)) + + # transform + a = _fhtq(A, u, inverse=True, xp=xp) + + # bias output array + if bias != 0: + # a(r) = a_q(r) (r/r_c)^{q} + a /= xp.exp(-bias*(j - j_c)*dln) + + return a + + +def fhtcoeff(n, dln, mu, offset=0.0, bias=0.0, inverse=False): + """Compute the coefficient array for a fast Hankel transform.""" + lnkr, q = offset, bias + + # Hankel transform coefficients + # u_m = (kr)^{-i 2m pi/(n dlnr)} U_mu(q + i 2m pi/(n dlnr)) + # with U_mu(x) = 2^x Gamma((mu+1+x)/2)/Gamma((mu+1-x)/2) + xp = (mu+1+q)/2 + xm = (mu+1-q)/2 + y = np.linspace(0, np.pi*(n//2)/(n*dln), n//2+1) + u = np.empty(n//2+1, dtype=complex) + v = np.empty(n//2+1, dtype=complex) + u.imag[:] = y + u.real[:] = xm + loggamma(u, out=v) + u.real[:] = xp + loggamma(u, out=u) + y *= 2*(LN_2 - lnkr) + u.real -= v.real + u.real += LN_2*q + u.imag += v.imag + u.imag += y + np.exp(u, out=u) + + # fix last coefficient to be real + u.imag[-1] = 0 + + # deal with special cases + if not np.isfinite(u[0]): + # write u_0 = 2^q Gamma(xp)/Gamma(xm) = 2^q poch(xm, xp-xm) + # poch() handles special cases for negative integers correctly + u[0] = 2**q * poch(xm, xp-xm) + # the coefficient may be inf or 0, meaning the transform or the + # inverse transform, respectively, is singular + + # check for singular transform or singular inverse transform + if np.isinf(u[0]) and not inverse: + warn('singular transform; consider changing the bias', stacklevel=3) + # fix coefficient to obtain (potentially correct) transform anyway + u = copy(u) + u[0] = 0 + elif u[0] == 0 and inverse: + warn('singular inverse transform; consider changing the bias', stacklevel=3) + # fix coefficient to obtain (potentially correct) inverse anyway + u = copy(u) + u[0] = np.inf + + return u + + +def fhtoffset(dln, mu, initial=0.0, bias=0.0): + """Return optimal offset for a fast Hankel transform. + + Returns an offset close to `initial` that fulfils the low-ringing + condition of [1]_ for the fast Hankel transform `fht` with logarithmic + spacing `dln`, order `mu` and bias `bias`. + + Parameters + ---------- + dln : float + Uniform logarithmic spacing of the transform. + mu : float + Order of the Hankel transform, any positive or negative real number. + initial : float, optional + Initial value for the offset. Returns the closest value that fulfils + the low-ringing condition. + bias : float, optional + Exponent of power law bias, any positive or negative real number. + + Returns + ------- + offset : float + Optimal offset of the uniform logarithmic spacing of the transform that + fulfils a low-ringing condition. + + Examples + -------- + >>> from scipy.fft import fhtoffset + >>> dln = 0.1 + >>> mu = 2.0 + >>> initial = 0.5 + >>> bias = 0.0 + >>> offset = fhtoffset(dln, mu, initial, bias) + >>> offset + 0.5454581477676637 + + See Also + -------- + fht : Definition of the fast Hankel transform. + + References + ---------- + .. [1] Hamilton A. J. S., 2000, MNRAS, 312, 257 (astro-ph/9905191) + + """ + + lnkr, q = initial, bias + + xp = (mu+1+q)/2 + xm = (mu+1-q)/2 + y = np.pi/(2*dln) + zp = loggamma(xp + 1j*y) + zm = loggamma(xm + 1j*y) + arg = (LN_2 - lnkr)/dln + (zp.imag + zm.imag)/np.pi + return lnkr + (arg - np.round(arg))*dln + + +def _fhtq(a, u, inverse=False, *, xp=None): + """Compute the biased fast Hankel transform. + + This is the basic FFTLog routine. + """ + if xp is None: + xp = np + + # size of transform + n = a.shape[-1] + + # biased fast Hankel transform via real FFT + A = rfft(a, axis=-1) + if not inverse: + # forward transform + A *= u + else: + # backward transform + A /= xp.conj(u) + A = irfft(A, n, axis=-1) + A = xp.flip(A, axis=-1) + + return A diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/fft/_helper.py b/llmeval-env/lib/python3.10/site-packages/scipy/fft/_helper.py new file mode 100644 index 0000000000000000000000000000000000000000..aaa9a107be35f9efacf4b15f958ad57787723443 --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/scipy/fft/_helper.py @@ -0,0 +1,313 @@ +from functools import update_wrapper, lru_cache +import inspect + +from ._pocketfft import helper as _helper + +import numpy as np +from scipy._lib._array_api import array_namespace + + +def next_fast_len(target, real=False): + """Find the next fast size of input data to ``fft``, for zero-padding, etc. + + SciPy's FFT algorithms gain their speed by a recursive divide and conquer + strategy. This relies on efficient functions for small prime factors of the + input length. Thus, the transforms are fastest when using composites of the + prime factors handled by the fft implementation. If there are efficient + functions for all radices <= `n`, then the result will be a number `x` + >= ``target`` with only prime factors < `n`. (Also known as `n`-smooth + numbers) + + Parameters + ---------- + target : int + Length to start searching from. Must be a positive integer. + real : bool, optional + True if the FFT involves real input or output (e.g., `rfft` or `hfft` + but not `fft`). Defaults to False. + + Returns + ------- + out : int + The smallest fast length greater than or equal to ``target``. + + Notes + ----- + The result of this function may change in future as performance + considerations change, for example, if new prime factors are added. + + Calling `fft` or `ifft` with real input data performs an ``'R2C'`` + transform internally. + + Examples + -------- + On a particular machine, an FFT of prime length takes 11.4 ms: + + >>> from scipy import fft + >>> import numpy as np + >>> rng = np.random.default_rng() + >>> min_len = 93059 # prime length is worst case for speed + >>> a = rng.standard_normal(min_len) + >>> b = fft.fft(a) + + Zero-padding to the next regular length reduces computation time to + 1.6 ms, a speedup of 7.3 times: + + >>> fft.next_fast_len(min_len, real=True) + 93312 + >>> b = fft.fft(a, 93312) + + Rounding up to the next power of 2 is not optimal, taking 3.0 ms to + compute; 1.9 times longer than the size given by ``next_fast_len``: + + >>> b = fft.fft(a, 131072) + + """ + pass + + +# Directly wrap the c-function good_size but take the docstring etc., from the +# next_fast_len function above +_sig = inspect.signature(next_fast_len) +next_fast_len = update_wrapper(lru_cache(_helper.good_size), next_fast_len) +next_fast_len.__wrapped__ = _helper.good_size +next_fast_len.__signature__ = _sig + + +def _init_nd_shape_and_axes(x, shape, axes): + """Handle shape and axes arguments for N-D transforms. + + Returns the shape and axes in a standard form, taking into account negative + values and checking for various potential errors. + + Parameters + ---------- + x : array_like + The input array. + shape : int or array_like of ints or None + The shape of the result. If both `shape` and `axes` (see below) are + None, `shape` is ``x.shape``; if `shape` is None but `axes` is + not None, then `shape` is ``numpy.take(x.shape, axes, axis=0)``. + If `shape` is -1, the size of the corresponding dimension of `x` is + used. + axes : int or array_like of ints or None + Axes along which the calculation is computed. + The default is over all axes. + Negative indices are automatically converted to their positive + counterparts. + + Returns + ------- + shape : tuple + The shape of the result as a tuple of integers. + axes : list + Axes along which the calculation is computed, as a list of integers. + + """ + x = np.asarray(x) + return _helper._init_nd_shape_and_axes(x, shape, axes) + + +def fftfreq(n, d=1.0, *, xp=None, device=None): + """Return the Discrete Fourier Transform sample frequencies. + + The returned float array `f` contains the frequency bin centers in cycles + per unit of the sample spacing (with zero at the start). For instance, if + the sample spacing is in seconds, then the frequency unit is cycles/second. + + Given a window length `n` and a sample spacing `d`:: + + f = [0, 1, ..., n/2-1, -n/2, ..., -1] / (d*n) if n is even + f = [0, 1, ..., (n-1)/2, -(n-1)/2, ..., -1] / (d*n) if n is odd + + Parameters + ---------- + n : int + Window length. + d : scalar, optional + Sample spacing (inverse of the sampling rate). Defaults to 1. + xp : array_namespace, optional + The namespace for the return array. Default is None, where NumPy is used. + device : device, optional + The device for the return array. + Only valid when `xp.fft.fftfreq` implements the device parameter. + + Returns + ------- + f : ndarray + Array of length `n` containing the sample frequencies. + + Examples + -------- + >>> import numpy as np + >>> import scipy.fft + >>> signal = np.array([-2, 8, 6, 4, 1, 0, 3, 5], dtype=float) + >>> fourier = scipy.fft.fft(signal) + >>> n = signal.size + >>> timestep = 0.1 + >>> freq = scipy.fft.fftfreq(n, d=timestep) + >>> freq + array([ 0. , 1.25, 2.5 , ..., -3.75, -2.5 , -1.25]) + + """ + xp = np if xp is None else xp + # numpy does not yet support the `device` keyword + # `xp.__name__ != 'numpy'` should be removed when numpy is compatible + if hasattr(xp, 'fft') and xp.__name__ != 'numpy': + return xp.fft.fftfreq(n, d=d, device=device) + if device is not None: + raise ValueError('device parameter is not supported for input array type') + return np.fft.fftfreq(n, d=d) + + +def rfftfreq(n, d=1.0, *, xp=None, device=None): + """Return the Discrete Fourier Transform sample frequencies + (for usage with rfft, irfft). + + The returned float array `f` contains the frequency bin centers in cycles + per unit of the sample spacing (with zero at the start). For instance, if + the sample spacing is in seconds, then the frequency unit is cycles/second. + + Given a window length `n` and a sample spacing `d`:: + + f = [0, 1, ..., n/2-1, n/2] / (d*n) if n is even + f = [0, 1, ..., (n-1)/2-1, (n-1)/2] / (d*n) if n is odd + + Unlike `fftfreq` (but like `scipy.fftpack.rfftfreq`) + the Nyquist frequency component is considered to be positive. + + Parameters + ---------- + n : int + Window length. + d : scalar, optional + Sample spacing (inverse of the sampling rate). Defaults to 1. + xp : array_namespace, optional + The namespace for the return array. Default is None, where NumPy is used. + device : device, optional + The device for the return array. + Only valid when `xp.fft.rfftfreq` implements the device parameter. + + Returns + ------- + f : ndarray + Array of length ``n//2 + 1`` containing the sample frequencies. + + Examples + -------- + >>> import numpy as np + >>> import scipy.fft + >>> signal = np.array([-2, 8, 6, 4, 1, 0, 3, 5, -3, 4], dtype=float) + >>> fourier = scipy.fft.rfft(signal) + >>> n = signal.size + >>> sample_rate = 100 + >>> freq = scipy.fft.fftfreq(n, d=1./sample_rate) + >>> freq + array([ 0., 10., 20., ..., -30., -20., -10.]) + >>> freq = scipy.fft.rfftfreq(n, d=1./sample_rate) + >>> freq + array([ 0., 10., 20., 30., 40., 50.]) + + """ + xp = np if xp is None else xp + # numpy does not yet support the `device` keyword + # `xp.__name__ != 'numpy'` should be removed when numpy is compatible + if hasattr(xp, 'fft') and xp.__name__ != 'numpy': + return xp.fft.rfftfreq(n, d=d, device=device) + if device is not None: + raise ValueError('device parameter is not supported for input array type') + return np.fft.rfftfreq(n, d=d) + + +def fftshift(x, axes=None): + """Shift the zero-frequency component to the center of the spectrum. + + This function swaps half-spaces for all axes listed (defaults to all). + Note that ``y[0]`` is the Nyquist component only if ``len(x)`` is even. + + Parameters + ---------- + x : array_like + Input array. + axes : int or shape tuple, optional + Axes over which to shift. Default is None, which shifts all axes. + + Returns + ------- + y : ndarray + The shifted array. + + See Also + -------- + ifftshift : The inverse of `fftshift`. + + Examples + -------- + >>> import numpy as np + >>> freqs = np.fft.fftfreq(10, 0.1) + >>> freqs + array([ 0., 1., 2., ..., -3., -2., -1.]) + >>> np.fft.fftshift(freqs) + array([-5., -4., -3., -2., -1., 0., 1., 2., 3., 4.]) + + Shift the zero-frequency component only along the second axis: + + >>> freqs = np.fft.fftfreq(9, d=1./9).reshape(3, 3) + >>> freqs + array([[ 0., 1., 2.], + [ 3., 4., -4.], + [-3., -2., -1.]]) + >>> np.fft.fftshift(freqs, axes=(1,)) + array([[ 2., 0., 1.], + [-4., 3., 4.], + [-1., -3., -2.]]) + + """ + xp = array_namespace(x) + if hasattr(xp, 'fft'): + return xp.fft.fftshift(x, axes=axes) + x = np.asarray(x) + y = np.fft.fftshift(x, axes=axes) + return xp.asarray(y) + + +def ifftshift(x, axes=None): + """The inverse of `fftshift`. Although identical for even-length `x`, the + functions differ by one sample for odd-length `x`. + + Parameters + ---------- + x : array_like + Input array. + axes : int or shape tuple, optional + Axes over which to calculate. Defaults to None, which shifts all axes. + + Returns + ------- + y : ndarray + The shifted array. + + See Also + -------- + fftshift : Shift zero-frequency component to the center of the spectrum. + + Examples + -------- + >>> import numpy as np + >>> freqs = np.fft.fftfreq(9, d=1./9).reshape(3, 3) + >>> freqs + array([[ 0., 1., 2.], + [ 3., 4., -4.], + [-3., -2., -1.]]) + >>> np.fft.ifftshift(np.fft.fftshift(freqs)) + array([[ 0., 1., 2.], + [ 3., 4., -4.], + [-3., -2., -1.]]) + + """ + xp = array_namespace(x) + if hasattr(xp, 'fft'): + return xp.fft.ifftshift(x, axes=axes) + x = np.asarray(x) + y = np.fft.ifftshift(x, axes=axes) + return xp.asarray(y) diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/misc/__init__.py b/llmeval-env/lib/python3.10/site-packages/scipy/misc/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..90b393b4ff585e467d781e9e5a6060cafbadfc34 --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/scipy/misc/__init__.py @@ -0,0 +1,67 @@ +""" +========================================== +Miscellaneous routines (:mod:`scipy.misc`) +========================================== + +.. currentmodule:: scipy.misc + +.. deprecated:: 1.10.0 + + This module is deprecated and will be completely + removed in SciPy v2.0.0. + +Various utilities that don't have another home. + +.. autosummary:: + :toctree: generated/ + + ascent - Get example image for processing + central_diff_weights - Weights for an n-point central mth derivative + derivative - Find the nth derivative of a function at a point + face - Get example image for processing + electrocardiogram - Load an example of a 1-D signal + +""" + + +from ._common import * +from . import _common +import warnings + +# Deprecated namespaces, to be removed in v2.0.0 +from . import common, doccer + +__all__ = _common.__all__ + +dataset_methods = ['ascent', 'face', 'electrocardiogram'] + + +def __dir__(): + return __all__ + + +def __getattr__(name): + if name not in __all__: + raise AttributeError( + "scipy.misc is deprecated and has no attribute " + f"{name}.") + + if name in dataset_methods: + msg = ("The module `scipy.misc` is deprecated and will be " + "completely removed in SciPy v2.0.0. " + f"All dataset methods including {name}, must be imported " + "directly from the new `scipy.datasets` module.") + else: + msg = (f"The method `{name}` from the `scipy.misc` namespace is" + " deprecated, and will be removed in SciPy v1.12.0.") + + warnings.warn(msg, category=DeprecationWarning, stacklevel=2) + + return getattr(name) + + +del _common + +from scipy._lib._testutils import PytestTester +test = PytestTester(__name__) +del PytestTester diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/misc/__pycache__/_common.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/scipy/misc/__pycache__/_common.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..222121159a3cebe6b90f72f32981ae3360133862 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/scipy/misc/__pycache__/_common.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/misc/__pycache__/doccer.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/scipy/misc/__pycache__/doccer.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0365d9636500b6506d0d239c7aaefabdf2428a43 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/scipy/misc/__pycache__/doccer.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/misc/_common.py b/llmeval-env/lib/python3.10/site-packages/scipy/misc/_common.py new file mode 100644 index 0000000000000000000000000000000000000000..ae9dfcc704b3cf8870c0c78b58e9957a09f9eeb9 --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/scipy/misc/_common.py @@ -0,0 +1,344 @@ +""" +Functions which are common and require SciPy Base and Level 1 SciPy +(special, linalg) +""" + +from scipy._lib.deprecation import _deprecated +from scipy._lib._finite_differences import _central_diff_weights, _derivative +from numpy import array, frombuffer, load + + +__all__ = ['central_diff_weights', 'derivative', 'ascent', 'face', + 'electrocardiogram'] + + +@_deprecated(msg="scipy.misc.central_diff_weights is deprecated in " + "SciPy v1.10.0; and will be completely removed in " + "SciPy v1.12.0. You may consider using " + "findiff: https://github.com/maroba/findiff or " + "numdifftools: https://github.com/pbrod/numdifftools") +def central_diff_weights(Np, ndiv=1): + """ + Return weights for an Np-point central derivative. + + Assumes equally-spaced function points. + + If weights are in the vector w, then + derivative is w[0] * f(x-ho*dx) + ... + w[-1] * f(x+h0*dx) + + .. deprecated:: 1.10.0 + `central_diff_weights` has been deprecated from + `scipy.misc.central_diff_weights` in SciPy 1.10.0 and + it will be completely removed in SciPy 1.12.0. + You may consider using + findiff: https://github.com/maroba/findiff or + numdifftools: https://github.com/pbrod/numdifftools + + Parameters + ---------- + Np : int + Number of points for the central derivative. + ndiv : int, optional + Number of divisions. Default is 1. + + Returns + ------- + w : ndarray + Weights for an Np-point central derivative. Its size is `Np`. + + Notes + ----- + Can be inaccurate for a large number of points. + + Examples + -------- + We can calculate a derivative value of a function. + + >>> from scipy.misc import central_diff_weights + >>> def f(x): + ... return 2 * x**2 + 3 + >>> x = 3.0 # derivative point + >>> h = 0.1 # differential step + >>> Np = 3 # point number for central derivative + >>> weights = central_diff_weights(Np) # weights for first derivative + >>> vals = [f(x + (i - Np/2) * h) for i in range(Np)] + >>> sum(w * v for (w, v) in zip(weights, vals))/h + 11.79999999999998 + + This value is close to the analytical solution: + f'(x) = 4x, so f'(3) = 12 + + References + ---------- + .. [1] https://en.wikipedia.org/wiki/Finite_difference + + """ + return _central_diff_weights(Np, ndiv) + + +@_deprecated(msg="scipy.misc.derivative is deprecated in " + "SciPy v1.10.0; and will be completely removed in " + "SciPy v1.12.0. You may consider using " + "findiff: https://github.com/maroba/findiff or " + "numdifftools: https://github.com/pbrod/numdifftools") +def derivative(func, x0, dx=1.0, n=1, args=(), order=3): + """ + Find the nth derivative of a function at a point. + + Given a function, use a central difference formula with spacing `dx` to + compute the nth derivative at `x0`. + + .. deprecated:: 1.10.0 + `derivative` has been deprecated from `scipy.misc.derivative` + in SciPy 1.10.0 and it will be completely removed in SciPy 1.12.0. + You may consider using + findiff: https://github.com/maroba/findiff or + numdifftools: https://github.com/pbrod/numdifftools + + Parameters + ---------- + func : function + Input function. + x0 : float + The point at which the nth derivative is found. + dx : float, optional + Spacing. + n : int, optional + Order of the derivative. Default is 1. + args : tuple, optional + Arguments + order : int, optional + Number of points to use, must be odd. + + Notes + ----- + Decreasing the step size too small can result in round-off error. + + Examples + -------- + >>> from scipy.misc import derivative + >>> def f(x): + ... return x**3 + x**2 + >>> derivative(f, 1.0, dx=1e-6) + 4.9999999999217337 + + """ + return _derivative(func, x0, dx, n, args, order) + + +@_deprecated(msg="scipy.misc.ascent has been deprecated in SciPy v1.10.0;" + " and will be completely removed in SciPy v1.12.0. " + "Dataset methods have moved into the scipy.datasets " + "module. Use scipy.datasets.ascent instead.") +def ascent(): + """ + Get an 8-bit grayscale bit-depth, 512 x 512 derived image for easy use in demos + + The image is derived from accent-to-the-top.jpg at + http://www.public-domain-image.com/people-public-domain-images-pictures/ + + .. deprecated:: 1.10.0 + `ascent` has been deprecated from `scipy.misc.ascent` + in SciPy 1.10.0 and it will be completely removed in SciPy 1.12.0. + Dataset methods have moved into the `scipy.datasets` module. + Use `scipy.datasets.ascent` instead. + + Parameters + ---------- + None + + Returns + ------- + ascent : ndarray + convenient image to use for testing and demonstration + + Examples + -------- + >>> import scipy.misc + >>> ascent = scipy.misc.ascent() + >>> ascent.shape + (512, 512) + >>> ascent.max() + 255 + + >>> import matplotlib.pyplot as plt + >>> plt.gray() + >>> plt.imshow(ascent) + >>> plt.show() + + """ + import pickle + import os + fname = os.path.join(os.path.dirname(__file__),'ascent.dat') + with open(fname, 'rb') as f: + ascent = array(pickle.load(f)) + return ascent + + +@_deprecated(msg="scipy.misc.face has been deprecated in SciPy v1.10.0; " + "and will be completely removed in SciPy v1.12.0. " + "Dataset methods have moved into the scipy.datasets " + "module. Use scipy.datasets.face instead.") +def face(gray=False): + """ + Get a 1024 x 768, color image of a raccoon face. + + raccoon-procyon-lotor.jpg at http://www.public-domain-image.com + + .. deprecated:: 1.10.0 + `face` has been deprecated from `scipy.misc.face` + in SciPy 1.10.0 and it will be completely removed in SciPy 1.12.0. + Dataset methods have moved into the `scipy.datasets` module. + Use `scipy.datasets.face` instead. + + Parameters + ---------- + gray : bool, optional + If True return 8-bit grey-scale image, otherwise return a color image + + Returns + ------- + face : ndarray + image of a raccoon face + + Examples + -------- + >>> import scipy.misc + >>> face = scipy.misc.face() + >>> face.shape + (768, 1024, 3) + >>> face.max() + 255 + >>> face.dtype + dtype('uint8') + + >>> import matplotlib.pyplot as plt + >>> plt.gray() + >>> plt.imshow(face) + >>> plt.show() + + """ + import bz2 + import os + with open(os.path.join(os.path.dirname(__file__), 'face.dat'), 'rb') as f: + rawdata = f.read() + data = bz2.decompress(rawdata) + face = frombuffer(data, dtype='uint8') + face.shape = (768, 1024, 3) + if gray is True: + face = (0.21 * face[:,:,0] + + 0.71 * face[:,:,1] + + 0.07 * face[:,:,2]).astype('uint8') + return face + + +@_deprecated(msg="scipy.misc.electrocardiogram has been " + "deprecated in SciPy v1.10.0; and will " + "be completely removed in SciPy v1.12.0. " + "Dataset methods have moved into the scipy.datasets " + "module. Use scipy.datasets.electrocardiogram instead.") +def electrocardiogram(): + """ + Load an electrocardiogram as an example for a 1-D signal. + + The returned signal is a 5 minute long electrocardiogram (ECG), a medical + recording of the heart's electrical activity, sampled at 360 Hz. + + .. deprecated:: 1.10.0 + `electrocardiogram` has been deprecated from + `scipy.misc.electrocardiogram` in SciPy 1.10.0 and it will be + completely removed in SciPy 1.12.0. + Dataset methods have moved into the `scipy.datasets` module. + Use `scipy.datasets.electrocardiogram` instead. + + Returns + ------- + ecg : ndarray + The electrocardiogram in millivolt (mV) sampled at 360 Hz. + + Notes + ----- + The provided signal is an excerpt (19:35 to 24:35) from the `record 208`_ + (lead MLII) provided by the MIT-BIH Arrhythmia Database [1]_ on + PhysioNet [2]_. The excerpt includes noise induced artifacts, typical + heartbeats as well as pathological changes. + + .. _record 208: https://physionet.org/physiobank/database/html/mitdbdir/records.htm#208 + + .. versionadded:: 1.1.0 + + References + ---------- + .. [1] Moody GB, Mark RG. The impact of the MIT-BIH Arrhythmia Database. + IEEE Eng in Med and Biol 20(3):45-50 (May-June 2001). + (PMID: 11446209); :doi:`10.13026/C2F305` + .. [2] Goldberger AL, Amaral LAN, Glass L, Hausdorff JM, Ivanov PCh, + Mark RG, Mietus JE, Moody GB, Peng C-K, Stanley HE. PhysioBank, + PhysioToolkit, and PhysioNet: Components of a New Research Resource + for Complex Physiologic Signals. Circulation 101(23):e215-e220; + :doi:`10.1161/01.CIR.101.23.e215` + + Examples + -------- + >>> from scipy.misc import electrocardiogram + >>> ecg = electrocardiogram() + >>> ecg + array([-0.245, -0.215, -0.185, ..., -0.405, -0.395, -0.385]) + >>> ecg.shape, ecg.mean(), ecg.std() + ((108000,), -0.16510875, 0.5992473991177294) + + As stated the signal features several areas with a different morphology. + E.g., the first few seconds show the electrical activity of a heart in + normal sinus rhythm as seen below. + + >>> import numpy as np + >>> import matplotlib.pyplot as plt + >>> fs = 360 + >>> time = np.arange(ecg.size) / fs + >>> plt.plot(time, ecg) + >>> plt.xlabel("time in s") + >>> plt.ylabel("ECG in mV") + >>> plt.xlim(9, 10.2) + >>> plt.ylim(-1, 1.5) + >>> plt.show() + + After second 16, however, the first premature ventricular contractions, also + called extrasystoles, appear. These have a different morphology compared to + typical heartbeats. The difference can easily be observed in the following + plot. + + >>> plt.plot(time, ecg) + >>> plt.xlabel("time in s") + >>> plt.ylabel("ECG in mV") + >>> plt.xlim(46.5, 50) + >>> plt.ylim(-2, 1.5) + >>> plt.show() + + At several points large artifacts disturb the recording, e.g.: + + >>> plt.plot(time, ecg) + >>> plt.xlabel("time in s") + >>> plt.ylabel("ECG in mV") + >>> plt.xlim(207, 215) + >>> plt.ylim(-2, 3.5) + >>> plt.show() + + Finally, examining the power spectrum reveals that most of the biosignal is + made up of lower frequencies. At 60 Hz the noise induced by the mains + electricity can be clearly observed. + + >>> from scipy.signal import welch + >>> f, Pxx = welch(ecg, fs=fs, nperseg=2048, scaling="spectrum") + >>> plt.semilogy(f, Pxx) + >>> plt.xlabel("Frequency in Hz") + >>> plt.ylabel("Power spectrum of the ECG in mV**2") + >>> plt.xlim(f[[0, -1]]) + >>> plt.show() + """ + import os + file_path = os.path.join(os.path.dirname(__file__), "ecg.dat") + with load(file_path) as file: + ecg = file["ecg"].astype(int) # np.uint16 -> int + # Convert raw output of ADC to mV: (ecg - adc_zero) / adc_gain + ecg = (ecg - 1024) / 200.0 + return ecg diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/misc/ascent.dat b/llmeval-env/lib/python3.10/site-packages/scipy/misc/ascent.dat new file mode 100644 index 0000000000000000000000000000000000000000..f3602460a5170a78ef09b038171853ce8e76fca7 --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/scipy/misc/ascent.dat @@ -0,0 +1,749 @@ +€]q(]q(KSKSKSKSKSKSKSKRKRKRKRKRKRKRKRKRKRKSKSKSKSKSKSKSKRKRKRKRKRKRKRKRKRKUKVKUKUKUKVKVKVKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKVKTKUKVKUKUKUKUKVKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKYK[KZK[KZKZKZKZK[KXKWKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K[KZKZKZKZKZKZK[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K_K_K`K]K\K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKdKdKaKaKaKcKeKdKdKdKdKeKbK^KOKQKRKTKRKVKTKVKNKRKMKOKIKPKYKXKRKPKUK`KjK[KSKRKUK9K!K$K%K&K&K'K*K0K K +K KKKKKCKBKAKEK*KKKK!K)K-K(K)K-K+K"KKKK8KBKK9K2K/K/K+K"KKK!K/K0K$K+K3K5K4K?KGKAK;K9K-K+K+K+K$K8KGKFKFKFKFKFKFKFKFKFKFKGK6KK$KBKIKJKJKHKHKAK9K=K=K=KKKHKFKFKFKFKFKFKFKGKFKGKHK2KK*KEKFKHKIKHKGK?KKdKsKrKtKsKsKsKsKsKsKsKsKsKsKuKuKsKtKuKtKsKtKtKtKtKvKtKsKsKsKuKuKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKue]q(KPKQKSKSKSKSKSKRKRKRKRKRKRKRKRKRKRKSKSKSKSKSKSKSKRKRKRKRKRKRKRKRKRKUKVKUKUKUKUKUKUKUKUKUKVKTKUKVKUKUKUKUKUKUKWKXKUKUKUKUKUKUKUKWKWKUKVKXKWKWKUKVKWKWKWKWKWKXKXKWKWKWKWKWKWKWKWKWKWKWKWKZK[K[KYKWKWKWKZKZKZKZK[KXKWKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKYKZKZKZKZKZKZKZK[K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKdKeKdKdKdKdKeKcKaKcK^KNKTKTKVKQKVKTKSKQKUKOKTKIKCKVKZKYKMKCKJKNKVKUKSKPK*K$K&K%K!KKKKK K +K +KKKK?KAK@KK=K;K;K?K?K=KK.K-K+K)K KKKK'K'K&K%K)K$K K"K%K%K1K>K(K)K)K+K"KKKK0KDKDKFKGKFKFKFKFKFKGKFKFKFK)KK4KFKGKIKHKFKEK@K;KK=K=K=KK=KK:K:K9KK?K=KK?K=K=K=K;K4K*K,K0K4K8K7K5K4K3K1K0K/K0K4K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K1K6KYKrKtKsKsKsKsKsKsKsKsKsKsKsKtKvKvKvKuKuKsKtKvKtKsKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKue]q(KSKRKSKSKSKSKSKSKSKSKSKSKSKSKRKRKRKRKRKRKSKUKTKRKSKRKSKSKUKUKTKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKVKVKUKVKTKVKUKUKUKUKUKUKVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKUKUKXKWKWKXKWKXKYK[KYKXKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[KZKZKZKZKZKZK[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K_K]K\K\K\K\K]K]K^K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaK`K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKdKbKaKdKdKeKcKbKdKeKdKdKeKcKbKbKXKOKQKWKWKTKVKUKWKSKWKRKVKLKMKLKPKDKNKSK]KhKPKVKVKBK!K&K%K&KK K K +K KKK K K KKKKKKKK K KKKKKKKKKKKKKKKKKKKKK KKKKKKKKKKKKK#K)K'K)K&KKKKKKKKKKKKKKK1K/K(K+K(K%KKKKKKKKKKKKKK#K/K)K'K)K)K&KKKKKKK1KGKGKGKFKFKFKFKFKFKGKFKHKBK!KK:KHKHKIKIKGKCK?K;K=K=K=K=K>K>K=KK;KK?K=KKK?K=K=KK?K>K>K>K>KKHKHKHKIKGKBKK>KK>K>K?K>K=K;K=K>K4K'K.K2K5K5K8K6K5K2K/K*K*K,K$K0K2K2K4K3K3K3K3K3K3K3K3K3K3K3K3K3K2K0KHKlKtKsKsKtKuKtKtKtKtKuKuKuKuKuKuKuKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKvKuKuKuKuKuKuKuKuKue]q (KSKSKSKSKSKSKSKSKSKSKSKSKSKSKRKTKVKTKRKRKSKVKVKVKVKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKWKXKXKXKWKWKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKZK[K[K[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[KZKZK\K]K\K\K]K\KZK\K]KZKZK\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K`K]K\K\K]K`K`K`K]K\K\K]K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKcKeKdKeKeKeKdKdKdKdKdKdKdKeKdKaK`KUKSKUKYKWKWKYKWKVKUKVKTKZKRKVKLKGKWKDKMKIKBKTKSKNK(K"K%K&K!K K +K +K K +K +KKK K +K K K K K KKKKK K K K K K K K K K K K K K K K K K K K K K +K K +KK K K K K KKKKKKKKK K K K K K K K K K KKKKKKKKKK K K K K K K K K KKKKKKKKKKKKK K KKKKKKKK%KDKGKFKFKFKFKFKGKFKGKIKHKGK3KK#KEKGKHKHKHKIKBK:KKK?K?K>KK=K>K?K>KK=KK?K=KKK?K=KK?K=K=K>K>K>K>K>K>K>K?K>K=K5K+K2K6K3K4K6K5K1K2K/K*KKKK2K6K2K4K4K5K5K4K3K3K4K4K4K3K3K4K4K3K0KK?K=K=K>K?K?K?K>K?K?K?K>KK>K>K>K>K>K>K>K>K?K>KK3K*K0K/K4K7K8K5K3K2K0K+KKKK,K4K4K3K4K5K3K3K3K3K3K3K3K3K3K4K4K4K3K9KYKrKsKrKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKue]q(KSKSKSKSKSKSKSKRKSKSKTKVKUKUKSKTKVKUKVKVKVKUKUKUKUKUKUKUKTKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKVKVKVKVKUKVKXKWKVKVKVKWKWKWKWKWKVKVKWKXKWKWKWKWKWKWKWKWKWKWKWKWKWKXK[KYKWKZKZKXKXKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K[KZKZK\K\K[K[K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K`K^K]K]K]K]K]K\K^K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKbKaKbKbKcKeKdKdKdKdKdKdKdKdKdKdKdKeKdKaKXKTKRKXKYKWKXKWKYKTKWKWKYKXKXK[KPKWKXK^KdKJKTKTKQK,K$K&K&K"KK&K'K(K'K'K)K%K$K'K'K'K'K(K&K&K&K&K&K%K$K&K&K$K$K$K#K"K"K"K"K!K K K K K KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK KKKKKKKKKKKKKKK$KDKFKGKGKFKFKGKFKHKHKFKFKGK>K?KAKEKGKJKKKIKFKFK=K;K=KK?K>K>K>K?K?K?K>K?K>K=K=KKYK\KXKWKWKXKTKXKXKXKXKWK[KRKXKYKcKdKVKUKUKNK)K%K&K'K#K K&K%K&K&K$K&K'K#K%K&K%K%K%K&K&K&K&K&K&K&K&K&K&K&K&K&K&K&K&K&K&K&K&K&K&K&K&K'K'K'K'K'K&K$K$K#K$K$K$K$K$K$K$K"K!K!K!K K KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK-KEKFKGKGKFKFKGKHKHKFKGKIKHKFKEKFKFKFKIKIKHKKKFK>K=K=KK?K?K?K?K=KK?K>K>K?K>K=KK>K>K>K>K=KK?K>K>K?K=K;KK>K5K,K0K4K7K7K5K4K2K0K2K-KKKK-K3K4K4K5K5K5K3K4K4K4K4K5K4K4K3K3K3K3K4KPKoKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKwKwKwKyKwKuKuKuKwKwKxKyKxKwKwKvKvKwKwKwKvKuKwKwKuKuKuKuKuKuKue]q(KRKRKRKRKRKSKSKRKSKVKUKUKUKUKUKWKUKTKVKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKVKXKWKXKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKZKZKWKWKWKZK[KZK[K[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K\K\K\K\K\KZKZK]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K_K`K_K]K\K_K_K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKcKaKaKaKaKaKaKbKeKbKaKdKdKdKdKdKdKdKdKdKeKdK]KRKMKGK[KYKTKYKWKXKTKWKSKXKXKVK\KVKXK^KlKaKUKUKWKBK#K&K&K'K"K#K%K$K&K'K'K&K%K'K%K%K%K%K%K&K&K&K&K%K%K%K%K%K%K&K%K&K&K&K&K&K&K&K&K&K&K&K%K&K&K&K&K%K'K&K%K#K#K#K#K#K#K$K&K$K#K#K#K#K#K$K#K#K%K&K#K$K&K%K#K$K$K!K%K$K$K$K$K$K$K$K$K$K$K&K#K$K$K!K"K"K"K#K#K#K#K#K#K#K#K!K K!K!K!KKKKKKKKKKK;KDKDKFKHKFKFKGKIKIKIKGKFKFKGKGKCKFKIKIKHKHKGKDK?KK>KK?K?K?K>K>K?K=KK=K>K>K>K?K?K>K>K>K=K=K5K-K2K2K4K6K8K6K4K2K2K-KKKK-K4K5K4K4K5K5K5K4K4K3K3K3K3K3K3K3K3K3K3KJKmKsKsKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKvKuKuKvKvKuKuKuKwKxKyKxKvKvKvKwKwKuKwKyKxKwKxKwKuKuKuKwKxKxKwe]q(KVKUKRKUKVKSKSKVKVKUKUKUKUKUKVKVKVKVKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKVKXKVKUKWKWKUKUKUKUKUKUKUKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKXKWKYK[KZKZK[KZKWKYK[KXKWKWKXKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K]K\K\KZK[K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K`K_K_K`K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKdKdKaKcKeKdKeKeKeKeKdKdKdKeKdKdKdKdKdKdKdKdKdKeKdK[KOKPKVK[K\KWK[KZK[KXKYKWK\K[KYKWKUKYKaKnK\KUKUKUK.K#K'K&K$K'K=KBKHKKKKKK)KK8K/K1K1K7K1K,K-K-K.K(K%K'K$K*K0K.K.K.K.K.K.K-K*K+K(K'K'K%K&K%K%K&K&K%K#K$K%K$K$K$K$K%K$K%K$K#K#K#K$K$K$K$K#K%K&K$K$K$K$K$K$K$K$K$K$K$K#K$K$K$K$K$K$K$K$K$K#K$K$K$K$K$K$K$K#K#K#K#K$K#K!K!K*KDKGKDKGKIKHKIKHKIKGKFKHKHKFKHKBKAKEKHKIKLKJKHKEK>KK>K>K>K>K?K?K?K>KK6K-K/K4K6K8K6K5K3K2K2K.KKKK-K4K4K4K5K5K5K5K5K3K3K3K3K3K3K3K3K3K2K2KEKhKtKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKxKyKxKwKuKuKuKxKxKuKwKxKxKxKyKxKuKuKuKwKyKyKxe]q(KUKUKUKUKVKUKUKVKVKVKVKVKVKVKUKUKUKUKVKVKVKVKTKUKWKUKVKVKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKVKXKVKUKWKWKWKWKWKWKWKWKXKWKWKXKWKVKWKWKWKWKWKWKWKWKWKXKXKWKYK[KXKWKZKZKWKYK[KZKZKWKXKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\K[K[K\K\KZKZK[KZK[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K_K]K\K\K]K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`K_K_K_K_K_K_K_KaKaK_K_K_K_K_KaKaK`K_K_K`KbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKXKPKSKVK\K[KWK[KYK[KWKYKZK]KYKZKZKYKZKfKkKXKTKVKQK&K$K&K&K$K+K>KBK?KKKKKK,K;K7K5K9K5K+K+K$K7KIKDKDKCKIK;K7K8K;KBKKGKEKJKJKLKKK:K.K0K2K5K,K&K#K#K+K,K-K-K0K6K7K6K5K5K/K(K(K&K%K'K&K&K%K$K%K%K&K'K#K$K#K"K"K"K$K$K!K!K#K$K$K$K$K#K#K$K#K!K#K#K#K$K#K#K$K$K$K#K K"K$K#K$K K2KGKGKFKHKIKIKIKIKHKHKGKFKFKFKGKCKCKDKHKMKKKKKJKCKK?K?K>K>K>K?K>K=K=K=K>KK>K>K>K>K>K?K>K=KK5K/K4K5K6K7K7K4K3K2K1K-KKKK+K7K6K4K3K4K5K4K4K3K3K3K4K4K3K3K3K2K4K2K>KdKuKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKuKuKuKxKxKxKwKvKxKyKxKwKuKvKvKvKvKxKxKyKwKvKvKuKvKvKuKuKuKwKyKvKve]q(KVKVKUKVKVKVKVKVKVKVKVKVKVKVKTKUKVKUKVKVKVKUKUKUKUKVKVKVKUKVKXKVKUKUKUKUKVKXKWKWKWKWKXKXKXKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKZK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K]KZKZKZKZKZKZKZK\K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K\K\K`K_K\K^K`K_K_K_K_K_K_K_K_K_K_K_K`K^K\K_K`K_K_K_K_K_K_K_KaKaK_K_K_K_K_KaKaK_K_K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKdKdKaKcKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKeKbKUKTKYK\K^K\KWK[KXKXKVKYKYK^KXKZKZKWK]KoKhKUKVKXKIK"K&K&K&K#K3KK>K@K9KEKHKJKKKPKQKLK:K3K6K8K7K)K&K!K)K4K4K4K5KHKSKVKQK\KUKAK4K0K0K+K.K'K#K$K,K-K/K+K1KMKWKXKYKWKRK8K-K+K+K)K$K#KK'K+K*K)K&K=KDKCKCK@K=K7K%K!K!K"K KK"K%K%K%K"K%KK>K?K?K?K?K?K>KK?K>KKHKGKJKLKKKIKAK>K?K>K=K=K?K>K=K>K>K?K>K>K=K>K?K=KK6K-K2K5K6K7K9K8K3K1K/K,KKKK)K2K1K4K5K4K4K5K5K5K3K3K2K3K4K3K3K4K5K5K:K]KtKuKuKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKwKuKvKwKwKwKvKvKwKwKyKwKwKwKwKxKxKxKwKwKxKxKuKvKwKwKwKwKwe]q(KRKSKVKUKUKUKUKUKVKVKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKWKWKUKUKUKUKUKUKUKUKUKUKVKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKZKZKWKWKWKYK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K`K`K_K\K\K\K\K\K_K`K_K_K_K_K_K_K_K_K_K_K_K`K_K_K_K_K_K_K_K_K_KaKaK_K`KbKaKbKaKaKbKbKbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKcK`KTKRKXK\K_K[KWK[KZK[KVKYK\KaK[K]K]KXK`KpKaKVKVKXKK>KFK!KKKKK%K:K9K:K3K8K,K,K$K1KEKCKBK@KGKAK6K8K9K=K?K;K6K4K6K/K#K'K#K1K?K?KBKAKDKDKPKRKTKQKCK-K.K3K:K2K(K%K"K.K4K5K3KK=KK?K?K>KK?K>K?K?K?K?K=KK>KK5K/K2K3K6K8K7K5K5K2K0K.KKKK*K2K4K5K5K5K4K4K5K3K2K2K3K5K4K2K4K5K5K3K7KYKqKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKyKyKyKvKuKuKvKxKxKxKxKyKyKxKuKvKyKvKuKuKue]q(KTKUKUKUKUKUKUKVKVKVKUKUKTKVKVKUKVKTKSKUKUKUKUKUKUKUKWKWKUKVKWKVKUKWKWKUKUKUKVKXKVKVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKZKYKYKYKYKZKZKWKWKWKYK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\K\K[KZK[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K^K_K_K_K^K^K^K^K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKdKbKaKaKaKaKbKbKcKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKcKbKdKdKcK^KRKSKXK\K^K]KXK[K[KZKWK[K\K`K[K]K\KYKcKqK_KVKVKXK5K"K&K'K$K2K>K?K?KKKKKK(K9K9K;K;K4K-K-K#K4KGKCKCK@KFK=K8K9K;K?K>K8K6K4K6K.K&K(K%K6K=KAK?K@KHKGKQKTKUKIK:K-K2K3K7K*K(K"K%K2K3K4K4KCKTKTKYK\KWKJK7K,K-K1K/K(K#K K,K.K/K-K1KKKSKUKWKRKPK:K+K/K0K-K'K"KK$K/K-K+K(KCKKKLKPKOKKKEK+K$K#K$K KK K(K+K+K)K4KOKQKSKTKJKFKHKIKHKHKHKHKHKHKHKIKJKEK)KK)KDKHKLKLKKKGKEKAK>K>K=K>K?K=K>K>K?K?K>K=K=K?K>K>K>K>K>K?K>K3K.K2K6K5K6K8K7K4K4K1K.KK KK'K4K4K4K5K4K4K5K3K2K2K3K3K4K4K5K5K3K4K3K5KWKsKwKuKuKuKuKuKuKuKuKvKxKwKuKuKuKuKvKxKwKxKvKuKwKxKwKwKwKxKwKuKvKyKwKvKvKuKwKxKxKxKxKxKxKxKxKwKxKxKxKwKwKxe]q(KVKUKUKUKUKUKUKVKVKVKUKUKSKVKVKUKUKVKVKUKUKUKUKUKUKUKWKWKUKVKXKVKUKWKWKUKUKUKVKXKVKUKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXK[KZK[K[KZKZKZKWKWKWKZK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\K]K\KZK\K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K_K_K_K`K`K`K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKbKaKaKbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKcKaKaKaKaKaKaKcKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKeKdKdKcK]KQKSKXK\K^K^KYK[K[KZKXK\K\K`K[K^K\KZKfKpKZKVKXKUK.K"K&K'K"K5KK=KK?K?K?K>K?K>KK?K>K?K@K=K1K.K4K4K6K8K7K4K3K0K1K.KKKK)K2K4K5K4K4K5K3K2K3K3K2K4K5K5K5K3K3K5K4K5KSKsKvKvKuKuKuKuKuKuKvKyKwKuKuKuKuKvKyKxKyKvKuKxKyKyKyKyKyKyKvKvKyKwKuKuKuKxKyKxKxKxKxKxKxKxKyKxKxKxKyKyKye]q(KUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKVKVKUKUKUKUKUKUKUKWKWKUKUKUKUKUKWKWKWKWKUKVKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKZKZKWKYK[KZKZKXKWKWKYKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K_K]K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKaK_K`KbK`K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKcKaKcKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKfKgKeKdKcK\KRKVKZK\K^K[KXK[KZKZKVKZK^K`K[K^K\K[KjKnKXKWKXKQK)K%K)K'K%K9K=KBK7KKKKKK3KKCKEK@KFKFK9K:K:K@K=K4K.K2K5K4K(K)K'K*K?KBKBK=KFKLKPKTKXKUKEK3K2K4K9K4K(K'K"K-K3K3K0K9KQKTKXK[KZKMK>K6K3K2K2K+K$K"K)K.K.K,K,KAKSKUKVKTKSKIK/K/K0K.K(K#K K!K+K+K+K(K9KLKMKNKNKLKPK7K%K$K$K$KKK(K+K+K*K-KIKMKVKWKVKYKNKGKIKIKIKHKHKHKHKHKHKIKHKIKEK$KK3KFKGKJKIKIKGKDK@KK?K?K?K?K?K>K>K>K>K?K>K>K?K>K>K?KAK=K2K,K1K3K5K7K8K6K2K2K/K/KKKK(K5K3K2K4K5K5K4K3K3K3K3K3K4K5K3K3K3K3K3K2KNKrKwKuKvKuKuKuKtKwKuKwKyKvKuKuKuKuKvKuKwKxKxKxKxKxKxKxKxKxKxKuKwKxKxKxKxKxKyKwKuKwKyKxKxKxKxKxKxKxKxKxe]q(KUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKWKWKVKVKVKVKVKWKWKWKWKVKVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKZKYKWKYK[KZKZKXKXKXKYKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K[KZKZKZK[K[K[K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K]K\K^K`K]K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKaK`K`KbK`K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKcKaKcKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKfKeKdKcKZKRKTKZK\K^K\KYK[KZKZKVKZK_K`K[K_K[K[KjKlKWKWKXKLK&K&K)K&K&K-K8KFK/KKKKKK4K6K6K8K4K0K.K(K+K?KAKEKAKEKDK6K:K;K?KKGKJKQKUK\KRKAK3K3K4K9K/K%K&K#K-K3K3K2K@KSKUKYK\KYKJKKKKHKHKHKHKHKHKHKHKHKIKHKKKAKKK8KHKIKIKIKJKMKEK=KK>K>K>K>K>K?K?K?K>K?K>K>K?K>K>K>K>K?K=K1K+K0K5K7K7K8K6K4K2K0K-KKKK'K0K3K4K5K5K5K3K3K3K3K3K4K5K3K3K3K3K3K2K1KJKpKwKuKuKuKuKuKvKuKvKxKwKvKvKvKvKvKvKxKyKxKxKxKxKxKxKxKyKxKvKwKyKxKxKxKxKyKwKvKwKyKxKxKxKxKxKxKxKxKxe]q (KUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKVKUKUKUKUKUKUKUKUKWKWKWKWKWKWKWKVKUKWKWKXKVKUKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKYK[KXKWKZKZK[KYKWKYK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\KZKZKZK\K]K\K\K]K\KZK\K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K`K_K\K^K`K_K_K\K]K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKaKaKaKbK`K_KaKbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKcKaKaKaKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKcKYKOKQK[K[K^K^KYK[K\KZKXK\K_K`K\K_KZK_KoKfKUKXKYKEK$K&K&K%KKK7KEK'KKKKKK2K7K9K4K5K.K.K&K/KAKDKDKAKGKCK9K;K>K=K;K9K4K4K8K/K#K$K"K4K@K?K?KBKKKOKVKYK[KNK2K.K3K3K6K-K&K"K'K.K2K3K4KHKRKYK^K^KMK@K4K.K2K6K0K%K#K$K-K/K.K,K5KMKTKVKUKSKNK7K.K0K,K(K"K!K K&K*K+K+K-KIKOKQKPKMKOK>K%K%K$K#KKK#K*K+K*K*KAKQKUK[K[KYKRK/K-KAKIKFKHKIKHKHKHKHKHKIKHKEKHKAKKKK?K>K>K>K>K>K>K>K>K>K?K>K>K>K;K1K/K3K5K4K7K8K4K4K2K0K.KK KK(K4K5K5K5K5K5K5K5K5K5K5K5K3K3K3K3K3K2K3K0KGKlKuKuKuKuKuKuKuKuKuKwKyKyKyKyKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKuKuKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q!(KUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKVKUKTKVKUKUKVKVKUKUKUKWKWKWKWKWKWKWKVKVKWKWKWKWKVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKYKYKYKYKYKZKZKZKZKXKZKZKZKZKZKZKZK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\K[K[K[K\K\K\K\K\K\K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K^K^K^K\K^K`K_K_K^K^K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`K`KaKaKaKaKaKaK`K`K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKcKcKcKcKcKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKeKeKdKdKdKdKdKdKWKPKRK^K\K^K\KYK[K\KZKXK\K^K`KZK^K[KaKpKfKVKWKYK?K"K'K'K"K&K5K=KCK KKKKK&K5K5K8K7K1K-K.K$K2KAKDKCK>KJK?K:K;K?K=K9K8K5K4K5K-K'K#K!K;K>K:K>KCKIKPKVKYKXKJK0K.K1K5K5K*K'K"K)K1K3K2K6KMKTKYK]KYKJK@K2K0K2K5K.K!KK&K-K/K.K+K;KOKTKUKTKSKLK2K.K.K+K'K"K!K"K(K*K+K(K6KMKQKQKQKLKQK6K%K&K&KKKK'K*K)K(K/KKKSKVKZKZKZKFK-K+K,KCKGKHKIKHKHKHKHKHKIKHKGKHKFK7KKK@KGKHKLKLKKKHKBK=K=K=K=KK?K>K>K>K>K>K>K>K>K>K>K>K>K>K?K=K/K.K4K5K7K8K7K7K3K1K1K0K KKK%K2K5K5K5K5K5K5K5K5K4K4K2K4K4K4K4K3K4K3K1KCKjKxKuKuKuKuKuKuKuKwKxKwKwKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKwKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q"(KVKVKVKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKVKXKWKUKUKUKWKWKWKWKWKWKWKWKXKWKWKWKWKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXK[KYKWKZK[KZKZK[K[K[KZKZKZKZKZKZKZK\KYKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\K\K]K]K\K\K\K\K\K\K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K_K_K\K\K\K^K`K_K_K`K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKbKaKaKaKaKaKaKbKbKbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKcKeKeKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKgKfKdKdKdKdKdKbKTKNKRK]K\K^KZKXK[K\KZKXK[K^K`KXK]K[KbKqKbKUKXKYK7K!K'K(K K-KK2K.K1K3K+K#KK*K+K"K(K-KGKOKSKVKTKSK@K.K/K,K,K&K#K!K$K+K+K+K)KCKOKQKQKPKNKLK,K%K&K$KKK!K)K*K)K)K9KPKUKXKZK[KWK9K.K)K"K/KFKIKHKHKHKHKHKHKHKIKHKJKFKEK4KK KBKGKHKLKLKKKHKDKK?K>K>K>K>K>K>K>K>K>K>K>K>K?K>K>K:K1K0K2K4K5K8K8K5K4K2K.K/KKKK'K3K2K2K5K5K5K5K5K3K2K2K2K2K3K5K5K5K3K4K2KBKgKwKuKuKuKuKuKuKwKxKuKuKuKvKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q#(KVKVKVKUKUKUKUKUKUKUKUKUKUKUKVKUKUKVKUKUKUKVKVKWKVKUKWKWKVKVKVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKYKZKZKZKYKZKZKZKZKXKYKZKZKZKZKZKZKZKZK[KZKZKZKZKZKZKZKZKZK[K\K[KZKZKZK\K\K\K\K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K_K]K]K\K\K\K^K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaK`K_KaK`K_K`KaKaKaKaKaKaKaKaKbKbKaKaKaKaKaKaKaKaKaKaKaKaKcKdKcKcKcKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKeKfKeKdKeKcK`KRKNKRK]K^K`KZKXK[K]KYKZK\K^KaK[K]K[KiKrK^KUKXKXK0K$K(K'K#K.K9K?K;KKKKKK-K9K5K6K4K*K.K*K$K?KEKAK?KAKHK:K9K;K?K=K7K7K8K6K-K'K*K#K,KAK:K1K@KJKHKRKYKZKUK;K.K3K0K6K1K(K#K$K1K3K4K3K@KTKSKZK[KOKBK5K0K1K5K2K(K$K"K)K$KK&K1KMKQKTKUKQKLK3K.K-K*K)K#K KK%K+K+K*K/KOKPKSKSKOKPKBK%K'K$K"KKK$K)K&K%K)KFKTKUKXKYK\KNK1K,K$K#K#K4KIKHKHKIKHKHKHKHKHKHKIKIKGKFK/KK#KCKGKIKKKLKKKIK?K>K>KK?K@K@K>K>K>K>K>K>K>K>K>K>K>K>K>K@K>K1K/K3K4K5K6K7K8K6K2K/K-KKKK$K2K3K3K4K5K5K5K4K4K5K3K1K2K3K3K3K2K3K4K4K>KfKwKtKvKuKuKuKwKyKxKwKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q$(KVKVKVKUKUKUKUKUKUKUKUKUKUKUKUKVKUKUKUKUKUKUKVKXKVKUKWKWKUKUKUKVKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKZKZKZKZK[KZKZK[KZKWKYK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K]K\KZKZKZK\K\K\K\KZK\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K`K]K\K\K\K\K^K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KbK`K_KbKaK_K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKdKeKdKeKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKgKeKdKeKdK^KNKMKTK\K`K`KZKXK[K]KYK\K]K^KaK\K]K[KkKqKYKVKXKUK*K'K)K&K%K3K9K@K4KKKKKK.K4K5K9K7K,K/K(K*K?K?KCKBKDKDK9K:K;K@KBK8K2K8K8K0K$K*K#K2KAK>K=KAKIKJKVKZK\KVK8K.K1K2K9K.K&K$K&K2K3K2K5KHKTKTKZKVKMKAK3K0K5K7K.K#K K$K*K%K&K*K;KOKQKUKSKPKKK3K/K,K*K*K#K K!K)K+K+K(K7KOKRKSKQKLKOK2K"K!K#KKK K'K*K$KK0KOKUKXKXKYK^KAK(K*K$K$K"K#K:KIKHKHKIKHKHKHKHKHKIKHKIKJKHK*KK(KFKEKHKKKKKJKIKCK=KK>K=K>K?K>K>K>K>K>K>K>K>K>K>K?K>K?K@K>K1K/K2K4K6K8K9K7K5K2K2K.KKKK'K4K2K3K5K5K5K5K5K5K5K3K3K2K2K3K2K3K4K6K5K=KcKwKvKvKuKuKwKyKxKyKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q%(KUKUKUKUKUKUKUKUKUKUKUKUKUKUKVKVKVKUKUKUKVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKYKZKZKZKXKXK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\K]K\KZK\K\K[K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K`K]K\K\K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`K_K_K_K_K_K`KbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKcKdKbKaKaKbKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKgKeKdKeKdK^KOKLKRK\K_K`K\K[KZK\KYK[K\K^K`K\K^K^KmKpKVKWKYKPK&K(K)K$K#K4K9K@K.KKKKK K3K6K7K5K3K-K,K&K-K>K?KCKBKEKAK9K=K=KBK:K6K/K2K7K/K'K)K%K8K@K;K6KAKLKWK^K_K_KPK;K4K2K4K3K+K'K$K+K3K3K2K8KKKTKWKYKRKNK>K0K2K4K7K*K#K!K&K,K.K2K+KEKTKQKSKSKRKHK/K-K+K*K'K#KK%K*K.K-K'KBKRKRKPKOKNKNK(K#K#K$KKK%K)K)K)K'K:KTKVKYK]K\KVK2K+K(K$K$K$K#K'K?KJKHKHKIKIKHKIKHKIKIKIKHKJKEK&KK.KGKHKGKJKLKKKEK>K=K=K=KK>K>K>K>K>K>K>K>K>K>K>K>K?K?K:K/K-K4K4K5K6K8K7K3K2K2K,KKKK#K4K4K5K5K5K5K5K5K5K5K4K3K4K5K3K3K3K3K5K3KK9K>K>KBK8K5K2K5K5K+K'K(K'KK>K>K>K>K>K>K>K>K>K>K>K>K>K=K?K;K-K/K2K5K6K8K7K4K3K2K1K.KKKK%K3K4K4K5K5K5K5K5K5K4K3K4K5K3K3K3K2K/K2K4K9K\KuKwKuKwKxKxKxKvKvKvKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKvKwKyKxKxKxKxKxKxKxKxKxKxKxe]q'(KUKUKUKUKUKUKUKUKUKUKUKUKWKWKVKVKVKUKUKUKVKWKWKUKVKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKYK[KXKWKWKWKWKYK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\K]K\KZKZKZK\K\KZK[K]K\K\K\K\K\K\K]K[KZK\K\K\K\K\K\K\K\K\K\K\K\K\K\K_K_K\K\K\K^K`K`K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKbKbKbKbK`K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbK`KaKeKeKeKeKeKdKdKdKdKeKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKfKgKfKdKVKLK?KOK]K]KbK]K\KYK[KYK\K]K^K^K^K[K_KsKhKVKWKXKAK!K(K)K%K*K6K;K>KKKKKK'K6K8K8K5K1K.K*K&K9KCKBK@K>KKK=K:K>K@KDK8K6K8K9K8K*K&K%K*KKKK7KHKGKHKKKLKJKDK@KK?K>K>K>K>K>K>K>K>K>K>K>K>K>K>K>K?K?K>K9K2K/K1K5K8K8K8K5K5K1K/K/KKKK+K4K4K5K5K5K5K4K4K5K2K1K3K5K4K3K2K1K3K5K3K6KWKqKuKvKuKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q((KUKUKUKUKUKUKUKUKVKVKVKUKVKVKVKVKVKUKUKUKVKWKWKVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKYKWKWKWKYK[KXKWKYKYKYKYKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K[K[KZK\K\K\K\KZKZKZK\K\KZK[K\K\K\K\K\K\K\K\K\K[K\K\K\K\K\K\K\K]K]K\K\K\K\K\K^K^K^K^K^K^K^K^K^K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`K`K`KaKaKaKaK`K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKcKbKaKaKbKcKcKcKcKcKdKdKdKdKcKcKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKeKfKfKeKeKRKIK8KOK]K^K`K[K\KYK[KYK\K\K_K]K\KZKdKvKdKVKXKXKK?KDKGK;K;K=KAKAK8K9K9K;K/K%K'K%K-K:K9K:KBKPKVK\K\K[KSK;K2K/K6K4K,K(K"K(K5K4K4K7KGKTKWKZK\KQKBK1K0K3K7K.K!KK(K/K/K0K,K?KTKTKVKVKVKKK-K,K,K-K'K$K K!K)K.K+K'KBKSKSKRKQKOK?K'K$K#K%KKK%K)K)K)K'K?KVKVKZK[KYKVK.K,K)K%K#K"K"K$K!K!K"K3KHKKKIKIKHKHKJKLKKKJKIKIKGKKK;KKK;KGKGKJKLKIKIKFK?K>K?K>K>K>K>K>K>K>K>K>K>K>K>K>K>K>K>K>K>K?KK9KKKKKK0K6K8K8K8K-K+K)K*K>KCKBK?KEKHK9K;K=KAKBK=K:K:K8K2K&K&K%K4K;K:K:KBKRKWK\K^K\KVK=K3K5K7K5K,K'K"K+K2K5K8K;KOKUKXKYKZKKK@K6K5K8K4K(K#K!K)K/K1K/K0KHKSKWKVKUKQK>K,K.K-K,K%K$KK$K*K+K'K+KHKQKRKRKSKQK9K$K#K#K%KKK%K)K)K(K,KLKVKUK[KXKZKGK.K/K'K$K$K$K#K#K K!K"K$KK>K?K?K>K?K>K>K>K>K>K>K>K>K>K>K>K>K>K?K?K>K:K.K.K3K4K5K5K5K5K4K2K0K-K,K(K+K/K3K5K5K5K5K5K5K5K3K2K3K3K2K3K5K3K3K3K3K2K3KOKqKwKxKyKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKxKxKxKxe]q*(KUKUKUKUKUKUKUKUKVKVKVKWKWKWKWKVKUKVKWKWKVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKXKYKYKYKZKZKZKYKYKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K[K[KZK[K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K]K\K\K\K^K_K]K]K_K_K]K]K\K^K_K`K]K_K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaK`K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKbKaKbKdKcKcKcKcKcKcKeKdKdKcKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKfKfKfKcKIKAK"KNK^K]K^KYK[KYK\KYK\K\K_K_KZKYKiKxK_KVKXKTK-K$K(K%K"K.K8K>K1KKKKKK3K5K6K5K5K/K+K&K+K@KCKCK?KGKCK7K;K=KBKDK;K:K8K5K.K%K%K%K7KK>K?K>K?K>K>K>K>K>K>K>K>K>K>K>K?K=K=K>K?K:K/K/K4K3K6K7K8K8K5K2K1K.K*K0K4K2K3K4K5K5K5K5K5K4K4K3K3K1K3K5K3K3K3K3K3K3K4KNKrKxKvKvKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKvKxKxKxKxe]q+(KVKUKUKUKUKUKUKUKUKUKTKTKWKXKXKWKUKWKXKYKVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKZK[K[KZKZK[K[K[K[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K\K\K\K\K\K\K\K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K`K]K]K`K^K\K\K\K_K`K`K\K_K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KbK`K_KaKbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKcKeKdKeKdKdKeKdKeKdKeKeKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKcKdKgKgKfK`KFK;KKPK]K\K]KYK[KYK\KYK\K\K_K^KZK\KmKtK\KWKYKOK(K%K'K$K K0K7K=K*KKKKK"K6K4K4K4K5K-K+K%K0KAKCKBK>KJK?K9K:K>KFK@K:K?K8K2K-K%K%K(K;K9K5K;KIKXK]K`KXKUKJK9K5K2K7K4K'K$K(K2K5K8K6KCKVKWK[K]K\KIK2K3K3K7K-K%K"K%K.K1K4K,KK=K?K>K?K>K>K>K>K>K>K>K>K>K>K>K?K=KK?K8K,K-K4K8K8K7K9K7K4K1K2K/K,K*K/K3K3K5K5K5K5K5K5K5K3K3K3K4K5K3K3K3K3K3K2K4K3KHKoKxKtKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKwKuKwKyKxKxe]q,(KUKUKUKUKUKUKUKUKUKUKUKUKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKZKYKWKWKWKWKWKZKZKWKYK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\KZK[K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K\K\K\K\K\K\K\K]K`K]K\K_K_K\K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKaK_K_K_K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKbKdKdKbKbKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKfKgKdK]K=KYK'KLK^K]K]KYK\KYK[KYK^K[KaK\K\K]KnKpKZKWKYKJK$K&K'K#K#K5K9K?K$KKKKK(K5K2K8K8K4K*K)K$K4KDK@KBKAKHKK7K6K'K&K$K/K;K8K8KK?K>K>K>K>K>K>K>K>K>K>K?K>K>K>K>K>K>K>K>K@K6K*K0K6K8K8K8K8K6K2K3K2K0K)K)K1K2K4K4K5K5K5K5K5K5K4K5K4K3K3K3K4K4K3K2K2K5K3KFKkKwKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q-(KVKVKUKVKVKUKUKVKVKUKUKUKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKZKYKXKXKWKXKXKZKYKXKYK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\K[K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K^K_K^K]K_K_K]K^K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKaK_K_K_K`KbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKbKaKaKaKdKdKaKbKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKfKfKdK`KAKrKPKKK_K]K]KYK\KYK[KYK^K[KaK\K\K_KrKmKXKWKYKCK$K&K'K#K%K5K:K>KKKKKK*K1K3K8K8K1K*K(K%K;KCK?KAKBKGK:K:K=KCKEKK>K?K>K>K>K?K>K>K>K?K>K>K?K>K>K>K?K>K?K=KK?K;K>KBKDK8K=K?KGKFK9K8K:K6K.K$K'K%K8KK?K>K?K?K>K?K>K>K?K>K>K@K>K>K>K?K=K?K=KK:K-K-K3K7K8K8K8K6K2K3K1K/K-K-K0K2K3K4K6K5K5K5K5K5K4K2K3K3K3K3K3K3K3K3K2K5K2K=KeKwKuKuKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q/(KWKVKUKVKWKVKVKWKWKUKUKUKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXK[KYKXKZKZKWKXKZKZKZKYKYKZKZKZKZKZKZKZKZKZKZKZKZK[K[KZKZKZKZKZK[K[KZKZKZKZKZKZKZK[K[KZK[K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K^K]K\K\K\K\K]K^K^K]K_K_K_K_K_K_K_K_K^K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`K`K`K`K_K`KbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKdKdKaKbKcKcKcKcKcKbKcKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKeKeKfKUK]K[KPK…K`K\K]K]KYK\KYK\KYK]K[KaK]KZKbKtKfKWKXKXK6K$K(K&K#K*K5K:K4KKKKKK.K4K4K2K4K.K(K%K*KKCKJKBK:K=K;K9K.K#K&K'K;KK?K>K>K?K>K?K>K?K>K>K?K>K@K@K?K>K?K>K=K?K@K9K.K/K4K7K7K7K8K6K3K3K2K/K,K+K1K3K3K4K4K4K6K6K5K4K4K3K3K3K3K4K3K3K2K3K4K4K2K;KcKvKvKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q0(KUKUKUKUKUKUKUKWKWKUKUKUKWKWKWKWKWKWKWKUKUKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKZK[K[K[KZKWKXK[KZK[KXKWKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K]K[KZKZKZKZKZKZKZKZKZK[K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K`K_K_K_K_K_K_K`K]K\K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKbKbKaK_K`KbK_K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKdKaKcKeKbKaKeKeKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKgKfKhKXKXK`KOKfK^K^K\K\KYK\KYK\KXK^K[KbK\KZKhKuKaKYKYKTK/K'K)K%K"K,K5K9K.KKKKK K3K4K2K6K3K(K'K%K-K>K?K;KK?K?K>K>K>K>K>K?K?K>K>K>K>K>K?K>K?K?K>K>K?K2K*K0K3K5K5K8K8K5K4K2K/K1K-K.K3K3K2K2K3K5K5K5K5K5K3K2K3K3K5K4K2K3K3K3K3K5K4K>K`KtKtKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q1(KUKUKUKVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKWKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKZKXKWKWKXKYKZK[KYKXKZKZKYKYKXKYK[KXKWKZKZKZKZKZKZKZKZKZKZKZKZKYKYKZKZKZKZKZK[K[KZK[K\K[KZK[KYK[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K^K^K^K]K]K^K^K]K_K`K_K_K_K_K_K_K^K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaK`K_K`KaK`K`K`K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKcKcKdKdKdKcKbKcKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKfKfKfKeKeKhKcKXKTKcKQKTK`KYK[K^K[K]K[K]K[K^K[KaK]K[KkKsK^KZKYKQK)K(K)K&K$K1K5K:K&KKKKKK0K5K1K4K1K&K#K#K0K?K>K;K=KFK9K8K=KGKLK:KKFKGKIKLKLKIKBK>K@K?K>K?K>K>K?K>K=K>K?K>K?K>K>K>K>K>K?K>K>K8K)K,K,K3K5K6K6K7K6K3K1K1K0K-K1K0K1K3K4K2K3K3K4K5K4K4K3K3K5K4K4K3K3K3K3K3K4K3K8K[KtKvKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q2(KUKUKUKWKXKWKWKWKWKWKXKXKWKWKWKWKWKWKWKWKXKWKXKWKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXK[KYKWKWKXKZKZK[KYKWKZK[K[KZKWKYK[KXKWKZKZKZKZKZKZKZKZKZKZKZKZK[K[KZKZKZKZKZKZKZKZK[K]K\KZK\KYK\K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K`K_K`K]K]K`K^K\K^K`K_K_K_K_K_K_K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KbKaK_KaKbK`K_K_K`KbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKdKdKdKeKeKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKfKgKgKfKdKfKcK\KVKaKVKTK{KTK[K_K]K]K\K^K]K^KZKaK^K\KnKrK\KZK[KLK&K'K*K'K&K2K4K7K KKKKK%K6K3K2K1K,K'K$K#K7K=K=KKDK8K;KAKLKKK:K5K5K1K.K"K$K%K7K>K;KK;K9K8K(K"K%K4K8K8K5K=KTK^KaK`K_KMK3K0K0K0K,K#K"K&K0K3K4K.K?KTKYK[KYKWKAK,K*K*K)K&K#K K&K+K,K*K.KLKOKRKSKQKSK7K$K'K&K$KKK$K&K(K'K2KLKQKPKRKUKVK9K6K.K%K&K$K$K$K#KK#K%K#K\KwKsKsKsKsKsKsKsKtKfKPKJKKKLKLKLKKKLKLKHKJKLKKKIKIK/KKK@KCKDKGKLKLKIKDK?K>K?K>K>K>K>K?K?K?K>K>K>K>K>K>K>K>K?K>K=K;K;K6K&K)K5K5K5K8K7K4K3K3K1K/K-K(K2K4K2K3K3K2K4K5K5K5K3K3K5K5K5K3K3K3K3K2K2K3K2K6KWKuKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q3(KUKVKWKWKXKXKXKWKWKWKWKXKXKXKWKWKWKWKVKWKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKWKWKWKXKZKZK[KYKWKZK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K\K[KZKZKZKZK[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K]K]K_K_K_K_K_K_K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`K`K_K_K`K_K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKdKdKaKcKeKdKdKeKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKfKeKdKdKeKfKfKfKgKdK]K[K\K^KHK~K\KWK]K\K]K\K^K\K^K\KaK]K_KpKoK[KZKZKFK$K)K)K#K%K1K7K8KKKKKK+K6K4K5K5K,K&K%K'K;K=K:K:K=K@K6K=KCKNKHK;K9K0K,K*K#K#K&KK?K>K?K>K>K?K?K?K>K>K>K>K>K>K>K>K>K>K>K>K?K?K4K)K-K2K5K5K6K8K5K5K3K3K0K)K&K$K!K-K3K2K3K5K5K5K3K3K5K4K3K4K5K5K4K3K3K3K5K4K5KYKuKvKuKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q4(KVKVKXKXKXKXKXKWKWKWKXKXKXKXKWKWKWKXKYKXKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKXKWKXKZKZKZKYKXKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K]K[KZKZKZK[K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K]K\K\K\K\K\K_K_K_K_K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKdKcKaKcKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKgKeKdKeKeKfKfKfKdK_KZK[K[KbKHKsKuKTK]K\K]K\K^K]K^K\KbK\K_KrKlKZKZKZKKK6K9K:KK>K?K>K>K>K>K>K>K>K>K>K>K>K>K>K>K>K>K>K@K=K4K-K0K4K5K6K8K6K5K3K2K/K0K$KK KK1K3K2K5K5K5K3K3K5K4K3K4K5K5K4K3K3K3K4K5K2K3KPKrKvKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q5(KWKWKWKXKXKXKXKWKWKWKXKXKXKXKWKWKWKXKXKXKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXK[KWKWKWKWKWKYK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K]K[KZKZK[K]K\KZK\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K_K_K\K\K\K\K\K\K]K_K_K`K]K\K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaKaKbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKdKeKbKaKdKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKgKeKdKfKfKfKfKeK\KTK]K_KWKaKOK`K}KUK]K\K]K]K\K^K\K]KdK]KbKqKfKZKXKYK5K#K&K&K"K(K2K6K/KKKKKK,K3K4K5K4K(K&K K+K;K9K8K7K?K8K6K@KJKRK=K;K8K1K1K'K"K#K/K=K9K;K;KLKVKQK_KhKVK@K9K:KK>K>K>K>K>K>K>K>K>K>K>K>K>K?K>KK?K>K5K-K2K3K4K5K7K8K4K4K1K0K-KK K K!K2K5K5K5K5K4K1K2K4K5K3K2K5K4K3K3K3K2K2K3K2K3KPKqKvKvKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q6(KWKWKWKWKXKXKXKWKWKWKWKXKXKWKWKWKWKWKWKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKXKWKXKXKYK[KYKXKYKYKXKYKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K]K[KZK[K[K\K[K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K^K]K^K^K^K^K\K]K_K_K_K^K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaKaK`KaKaKaKaKaKaKaKaKaKaKaKbKaKaKaKaKaKaKaKbKcKcKcKcKcKbKcKdKdKdKcKcKcKcKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKfKeKdKfKfKfKgKeK]KVK]KdKWK^KZKOKZKVKZK\K]K]K\K]K^K^KbK]KdKuKeKYKYKWK0K%K(K(K#K*K2K7K)KKKKK"K0K4K4K5K1K&K'K#K/K:K9K8K7K@K:K;KDKOKPK;K9K7K5K0K"K#K#K5K=K9K:K=KLKFKCKSKbKMK;K:K:K>K9K&K K$K5K:K8K6K=KYKcKfKbK`KHK6K3K2K2K*K"K"K)K2K3K1K/KFKSKXKWKTKQK9K)K*K&K%K%K#KK%K+K/K)K4KNKPKQKQKQKPK+K!K)K*KKK#K(K&K'K*K?KJKIKKKMKPKIK0K2K(K$K"K$K&K%K#K#K&K K?KuKsKtKsKsKsKsKsKsKsKsKtKsKuKpKQKIKJKJKJKJKIKIKJKIKHKIKHKIKKK>KKK7KFKFKIKJKKKKKJKCK>K?K?K>K?K?K?K?K>K>K>K>K>K>K>K?K>K=K?K>K>K?K>K5K-K/K2K4K7K8K7K7K5K2K0K/K!K KKK1K5K4K5K4K2K3K4K5K4K3K5K5K3K4K4K3K3K3K2K2K2KLKqKuKvKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q7(KXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKZK[KWKXK[KZKZK[K[K[K[K[KZKZK[K[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K]K[KZK\K\KZK[K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K`K`K`K`K`K]K]K_K_K_K_K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKaK_K`KbKaKaKaKaKaKaKaKaKbKbK`KaKaKaKaKaKaKbKeKeKeKeKeKeKeKdKdKdKeKdKaKbKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKfKfKcKcK]K`K[KYKaKZK[K`KLKlKcKUK^K]K]K\K\K_K_KaK[KgKtK`KYK\KSK+K(K)K(K$K-K2K5K"KKKKK%K1K1K4K3K.K#K#K$K4K9K7K8K8K@KK?K?K?K?K?K>K>K>K>K>K>K>K>K?K?K>K>K>K>K?K=K4K-K4K2K6K8K8K9K8K5K2K/K.K KKK!K1K5K5K5K5K5K5K5K5K5K5K5K5K5K5K5K5K3K3K3K2K2KHKpKvKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q8(KVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKXKWKXKZKZKZKYKXKZKZKZKZKZKYKXKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K\K\K]K[KZK\K\KZK[K\K\K\K\K\K\K\K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K]K^K_K_K_K]K]K_K_K_K_K_K_K_K_K_K_K_K_K_K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaKaKaKaKaKaKaKaK`K`KaKaKaKaKaKaKaKaKaKbKaKaKaKaKaKaKaKbKeKcKbKdKdKdKdKdKdKdKdKdK`KaKeKdKdKdKdKdKdKdKdKdKdKdKdKeKfKfKfKeKdKeKhKjK[KVK`K]KUK\K_KXKaKKKmKlKLK]K[K[K\K_K_K_K^K\KkKsK^KZK[KMK'K)K'K%K#K+K1K7KKKKKK$K.K/K2K3K*K$K#K&K7K9K8K7K9K@KK>K?K?K?K@K?K>K>K>K>K>K>K?K>K>K?K>K>K>K>K>K?K>K2K-K2K4K6K6K7K9K7K3K0K/K.K KKKK2K5K4K5K5K5K5K5K5K5K5K5K5K5K5K5K3K3K3K3K3K0KFKkKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q9(KUKVKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXK[KZK[KXKWKZKZKZKZK[KXKWKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K]K\K\K[KZK\K\KZK[K]K\K\K\K\K\K]K]K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K`K_K_K]K]K_K_K_K_K_K_K_K_K_K_K_K_K_K`K^K_K`K_K_K_K_K_K_K_K_K_K_K_K_K`KbKaKaKaKaKaKaKbK`K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKcKaKdKeKdKdKdKdKdKdKdKbKcKdKdKdKdKdKdKdKdKdKdKdKdKdKeKgKgKgKfKfKaK`K^KVKVKaKaKVKYK`KWK`KSKXK|KRK\KZKZK]K`K_K_K\K]KoKsK\KZK[KCK#K)K(K%K%K-K1K4KKKKKK&K0K.K1K4K(K$K"K&K7K8K8K6K9K@K=KIKTKTK;K9K9K5K1K%K K!K,K;K:K=KK>K>K?K>K>K>K>K>K>K?K?K>K>K>K>K>K>K>K>K;K3K.K0K1K4K5K8K7K5K2K.K/K0K KKK K1K5K4K5K5K5K5K5K5K5K5K5K5K5K5K3K3K3K3K3K4K2K@KjKvKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q:(KWKWKVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKZKYKWKWKWKWKXKZKYKWKYKZKXKWKWKWKWKWKWKWKXKZKZKZKZKZKZKZKZKZK[KYKWKYKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K\K[KZKZKZKZK[K]K\KYK\K\K\K\K\K\K\K\K\K\K\K\K]K]K]K\K\K\K\K\K\K[K]K]K\K\K\K\K\K\K\K\K\K]K`K^K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKbKaKdKeKdKdKdKdKdKdKdKeKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKfKeKaKbK[KSKNKSKTKZK`KUKSK`KTK]K^KIK†KgKZK\K\K^K`K_K_K^K`KqKpKYKZK^K>K$K*K(K%K(K-K0K0KKKKKK-K0K.K1K2K&K"KK)K8K8K8K5K;K?K@KJKXKQK:K9K6K2K+K"K!K"K2K;K:K;KKLKKKLKJKOKDK)K)K)K'KKK$K'K K K*KFKEKHKKKIKLK7K3K.K&K$K$K%K&K#K#K&K$K%KfKvKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKsK[KIKIKJKIKKKKKKKKKKKKKKKHKIKGKEKJKGKDKGKFKFKHKIKJKLKFK?K>K>K>K>K?K>K>K>K>K>K>K>K>K>K?K>KK?K>K?K?KK?K@KJKXKKK8K:K5K2K,K!K!K"K2K;K9K7K:K9K4KKtKsKtKsKsKsKsKsKsKsKsKsKsKtKsKsKtKtKsKuKpKVKIKMKLKKKKKLKKKKKKKKKIKJKKKIKHKBKCKFKGKFKGKHKJKKKIKFK?K?K?K>K>K>K>K>K>K>K>K>K>K>K?K>K=K>K?K>K?K?K=KKAKMKRKAK7K8K6K-K)K K K$K7K;K9K7KK4K5K2K6K,K"K!K2KK3K0K'K$K$K$K%K"K!K%K'K#K[KwKsKsKsKsKsKsKsKsKsKsKsKtKvKtKsKuKvKvKuKtKkKPKLKJKHKIKLKJKHKKKLKKKKKLKJKIKDKCKFKDKGKFKFKGKJKKKLKFK?K>K?K>K>K>K>K>K>K>K>K>K?K>K>K?K>K>K>K>K>K>K?KK?K>K>K>K>K>K>K?K?K>K>K>K>K>K>K>K>K>K>K>K>K:K2K.K3K4K4K6K7K7K7K4K1K0K0K KKK K1K4K3K4K5K5K3K4K4K4K5K5K5K5K4K3K3K3K3K3K3K2K9K^KuKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q>(KWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKZK[KWKWKWKWKWKWKWK[KYKYK\KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K]K]K]K]K\K\K\K]K\K\K[KZK\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K_K_K_K_K_K_K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKbK`K_K_K`KbKaKbKaKbKbKbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKeKdKeKeKeKaK_K^K\K]K^K]K]K[K[KZK[KZKPKTKAKIK`KTKQK_KXK]KaKGK~K^KRK^K]KaKWKXK\KiKrK`KXKZKRK(K&K)K'K!K&K*K-KKKKKK(K/K,K*K-K*K K K&K5K5K4K4K6K=K;KCKNKSK:K6K8K2K,K#KK K/K9K8K7K6K:K5K7KEKPKCK1K6K8K6K2K'K"K'K9K:KKAK@KAKAK.K,K*K*K%K KK#K*K+K'K+KEKHKGKGKEKLK5K&K)K*K"KK"K%K%K&K&K7KEKEKHKFKHKCK3K6K'K$K$K$K$K$K"K$K$KKLKxKrKsKsKsKsKsKsKsKsKuKuKsKtKvKtKsKsKsKsKtKvKuKuKdKJKHKJKLKLKLKLKKKKKKKLKJKHKJKJKIKHKCKDKGKDKHKKKJKHKIKBK>K?K?K?K?K?K>K>K?K@K=K>K>K>K>K>K>K>K>K>K?K=KKaKWKQK]K]KWKdKJKiKxKRK_K]K`KVKYK[KkKoK\KYK[KGK#K'K)K'KK$K,K/KKKKKK)K.K-K-K-K%K!KK)K5K5K4K4K9K=K;KDKKKGK6K6K4K.K-KKKK1K4K4K2K6K9K4K9KEKMKK>KAK;K,K+K*K)K%K K!K(K*K*K&K4KJKFKEKEKHKHK*K(K)K*KKK%K'K(K(K,K@KCKCKFKEKJK:K9K2K'K%K%K%K$K"K$K%K%K,KfKuKsKsKsKsKsKsKsKtKuKuKuKuKtKtKtKuKuKuKuKuKuKuKuKvK^KJKJKLKKKKKKKKKKKKKLKKKJKIKIKGKFKHKBKEKFKGKGKGKIKLKHK@K>K=K=K=K>K?K>K?K?K>K>K>K>K>K>K>K>K>K>K?K>K>K=K;K1K2K4K4K5K6K6K5K4K3K3K0K/K KKKK0K4K5K7K5K4K3K3K4K3K3K4K3K3K4K4K3K3K3K3K3K2K3KUKtKwKwKyKxKxKxKxKxKxKxKxKxKxKxe]q@(KWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKZKZKWKWKWKWKWKWKWKWKWKWKWKWKZK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K]K[KZKZKZKZKZKZKZKZKZKZK\K\K\K\K\K\K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K`K]K\K\K^K`K`K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KbKaK_KaKaKaKaK_K_K_K`KbKaKaK_K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKdKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKcKdKeKdKeKbK^K^K\K]K^KXKMKK"K(K)K&KKK%K-KKKKK K.K-K.K.K-K"K K K,K3K5K3K0K=K;K;KEKOKEK5K7K2K*K'KKK K7K&KK)K:K6K4KKAK5K,K+K+K'K#K K#K*K(K)K'K=KGKDKCKCKJK@K*K)K'K&KKK%K&K)K(K3KCKAKBKFKFKEK5K9K-K'K#K%K%K$K!K$K'K!K@KuKsKsKsKsKsKsKsKsKuKvKuKuKvKuKsKuKvKuKvKvKuKuKuKuKvKrKZKJKLKLKKKLKLKKKKKKKLKLKIKIKKKGKIKIKFKFKFKFKFKHKLKLKHK>KK>K>K?K>K>K>K>K>K>K>K>K>K>K?K?K?K?KKIKAK1K/K5K7K1K'K#K#K7K:K:KK4K1K2K4K*K"K K0K6K4K2K7K>K9K:K:KKK>K>K>K>K>K>K>K>K>K>K>K>K?K=K=K>K>K?KKBKPKKKUKUKYK[KZKWKXKXKWKXKPKQKCKFK`KSKQK_KZKYK_KIKRKVKUK[K`K[K\KdKtKhKZKZKXK0K'K)K)K$K&K(K.K%KKKKK$K,K-K-K.K)K!KK#K4K4K2K2K3K5K4K8K>KBK8K4K4K1K0K$KK K,K5K3K0K4K=K5K4K@KFK>K0K3K5K2K/K&K!K)K;K8K:K=K@KEKHKJKKKIK:K6K3K2K0K&K"K%K2K,K)K2K9K=K9K:K8K9K:K0K0K-K*K"K!KK&K)K)K'K3KFKCKCKDKCKBK-K(K(K'KKK%K)K)K(K,K@KAKBKCKCKGK5K5K/K&K'K$K"K&K#K#K$K"K0KnKtKsKsKsKsKsKtKtKsKtKuKuKuKsKtKvKuKuKtKtKuKuKuKuKuKuKvKwKmKQKMKJKIKJKKKLKKKKKKKLKLKLKKKHKHKLKHK;KBKFKFKGKJKMKMKFK?KK?K>K>K>K>K>K>K>K>K>K>K>K>K>K>K=K=K>K?K>K?K8K.K.K4K5K4K6K8K7K4K1K.K.K.K!KKKK-K3K3K5K3K3K3K3K3K3K3K3K3K3K3K3K2K2K3K3K1K1K2KKKoKxKyKxKxKxKxKxKxKxKxKxe]qC(KWKXK[KXKWKWKWKWKWKWKWKWKZKZKWKWKWKWKWKWKWKWKXK[KYKWKZKZKWKWKWKWKWKWKWKVKYKWKWKWKWKXKZKZK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\K\K\K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K`K_K_K]K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKaKaKaKbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKdKdKcKfKeKeKeKdKdKdKdKdKdKdKeKeKcKcKaK\K\K_KaKZKIK=KEKUKLK+KKRKYKYK[K[K[KXKXKWKYKSKMKLKK8KEKDKGKGKLKLKIKEK?K?K?K?K>K>K>K>K?K?K?K>K>K?K?K?K>K?K>K>K>K?K=K=K9K/K/K3K5K5K5K7K8K5K3K.K0K/KKKKK/K3K2K4K5K3K3K3K4K5K4K3K3K3K3K2K1K2K3K3K3K2K1KJKpKxKwKyKxKxKxKxKxKxKxe]qD(KXKYK[KYKWKWKXKWKXKYKXKWKZKZKXKXKXKXKXKXKXKXKYK[KYKWKZKZKWKWKWKWKWKWKWKWKXKYKXKWKWKXKZKZKYKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K[K[K[KZK\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K^K_K_K]K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`K`K_K_K_K`K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKdKdKbKdKcKcKcKdKdKdKeKeKdKeKdKbK`K_K]K]K_KZKLKAKFKSKKK0KK#KAK[KWKXK[K[K[KXKXKXKWKQKIKOK5KYK\KUK[K]KVK^KSKKKKKKXK^KYK[KiKtK`KXKZKOK'K(K)K&K#K(K(K.KKKKKK'K*K*K+K-K&K!K K+K3K2K/K/K2K.K,K4K;KKDKCK4K-K2K4K3K)K#K$K5K:K8K8K=K?K>K@K>K@KAK;K5K1K3K,K"K K.K7K3K2K4K=K6K7K7K;KBK2K0K.K/K(K K!K%K*K)K)K-KAK?K@KBK=KBK0K"K(K+K KK#K(K(K%K&K;K>K>KAKAKCK:K9K5K%K%K$K$K&K#K#K&K%K%KeKvKsKsKsKsKsKtKuKtKsKsKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKtKtKuKaKLKKKJKKKLKKKKKKKLKKKKKJKJKJKGKFKAK$K,KCKDKCKFKKKLKJKEK?K=K>K?K>K>K>K>K>K>K?K?K>K>K>K>K?K>K>K>K?K>K=K=K9K-K/K4K5K5K6K7K6K6K2K1K/K-K KKKK.K3K3K5K4K3K3K3K4K2K3K3K3K3K4K5K3K3K3K3K3K4K2KFKnKxKxKxKxKxKxKxKxKxe]qE(K[K[K[KYKWKVKYKWKXK[KYKWKZK[K[K[K[K[K[KXKWK[K[K[KYKWKZKZKWKWKWKWKWKWKWKWKXK[KYKWKWKWKZKZKWKYK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K]K]K\KZK\K\K\K\KZKZKZK\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K`K]K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KbKaK_K_K_KaKaK_K`KbK`K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKdKdKaKaKaKaKaKdKeKeKeKeKbK^K^KZK_K_K]KXKJKBKHKUKLK.KK$KDK^KhK`KWKWK[K\K[KXKVKTKWKRKJKOK8KOK^KUKWK^KYK\K\KCKzKfKUK_KXK]KmKsK^KYK^KIK$K)K(K%K%K*K)K+KKKKKK*K*K*K+K)K"K K!K*K4K1K/K/K1K+K*K3K:KKFK=K/K0K3K1K0K%K"K'K7K8K6K7K=K;KK2K2K,K,K&K K!K'K,K+K)K3KAK=K>K?K>K@K)K$K'K)KKK'K)K)K(K.K=KK?K?KBK6K=K/K$K#K&K%K'K$K"K'K!K@KwKsKtKsKsKsKsKsKsKsKsKsKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKtK\KKKIKLKKKKKKKKKLKKKHKIKLKJKHKGKAKK +K/KGKCKDKGKLKMKJKBK=K>K?K>K>K?K=KK?K?K>KK?K?K>K>K?K?K=K=K9K.K.K4K5K5K5K5K5K3K0K/K,K+K KKKK/K5K5K5K4K3K3K3K1K3K3K3K3K2K2K3K3K3K3K3K3K3K3KEKjKwKxKyKxKxKxKxKxe]qF(KXKXKYKXKWKYKZKYKZKZKZKYKZK[KZKZKZKYKXKYKYKXKYK[KYKWKZKZKYKYKWKXKYKXKWKWKXK[KZKYKYKYKZKZKYKZKZKZKZKZKZKZKZKZKZKZKZK[K\K[KZK[K\K[K[K[K[KZK\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K^K^K^K^K^K^K^K^K\K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaK`K_K_K_K_K_K_K`KaKaKaK_K`KaK`K`KaK`K`K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKcKcKcKdKdKaKbKcKbKaKbKcKeKbK_K[K[K]K_KbK[KHK?KIKTKIK/KK(KDK`KiKgKgKcKYKTKZKYKYKXKVKUKXKWKLKJKFKKK_KUKSKYK[KVKaKHKiKƒKUK_KYK\KoKtK[KXK\KAK$K*K)K'K$K%K*K(KKKKKK,K*K*K+K(KKK!K-K3K1K/K/K.K*K+K1K:K9K3K2K/K+K$K!KK*K5K4K2K3K>K6K6K@KCK:K0K3K4K4K0K$K"K+K8K8K7K9K>K:K9K9K7K9K:K6K4K5K1K#KK%K4K5K5K4K9K6K5K8K8KKK>K>K?K8K;K*K%K$K$K$K#K!K%K'K"KVKvKsKsKsKsKsKsKtKuKtKsKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKsKVKKKLKKKLKKKKKLKKKJKKKLKKKJKKKIK4KKK4KFKDKFKIKKKLKJKCK>KK=K>K>K>K>K?K>KK=K@K>K>K>K>K=K=K9K+K/K4K4K3K4K6K6K4K1K.K/K/K!KKKK-K5K5K4K3K3K3K2K3K1K1K3K2K1K2K3K1K1K3K3K3K3K1KBKjKxKwKxKyKxKxKxe]qG(KWKWKWKWKXKZK[K[K[KZK[K[K[K[KZKZK[KYKWKZKZKWKXK[KYKWKZKZK[KZKWKYK[KXKWKWKXK[KZK[K[K[KZKZK[KZKZKZKZKZKZKZKZKZKZKZKZK[K]K[KZK\K]KZKZKZKZKZK\K]K\K\K]K\K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K_K`K`K`K`K`K`K]K\K\K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKbK`K_K_K_K_K_K_KaKbKaKaK_KaKbK`K_KbKaK_KaKbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKeKeKdKdKaKbKeKcKaKbKbKbK]K[K\K]K`K[KJK?KHKQKJK+KK'KIK]KhKhKcKcKaK]KTKRKYKXKWKXKXKYKVKVKRKHKPKQK\KVKNKYK`KVKaKQKQKlKWK_K\K_KqKnKXKXKZK;K#K)K(K%K!K#K)K%KKKKK K,K*K+K+K'KKK"K.K/K/K0K.K(K&K(K.K8K4K.K/K/K,K#K"K"K.K7K6K3K5K;K6K8KAKBK6K.K0K2K1K,K#K#K/K:K7K8K;KK=KDK4K*K)K*K"KK!K(K)K&K+KK?K?K7K=K2K&K#K$K$K#K K"K'K%K0KlKsKsKsKsKsKsKsKtKvKuKsKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKxKpKTKJKLKKKLKKKKKLKLKLKKKLKLKLKLKKK3KKK;KIKEKCKHKLKMKJKBK=K?K>KK>K?K>KK?K?K>K>K>K>K?K?K=K=K6K-K.K3K3K3K7K8K7K2K0K0K0K,K KKKK/K5K4K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K2K@KfKvKxKyKxKxKxe]qH(KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[KYKWKZKZKZKYKWKXKXKWKWKWKWKZK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K]K[KZK[K[KZK[K\K\K\K[K[K[K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K]K_K_K_K_K_K^K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`K`K_K_K_K`KaKaKaK`K`K`K`KaKaKaK`K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKdKdKdKdKdKdKcKbKcKcKbK`K]K\K_KaK[KKKAKKKOK@K%KK%KHK`KdK`K]K]K\K]K^K]KYKUKVKXKXKXKXKXKVKUKVKHKNKRK[KYKOKXK`KVK^KYKHKSKRKVK\K`KsKiKXK[KZK4K'K*K(K K K)K)K!KKKKK$K,K*K(K*K'KKK$K/K-K-K.K-K(K&K&K-K5K2K,K/K0K)K!K!K"K0K6K3K2K6K:K6K9KAK?K4K.K/K/K1K(K"K$K4K;K7K6K;K:K8K:K7K6K:K8KK?K5K=K+K'K$K#K$K#K!K%K'KKGKxKsKsKsKsKsKsKuKuKsKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKwKjKNKKKLKLKLKLKKKLKJKKKLKKKLKKKIKHK.KKK>KHKFKFKGKLKLKJKCK>K?K>K>K>K?K?K>K>K>K>K?K>K?K?K>K>K>K>K>K>K>K>K=K7K.K0K3K5K5K5K6K7K6K3K0K0K-K KKKK/K2K2K2K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K1K>KdKxKwKxKxKxe]qI(KZKZK[K[K[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[KYKXKZKZKZKZKXKXKXKWKWKXKXKZK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K]K[KZK[K[K[K[K]K\K\K[KZK[K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K]K\K\K\K\K\K\K\K]K]K]K]K]K_K_K_K_K_K`K`K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`K`K_K`KbKaKaK`K_K_K`KbKaKaK`K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKbKdKdKdKdKdKdKdKaKaK`K_K\K]K_KZKOKCKGKNKCK,K%K2KDKZK`K_K]K_KdKhKiKgKiKiKcKVKUKXKXKXKXKXKWKVKVKIKKKJKSK]KPKSK_KZKYK_KEKgKmKHK]KfKuKfKYK\KTK,K'K)K'KKK'K(KKKKKK$K+K*K(K*K%KKK%K0K-K-K-K+K%K%K&K-K3K/K*K,K.K&K K K$K4K5K3K2K7K8K5K;KAK9K3K0K0K0K.K#K K'K7K7K8K6K;K8K5K6K3K5K7K5K9K8K1K#K K&K4K5K4K2K8K3K1K0K1K9K9K/K3K2K,K"K K#K-K+K+K)K7K9K9K:KK8K;K7K'K$K#K$K$K#K#K&K%K%KdKvKsKsKsKsKsKsKuKuKsKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKvKfKMKKKLKLKLKKKLKJKKKLKKKLKLKLKLKHK+KK KCKHKEKDKHKKKKKJK@K>K?K>K>K>K>K>K>K?K?K>K>K>K>K?K>K>K>K>K>K>K?K=KK?K3K@K.K%K#K"K$K%K!K&K'K!K9KuKsKsKsKsKsKsKsKsKtKvKuKsKsKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuK_KIKKKLKKKKKKKKKKKKKKKKKKKLKJKJKDK#KK%KBKGKFKFKIKKKLKGK@K>K?K?K=KK?K>K?K?K?K>K>K>K>K>K>K>K>K>K>K?K=K=K6K-K/K3K5K5K4K7K8K6K3K0K.K.K KKKK-K4K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K2K3K0K7K]KvKxKxe]qK(KZK[K[K[K[K[KZKZKZK[KZKZKZKZKZKZKZKZKZKZK[KZKZKZKZKZKZKZKYKZKZKZKZKYKYKZKZKZKZKZKZKZKZKZKZKZKZKZK[KZKZKZKZKZKZKZKZK[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K^K\K\K\K\K\K]K^K_K_K_K_K_K]K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`K`K_K_K_K_K_K_K_K`KaKaKaKaK`K`KaKaK_K`KbKaK`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKaKaKbKcKcKcKcKbKcKbK^K^K`K`KbKYKKKBKHKWK_K`KdKiKlKlKlKjKiKkKiKhKgKfKgKeKeKeKfKgKaKXKTKWKXKWKXKWKWKXKWKSKJKJK7K^KWKNKZK_KUKaKUKHK~KSK\KhKuK`KYK[KJK%K'K&K%K$K%K(K#KKKKKK*K*K*K)K&K KKK*K,K*K+K+K%KK"K&K+K1K0K.K-K+K$K K!K,K4K4K3K3K4K3K3K3K3K4K/K0K/K1K+K#K"K/K9K7K7K8K;K0K1K2K2K;K8K6K8K8K.K!KK.K4K4K3K5K4K/K/K/K2K6K2K2K2K0K&K!K!K*K.K,K*K2K:K3K7K8K9K9K-K)K)K'KKK%K'K(K(K4K;K8K;K=K>K=K8K=K'K$K#K$K$K$K#K&K&K#KXKxKsKsKsKsKsKsKsKsKtKuKtKsKtKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKwKtK[KJKKKLKKKKKKKKKKKKKKKKKLKKKIKKK@K KK(KEKEKGKHKJKLKMKFK?K>K?K=K=K>K>K>K>K>K>K?K>K>K>K>K?K>K>K?K>K>K=KK?K?K?K?K?K=KK?K>K?K?K>K>K>K>K?K>KK,K$K#K$K$K$K"K%K'KKFKxKrKsKsKsKsKsKsKsKsKsKsKsKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKmKRKLKKKKKLKKKKKKKKKKKKKKKLKKKKKKK9KKK0KGKFKFKGKJKLKLKGK>K>K>K=K>KK>K>K?K?K>K=K>K@K?K>K?K>K>K=KKK?K>K>K?K>KK>K?K>K>K?K>KK6K,K/K3K3K3K6K5K5K1K0K-K,K,K KKKK/K4K3K3K3K3K3K3K3K3K3K3K3K2K2K3K3K3K3K3K3K3K2K3e]qO(KëK×K¨KvK]K\K`K_K^K\K\K\K\K\KZKZKZK[K[K[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K[K[KZKZKZKZKZKZKZKZKZKZKZKZKZK[K[K[KZKZK\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K[K\K\K\K\K]K]K_K_K_K_K_K]K\K]K^K`K_K_K_K_K_K_K_K_K_K_K_K_K`K_K^K`K_K_K_K_K_K_K_K_K_K_K_K_K`K`KaKaKaKaKaKaKaK`K`K`K`K`K`K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKaKaKbKaK`K`K`K_K_K^KcK^KKKDKPKXKHK+KK1KPKbKfKeKdKdKeKbK`K_K_K]K]K_K`KaKfKjKmKnKnKnKmKlKkKeKWKTKVKXKWKVKTKNKUKWKQKIKNKOK\K]K]KXK]KUK]KWKGK]KcKrKhKZK[KWK/K'K)K'K"K K K"KKKKKK#K$K$K$K%K KKK%K)K'K'K+K$K K!K!K%K+K+K*K,K+K$KK K)K1K1K1K2K/K'K'K'K)K/K.K.K/K1K'K!K K,K6K5K4K5K2K-K.K-K/K5K5K6K8K:K)KK"K1K6K5K5K5K.K.K0K/K0K7K4K3K1K,K"K K"K)K+K+K,K3K2K2K5K6K:K8K)K(K+K#KK!K&K$K&K)K5K8K6K6K9K=K6K9K4K'K$K"K$K%K"K$K%K!K:KqKsKsKsKsKsKsKsKsKsKsKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKxKYKFKMKLKKKLKKKKKKKKKKKKKKKLKLKKKIK1KKKK>KK>K?K>K>K=KK?K>K>K?K>K>K=KKKEKFKFKFKLKKKIKBK>K>K=K=K=K>K?K>K>K?K>KK?K>K>K>K>K?K=K=K=K=K>K>K5K,K/K4K5K5K5K8K6K4K2K0K/K/K!KKKK*K3K3K2K2K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3e]qQ(KìKèKãKçKîKæKÂKŒKdK\K`K_K]K\K\K\K]K[KZKZKZK\K\KZKZKZKZKZK\K\K]K[KZKZKZK[K[K[KZKZKZKZKZKZKZKZKZK\K]K\K\K\K\K\K\K\KZKZKZK[K]K[KZK\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K\K\K\K\K\K\K\K^K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaKaK_K_K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKbKbKaK_K_K_K`KaK\KNKGKMKLKK>K?K@K=K=K?K=KK?K?K>KK>K?K@K=K3K+K/K3K5K5K5K5K5K4K3K.K0K-KKKKK,K1K3K3K3K3K3K3K3K3K3K3K4K1K3K3K3K3K3K3K3e]qR(KªKÙKîKêKãKæKìKéKËK›KlKZK[K_K^K\K\K\K[K[K[K\K\KZK[K[K[K[K\K\K\K[KZKZKZK[K[KZK[K[K[KZKZKZKZKZKZK[K\K\K\K\K\K\K\K\K[K[K[K\K]K[K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K]K\K\K\K\K\K]K]K]K]K\K^K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaKaK_K`K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKcKaKaKaKaK`KaKaKYKLKJKIKSKVKJKLKVK_KgKjKjKmKsKvKwKuKtKsKoKmKkKjKfKfKfKdKcKfKdKeKgKgKgKhKhKgKgKfKfK[KLKQKVKVKVKUKUKUKTKSKMKJKPKMK[K\KSK_KgKYKcKaK[KjKqK^KXK]KBK#K*K)K%KKKKKKKKKK#K#K#K$K KKKK'K(K(K)K(KKK!K K&K,K*K,K+K(K!KK#K.K0K.K/K2K'K#K"K%K,K0K.K/K,K(KKK(K3K2K3K4K2K-K.K-K.K3K8K5K4K;K.KKK1K7K4K8K7K/K-K.K-K/K:K9K5K5K0K#KK#K,K,K-K,K2K0K/K2K2K9K5K)K+K*K KKK$K&K&K*K4K4K7K8K6KK?KK=K>K?K>K>K=K=K>K>K>K>K>K>K=KK=K?KK?K?K?K?K?K?K?K?K?K>KK>KK?K?K?K>K=K=K=K=K=K=K=K=K=K>K>K>K>K>KK?K?K>KKKK>K=KK?K=K=KK?K>K=K=KK>K=KK?K?K>K?K=KK>KK?K?K=KK>KK;K=K?K=KKK>K>K=KKK?K=KKK?K>K>K>K>K>K=KK>K?K>KK=K:KK?K?K?K?K>K?K=K=K>K?K>K=KK>K=KK?K>K?K>K?K?K>KK?K=K=K?K?K?K=KK>K=K>K8K,K-K1K4K5K5K5K3K2K3K2K-K/K-K*K/K/K1K0K1K3K3K3K3K3e]q`(KMKSK[KeKqK…K•K¢K²KÁKÏK×KÓKÙKØKÐKìKçKéKéKéKèKéKìKÙKªKÚKÓKÆK°KŽKKÎKîKíKåKåKïKìKÐKŸKqK]K_K`KaK_K^K^K_K_K]K]K]K]K]K\K]K]K]K]K\K\K]K]K]K^K`K_K_K]K^K_K_K_K^K]K]K^K_K_K_K_K_K_K`K^K_K_K_K_K_K_K_K_K_K_K_K_K_K`K^K_K`K_K_K_K_K_K_K_K_K_K_K_K`K`K`KaKaKaK`KaKaKaKaKaKaKaKaKaKaKbKaKaKcKbKbKdKdKbKVKPKVKUKSKRKXK`KcKcKbKaKdKTKPKRKXK^K^KaKdKfKjKmKpKtKvKvKwKwKuKrKoKlKkKiKgKeKeKdKcKdKdKcKfKgKfKfKfKfKfKfKhKgKgKfKfKeKcKbK_K\K\K\KYKWKYKVKWK[KZKWKOKOKRKSKRKSK\K\K\K]K]KNKUKUKaKfK]KVKiK\KQK\K[K8K!K%K%KKK +KKKKK KKKKKKKKK K K +K K K +K K KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK K%KKKKKKKKKKKKKK K"K)K(K,K#KKKK K!K#K%K&K,KkKtKsKsKsKsKtKtKuKuKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKwKuKvKyKxKxKxKxKwKxKxKxKxKxKxKxKxKxKxKuKZKLKMKLKLKLKKKLKKKKKKKKKKKKKLKKKLK@KKK#KCKFKFKFKFKHKJKJKBK>K?K>K=K>K>K>K>K>KK=K=K?K>K?K=KK>KK7K*K/K4K4K4K5K4K3K2K1K/K.K-K,K,K/K1K/K0K3K3K3K3K3e]qa(K\KZKXKTKOKMKKKHKGKLKRKRK¯KòKËKÝKëKèKéKéKèKèKéKïKºK[K¢KÚKªK¡KÌKºKK‘KÂKèKïKèKæKíKíKØK«KzK^K_KaK_K_K_K_K`K`K`K`K_K\K]K`K`K`K`K`K`K`K`K`K_K_K_K`K`K_K_K_K_K`K`K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KbK`K_K_K_KaKaKaKaKaKbKaKbKbKbKaKaKcKdKeKeKcKaKXKPKVKZKHKHKTKGKVK`KaKaKbKaKdKVKQKQK?KRKbKiKkKlKoKoKnKlKlKjKfKdKdKcKcKcKcKdKdKdKeKeKeKeKeKeKfKhKgKfKdKbK`K_K^K]K]K\KZKYKZKZK]K`KbKdKhKhKhKgKeKhKjKbKQKOKRKSKQKTKVKZK^KZKSKNKQKUKZKdK^KWKcKcKRKZKZK2K$K$K%KKKKKKKKK KKKKKKKK +K +K +K +K +KK K K KKKKKKKKK K K K K K KKKKKKKKKKKK KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK K%K&K+K KKKK K!K%K'K"KBKwKsKsKsKsKsKtKvKuKuKuKuKuKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKyKxKxKxKxKuKvKyKxKxKxKxKxKxKxKxKzKrKTKMKMKNKMKKKLKKKKKKKKKKKKKKKKKKKMK=KKK(KEKFKFKFKHKIKJKHKBK>K=K;KKK?K=KK=KK?K=KK=KK?K=KK>KKK>K>K>K?K=KK>K=K=K=K>K>K>K>KKZKdK]KWK]KaKaKaK_K]KaKbKbK`KaKYKNKTKFKcKcKdK_K^K^K_K_K`KbKcKeKlKnKqKsKvKyKxKxKvKvKrKqKnKlKhKfKeKdKdKeKeKdKeKfKfKfKfKfKgKfKfKgKgKgKgKhKhKhKhKhKfKeKeKYKEKFKMKNKNKPKQKNKRKSKJKIKQKEKHKfKVKNKVKZKPK>KK$K'K KK K KK K K KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK%KKKKKKK$K&K$K*KiKvKsKsKsKtKtKsKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKvKuKuKuKuKuKuKuKvKvKvKvKuKuKvKvKvKuKvKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKtK[KMKNKLKKKLKLKKKMKMKKKLKKKKKLKJKKKHK&KKK>KJKGKGKEKGKJKKKGK?KK?K?K?K?K=K=K>K>KK?K?K>KK>K>K>K>K?K>K=K=KK>K?K>KKKK`KfKjKjKmKoKmKjKjKhKfKeKdKcKcKcKdKfKdKfKgKgKgKgKfKfKfKfKgKgKgKhKgKfKfKdKdKaK_K]KZKYKXKUKTKUKTKUKWKWKWKPKJKMKOKOKQKMKLKNKNKOKKKKKRKUKTKEKSK;K`K`KQKQKYKFKK#K K"KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK!K%K'K&KZKwKsKsKsKsKuKuKsKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKxKvKuKuKuKuKuKuKwKxKxKwKvKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKnKQKKKLKMKMKNKLKKKMKMKMKMKLKKKLKKKNK@KKK!KCKJKGKFKFKGKKKMKGK>K=K?K>K>K>K>K?K=KK>K?K>K>K=K=KK>K?K=K?K=KK?K>K?K?K=KK?K=KK?K?K>K?K>K=KK>K?K>K?K?K=K>K?K>K>K=KK?K>K?K>K?K>KK>K>K?K>K?K?K>K?K>KKSK˜KÌKÄK–KŒK¸KæKóKëKéKïKòKàK­KzKaK_KdKeKbKaKaKaKaKaKaKaKaK_K_K_K_K_K_K_K_K_K_K`KaK_K`KaKaKaK`K_K_K_K_K_K_KaKaKaKaKaKaKbK_K`KaKcKdKeKgKiKgKbKZK\KcK\KCK1K?K]KaK_KaKaKbKcK`K\K_KbKbKcKaK[K[K^KaKcKcK^K\K_KaK`K`K`KbKPKWKFKYKeKaKcK`K_K]K]K_KaKaKcKcKdKhKkKoKqKsKvKsKrKsKsKqKoKnKlKjKjKjKhKfKfKfKfKfKfKgKfKfKfKiKhKbK[KQKPKQKQKQKPKQKOKMKDKK>K>K>K>K>K?K>K?K>K>K?K>K?K>K=K>K>K>K=KKNKVKLKBKLKRKSKEKPK;KSK]KLKEKZKNK'K$K"KKK KKK K K KKKKKKKKKKKK"KKKKKK!K$K$K$K$K$K#K#K$K$K$K$K%K&K&K&K%K&K&K%K%K%K&K%K%K%K%K&K&K&K$K%K'K(K%K%K%K&K&K'K'K&K&K&K%K%K&K%K$K(K(K&K&K&K&K)K)K'K(K(K(K(K(K)K*K*K*K(K'K(K(K)K(K%K(K(K'K'K$K$K$K"K!K#K#K!K"K KKKKK!K(K*K$KXKvKsKsKsKsKsKsKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKvKuKuKuKwKxKwKyKxKxKvKvKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KnKRKMKNKMKMKMKNKMKKKLKNKMKJKKKLKLKKKHKBKAK=KDKIKJKFKDKDKGKJKDK>K>K?K>K>K>K?K>K?K>K?K>K>K>K>K>K=KK>K?K>K=K=KK=KGKLKJKDKEKFKHKHKDK?K>K?K?K?K?K?K>K>K>K>K?K?K>KK?K=K=K>K>K?K=KK>K>K>K>K?K>K?K?K>K>K=KK?KK?K>KK;KFKKKYK[KNKHKVKFK(K(K)K"K +KKKKK +KKKKKKKKKKKKKKKKKK%K&K%K&KKKK$K&K'K&K'K KKKK'K+K*K*K(K!KK K(K)K)K,K/K*K+K.K0K0K*K+K+K(K"KK#K)K)K(K+K2K0K0K0K0K.K,K.K.K.K)K'K-K1K0K1K4K2K-K)K-K0K3K=K=K9K,K"K'K0K1K.K-K-K*K)K)K)K)K(K(K&K(K'K(K#K#K&K%K)KfKwKrKtKuKuKvKtKsKsKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKyKvKvKyKxKtKwKyKvKuKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKwK]KKKKKKKKKLKKKKKLKKKLKNKNKNKMKKKMKFKCKDK@KBKJKMKIKGKFKHKKKIKAKK?K@K=KK?KK>K?K;KK;K8K;K3K/K3K1K3K/K&K"KKK K"K K&K'K"KK>K?K>K?K?K>K>K>K=K>K?K=K=K>K>K?K>KK=K;K=K8K.K/K3K3K3K3K4K3K2e]qq(KlKgKaK^K_KZKtKÛKçKÅKèKéKçKçKéKèKçKìKãKçK½KjKaKgKdKeKbK~K×KÒKuK\KcKbKeKcK€KØKËKpK\KcKcKeKhK¢KçK¦K_K`KbKcKcK‹KáKÂKhK_KeKdKhK’KÙK³KŠK¿KÏK¦KŽK­KÞKöKïKèKíKóKãK¸K‚KeK_KeKfKeKbKbKaKaKaKaKaKaKaKaKaKaKbKbKbK`K`KeKhKlKlKlKmKdK\K\KeKaKGKMKdKgKcKaKaKdKdKdKcKaKaKaKbKaKaKcKaKbKbKbKaKaKbKaKbKbKcK`K_KaKcKaKcK]KZK_KaK_K`K_KbKYKSKQKJKgKdKdKcKbKaKaK^K\K\K\K\K]K\K[K]K^K^K^KbK`KbKeKdKdKfKiKjKhKfKcKZKUKSKSKQKPKPKRKSKNKFKK>K?K?K?K?K?K>K?K>KK6K/K1K0K1K6K'KKKKKK$K)K)K&K0KkKtKsKsKsKtKtKsKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKvKvKvKxKxKvKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKyKxKyKyKxKxKzKiKNKMKMKKKLKLKKKLKMKMKKKLKLKLKKKMKKKDKBKIKDKGKMKLKGKFKGKHKIKFK@K>K>K=K>K?K>K>K>K>K>K>K>K>K>K>K>K?K=KK>KK3K,K4KAKCKCK,KKKVKKKMKXKIK,K*K*K(KK K KKK K K K K K K K K K K K K K KKK K$K&K%K KKK K"K!K"K$KKKKK%K+K+K)K)K!KKK(K)K&K*K)K'K+K*K.K,K)K*K-K'K!KK#K'K$K&K*K/K-K/K0K/K*K*K+K+K(K!K#K,K*K,K0K5K4K*K)K0K1K7K>KHKEK-KK2KLKIKFK@K2K/K1K/K2K0KKKKKKK%K)K)K#KIKtKrKtKsKsKsKsKsKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKuKuKvKvKuKuKuKuKuKxKxKuKvKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKyKxKxKxKxKxKxKzKdKNKKKKKLKLKKKLKNKMKKKKKKKKKLKKKLKIKBKGKEKAKFKMKKKGKFKHKHKIKFK@K;KK?K>K>K>K>K>K?K>K>K>K?K?K?K=KK>KKLKJKHK?K0K2K3K/K2K)KKK!K!K!KK%K)K)K+KdKwKsKsKsKsKsKsKsKuKuKuKuKsKtKvKtKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKyKvKuKxKxKuKuKuKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKwK^KKKLKKKKKKKLKMKMKKKKKKKKKKKLKKKJKIKDKCKCKDKHKMKLKFKDKGKIKHKFK@K=K>K?K>K>K?K>K?K?K>K?K>K>K>K?K=KK5K+K-K3K3K3e]qu(KdKcKaKdK]K“KïKÔKÊKêKåKçKçKçKçKèKçKîK¨K_KfK_KaK«KìK¤K^K`K`KaKeK`K’KæK¹KdK]KeKdKdKaK”KæKµKdK^KdKcKeKpKºKâKŽK\KcKbKcKdKKåK¨K_KcKeKdKfK£KçK§K^KNK7K?K~KÃKÊKžKŒKÅKðKëKîKæKáKòKæK¼K‡KhKfKmKgKeKhKvKuK™K…KlKqK[KPKbKaKGK.K8KUKhKjKhKfKcKaKbKeKfKcKcKdKdKcKeKeKcKbKbKcKeKdKdKeKeKbKbKdKbKaKbKbKdKeKbK_K\K]KbKaK]K\KaK`K^K\K_KQKKKSK7KcKfKdKdKfKeKbKdKfKeKeKfKfKeKfKgKfKfKgKgKdKdK_KVKTKRKTKVKTKSKSKQKJK>K4K1K1K6K4K6K@KMKXKUKOKMKLKMKMKLKKKKKKKIKHKIKHKHKGKGKHKDK;K0K%K'K'K$K3KCKAKFK8K4KWKLKIKNKSK:K,K,K,K#KKKKKKK K K KKKKK K K K +K K KKK!K"KKKKK!K K K"KKKKKK)K+K*K'K$KKK K'K)K'K)K'K)K(K*K.K,K)K'K'K!KKK&K&K&K&K*K,K-K-K.K-K+K*K*K+K#KK$K*K+K+K1K4K0K(K0K/K1K6K?KGK;K!K'KEKEKHKHK9K.K1K2K0K1K#KKK!K!K!KK%K*K&K;KtKsKsKtKsKsKtKtKsKuKuKuKuKtKtKvKtKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKxKwKvKwKwKvKvKvKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKyKxKyKzKzK{KtKTKJKLKLKLKLKMKMKLKLKLKLKKKKKLKMKLKIKEKCKDKEKHKMKLKFKFKHKHKHKHKAKK?K>K?K>K?K?K>K>K>K>K>K?K>K=K=K=K=K>K?K=KK=K6K,K.K3K2e]qv(KbKbKaKeKfKºKïKÆKØKêKæKçKçKçKéKêKåKãK‚K`KfKbKbKaK˜KçK·KcK_KbKbKdKcK‚KÜKÍKoK]KeKaKeK\K…KÝKÆKkK]KgKfKeKfK§KèKŸK[KbKdKgKcKŒKáK¼KhK`KfKgKeKKãKºKiKcKUK4K2KmKÜKÌK¢KðKêKïKåKáKíKçKñKïK¼K¢KÉKÄKKuK{KzKK|KmKuKPK]KBKK'KOKdKgKjKjKhKcKaKbKgKgKgKdKaKdKeKeKdKeKeKeKeKeKdKeKeKeKeKbKaKaKaKaKcKeKdK`K`K]K^KbKaKdK[KYKaK`K^K\K]KRKGKVK?KbKeKdKeKeKeKeKeKeKeKeKeKeKeKeKeKdKdKcK`K\KWKTKTKVKSKSKSKTKQKGK;K3K2K4K4K5K8KBKMKWKUKOKLKKKKKKKLKLKLKLKIKHKIKIKIKGKGKHKCK:K/K)K)K$K&K'K%K-KCKBKBK@K/KQKNKIKGKUKCK-K.K.K)KKKK"KKKKKKKKKK K K K K +K KKKKKKKKKK!K!KKKKKKK)K(K)K'K KKK#K'K)K(K(K"K%K(K+K+K)K(K)K(KKK"K&K&K%K&K)K*K+K+K/K+K*K'K)K&K K K'K+K*K+K1K1K+K(K-K0K1K2K7KAK1KK/KAKAKFKCK2K.K0K0K3K0KKKK!K!K K"K'K)K%KUKwKrKsKsKsKtKvKuKsKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKyKuKuKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxK{KzKxKxKxKzKzKzKpKPKKKNKLKLKMKNKNKNKNKLKKKLKKKKKKKLKIKDKGKDKBKIKPKLKFKFKFKHKKKFK>K:K>K?K>K?K>K>K>K>K>K>K>K>K?K?K?K?K?K?K?K=KKK?K>K>K>K>K>K>K>K>K>K>K>K>K>K>K=K=K>K=KK?K>K>K>K?K?K?K?K?K?K>K>K>K?K>KK`KeKjKkKiKaKaKgKiKiKiKeKbKbKeKgKeKdKbKcKdKeKfKeKdKbKbKdKdKdKdKdKdKeKdKaK`KcKcKdKdKdKbKUKKKWK]K^K]K]K\K]KVKDKKKLKTKWKXK[K_K`K]KcKdKeKgKjKgK_KXKUKVKVKUKSKSKUKSKNKBK8K3K3K5K6K7K;KJKVKWKQKKKMKMKNKMKKKLKLKLKKKIKHKIKHKHKIKHK=K0K)K%K(K)K&K(K%KKKKKKKK5KDKAKFK:K3KUKOKFKEKUK=K.K/K.K)KKK!K K!K K!K$K!KKKKKKKKKKKKKKKKKKKKKKKKKK&K&K%K&K"KKK"K$K&K(K%KK K"K"K'K)K)K)K&KKK K&K$K$K(K$K#K&K)K+K+K)K(K(K#KKK$K)K)K)K/K0K)K$K0K/K*K*K*K/K)KK!K%K'K*K.K.K.K-K,K2K+KKK K K K"K#K)K+K)K]KwKsKsKsKsKsKtKuKuKuKtKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKvKwKxKxKxKvKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKyKxKzKzKzKzKzKzKzKzKzKzKyK{KyK^KKKKKLKKKKKLKMKLKKKJKMKJKLKKKLKLKIKDKGKAK7KFKOKPKIKFKFKHKIKEK@K>K>K?K?K=K=K=K=K=K>K?K>K>K=K=K>K>K>K=KK>K>K=KK>K>K=K=K?K?K?K=KKK?K>K>K?K>KKK=KK?K>K>K?K>K=K=KK?K?K?K?K?K?K=KKJKVKZKSKOKPKQKPKOKOKOKNKMKMKLKMKLKKKKKLKHK=K1K)K'K'K(K(K)K'KKKKKKKK!K!K KKKKKKKKKK(K@KBKDKCK/KPKTKLKEKTKKK4K3K0K1K&K K KKKK%K+K,K%K"K$K$K$K#K#K#K KKKKKKKKKKKKKKKKKK KKKKK!K!K"KKKKKK%K%K&K%K KKK$K%K#K%K$KKKK!K'K)K(K*K&KKK K&K&K'K*K*K(K K'K,K+K#K$K&KKKK"K%K$K&K+K,K,K-K/K+KKK!K!K"K"K%K+K.K,K\KwKrKsKtKtKtKtKuKuKuKuKuKuKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{KzKyK^KLKNKNKMKNKNKMKKKLKKKLKMKLKKKLKJKKKIK-KKK3KKKOKKKFKFKFKFKHKDK=KK=K=K=K>K?K=KKK>KK>KK>e]qƒ(KÝKÛKàKèKâKÜKéKæKèKçKçKëKéKìKK_KfKfKcK[K–KéKÀKlK_KcKbKeKeKcK§KîK®KcKaKcKaKeKbKwKÏKÝK€K]KfKdKcKcKiK¸KéK”K]KeKdKgKcKhKºKæK‘K]KeKeKfK`K€KÜKÏKrK`KgKjK`K±KóK¼KëKîKïKèKèKðKñKñKõKÚKœKÄKæK§KuK‡K‚KˆKšKtKuKKcKdKYK_KeKcKfKkKjKiKdKcKdKeKfKjKjKdKdKeKeKhKhKfKeKeKeKbKbKeKdKdKeKdKdKcK_K`KdKeKdKdKcK^KXK\KcKdKcK`KYKZKVKUK[KTKRKXKRKLKVKTKIK:K4K5K5K:K:K?KKKWKZKTKOKPKSKRKPKQKPKPKPKPKOKNKMKMKNKOKJKK>KK=KK?e]q„(KÜKÙKßKæKÛKäKéKèKäKæKçKáKåK×KqKfKiKdKfKfKZKƒKâKÓKxK`KfKdKeKdK_K”KèKÁKjK_KfKeKfKcKlK½KéK“K_KcKbKcKeKeK§KìK¬KaKcKeKcKhKeK¦KìK¥KaKcKfKfK`KqKÌKÝKK_KkKfKÄKëKÁKðKíKïKæKêKñKðKïKöKÑKžKÊKáK•KwKŠK‡K“KKtKuK€KgKaK?KbKcKgKjKjKhKdKeKeKfKhKjKiKdKdKdKdKiKjKhKcKaKcKeKdKdKeKeKdKfKcKaKaKaKbKeKfKdKbK^K[K]KaKdKdKeK]KVKVKLKMKWKTKRKZKKKCKDK9K3K3K6K8K9KBKNKYKXKTKOKNKQKPKRKSKPKQKPKOKQKPKLKMKOKOKIK:K0K)K'K)K)K*K)K$KKKKKKKK$K$K!KKKKKKKKKKKKKKKKKKK!K#K$K"KKK;KGKCKEK?KDKVKPKGKLKWKAK3K5K4K0K(K$KKKKK!K$K$K#K"K'K.K3K4K.K)K&K%K$K$K$K#K$K$K!KKKKKKKKKK K KKKKKKKKK"K#K$K!KKKK K K!K"KKKKK#K'K%K'K%KKKK$K&K$K'K%K!KK$K)K'K!K!K"K KKK K!KK$K*K,K.K.K.K"KKKKK!K$K+K3K2KK?K?K>KK0KSKRKKKFKUKJK4K5K4K5K+K$KKK K!K!K!K"K&K0K5K3K.K+K+K,K+K(K%K#K"K#K$K#K#K&K"KKKKKKKKKK K KKKKKKK!K K"KKKKK!K K!KKKKKK%K&K%K'K#KKKK$K%K$K'K"KK!K&K)K$KK!K!KKKK K!KK%K.K-K/K.K.KKK KKK!K%K4K5K1KOKxKuKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKxKxKwKwKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKyKxKyKyKyKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|KpKVKLKKKKKLKKKLKKKLKLKMKKKKKKKLKKKHKJKGK*KKK5KLKOKLKFKDKFKGKGKCK>KK=K=K>K>KK>KKPKXKWKRKSKSKSKRKRKQKQKQKQKQKPKMKNKOKQKMKCK5K'K%K*K*K(K*K%KKKKKKK K&K(K"KKKKKKKKKKKKKKKKKKKK%K(K"KKKKKKKKK K+KCKEKBKGK0KCKXKOKEKMKTK@K5K5K5K1K+K$KK#K)K/K2K-K*K)K)K,K-K.K,K.K2K4K4K,K%K$K$K$K$K"K$K$K%K$K KKKKKKKKKKK KKKKKKKKKKKKKKKKKK$K$K$K$KKKK#K$K#K(K#KKK#K&K'K KK KKKKKKK"K+K-K.K.K1K"KKKKKKK3KK=K=KK>KK/K)K*K*K*K*K)K$KKKKKKK"K(K'K KKKKKKKKKKKKKKKKKKKK'K'K!KKK KKKK!KKK%K%K$K=KEKCKFK8K5KYKQKHKNKVKGK5K5K5K4K.K)K&K,K+K'K(K(K(K*K+K-K-K-K0K4K2K(K"K K$K$K$K$K$K"K$K$K#K$K%K#KKKKKKKKKKKKKKKKKKKKKKKKKKK"K$K#K$K!KKKK$K#K#K%K KKK#K'K KKK KKKKKKK$K(K,K/K2K0KKKKK KK$K5K=K;KJKuKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKyKxKyKyKxKxKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K{K_KNKNKLKKKLKKKKKKKLKJKIKKKKKLKJKHKHKIK>KK K KDKOKNKIKDKFKGKGKEKAK=KK>KKJKPKWKSKQKFKEKTKUKUKRKRKSKRKRKSKQKPKPKQKSKOKBK4K(K'K(K*K)K'K%K!KKKKKK#K)K,K'KKKKKKKKKKKKKKKKKKK#K)K)K#KKK K!K!K KK K!K(K'K"KKKKKKKK!KCKEKBKHK/K@KXKOKIKOKUKDK7K8K6K1K-K)K!K!K#K&K,K/K*K&K#K"K$K$K$K$K$K#K"K!K!K$K$K$K#K!K$K+K0K&K#K$K$K#K#K$KKKKKKKKKKKK KKKKKKKKKK!K$K#KKKKK#K$K#K$K KKKK$K!KKKKKKKKKKK$K#K'K.K/KKKKKKKK$K@K—KÔKÏKKpKwKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KyKxKzKzKxKxKxKyK{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{KiKPKJKLKLKKKKKLKKKKKLKLKKKKKKKKKLKKKMKIK,KKK3KJKPKKKGKFKGKGKEKBK=K=K=K=KK?KAKCKIKSKSKRKGKDKNKVKWKWKUKRKRKSKRKRKRKQKPKRKOKBK0K)K'K)K+K*K*K$K!KKKKK!K'K*K)K$KKKKK KKKKKKKKKKKKKK$K+K(K#K KK!K"K"K K!K#K%K)K$K KKKKKKKKKKK;KGKDKFK6K4KWKRKKKLKWKKK8K9K8K6K1K-K#K"K*K-K+K%K!K#K#K$K"K"K#K K K"K"K"K"K"K$K$K&K,K4K7K6K1K,K$K$K$K$K#K$K#KKKKKKKKKK K K KKKKKKKK K"K!KKKKK!K"K#K!KKKKK%KKKKKKKKKKK!K"K"K%K.K$KKKKKK K!K,KœKÓKËKÒK¹KwKvKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKwKwKwKwKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKyKxKzKzKyKyKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K|K|K|K{KzKzKzK{KzKzKdKKKKKLKMKLKKKLKKKKKKKKKKKKKKKKKLKKKIKEK(KKK8KNKPKNKFKEKGKDKDKDK=KK.K(K&K+K,K,K(K"KKKKKK K'K)K&K"KK K!K!KKKKKKKKKKKKKKK#K*K'K KK K!K!K"K$K!K$K(K(K!KKKKKKKKKKKKKK1KFKFKGK>K-KRKSKNKJKTKQK;K9K8K8K4K-K*K&K%K!K"K#K$K$K"K K K K K K!K"K K#K"K"K*K1K7KKAKFKPKXK[KYKXKSKPKVKVKUKUKVKUKSKTKTKRKRKTKRKIKK=K?K@KBKCKMKZK]K[KWKWKWKXKWKVKUKVKVKVKTKRKRKQKPKPKHK9K,K'K*K,K+K)K(K#KKKKK K%K+K*K"KKKKKK K!KKKKKKKKKKKK K&K*K'K!K K!K$K$K$K#K$K'K+K)K!KKKKKKKKKKKKKKKKKK!KCKDKCKFK7KAKYKQKIKIKWKFK9K:K9K8K4K-K!KK KKKKKKK K"K"K!K!K$K.K6K9K8K8K8K7K/K1K4K9K=K;K2K+K&K%K$K$K$K$K$K$K%K!KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK'K!KKKKKK!K!K#K)K'KxKÐKËKÎKÕK›KtKvKvKuKuKuKuKuKuKuKuKuKuKuKuKuKvKyKwKuKwKyKxKxKuKvKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKzKzKxKxKxKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{KzK{K~K|KzK{K}KqKQKKKMKNKMKLKLKKKKKKKKKKKKKLKKKHKHKHKKKKFKDKFK9K2KZKRKHKFKUKKK:K;K9K8K4K3K&KKKKKKK K!KKK#K(K/K8K;K8K9K8K4K3K0K2K:K=K;K1K)K$K#K$K!K"K#K$K%K%K$K$K$K$KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK"KK KKKKK!K"K$K&K)K:K²KÏKËKÒKÂK}KwKxKuKuKuKuKuKuKvKxKwKuKuKuKuKvKyKwKuKwKyKxKxKuKvKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKzKzKzKzKzKyKxKxKxKxKxKxKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|K}K}K}K~K|KzK|K}K~KjKPKKKLKLKLKLKKKKKKKKKKKKKLKKKHKHKHKJKJK4KKK(KHKOKMKHKEKGKFKGKFK@K:K=K=KKKK9K>K8K;KK:e]qš(KdKdKeKfKcK^KUKPKNKMKKKKKMKbKŒKÂKåKïKéKäKåKçKèKèKèKéKéKéKëKìKëKìKíKëKéKëKïKïKÜK·K‹KoKhKnKvKyKzKuKsK€K KÉKæKñKíKéKêKëKëKéKìKðKñKÚK³K~KdK¬KñK«KzKéKÙKÆKõKïKòKæKìKòKðKðKóKêKªK·KæK·KwKKˆKƒK›KK|K|KˆKlKdK=KhK^KYKhKmKjKiKiKiKiKgKeKaK]K^K`KcKgKiKiKgKbK`K_K^K\K\K\KZK[K\K\K\K[KZKZKYKXKWKJK9K,K(K*K+K,K*K#KK"K"K#K&K*K*K,K)K%K&K+K*K(K'KKKKKKKKKKKKK#K&K/K4K2K1K3K1K3K2K0K0K2K1K+K#K KKKKKKKKKKKKKKKKKK-K.K+K%K#K$K%K#K#K!K%K,K-K'KKKKKKKKKKKKKK'KCKCKDKEK,KEKXKPKFKJKWKHK:K:K:K9K8K7K#KKKKKKKKKKKK K"K KKK$K-K6KKe]q›(KdKeKeKdKeKeKfKaK]KUKNKMKMKIKFKRKtK¦KÖKìKìKçKåKæKèKéKéKéKìKìKìKìKëKîKîKìKéKçKëKïKêKÎK¢KzKgKkKrKwKxKuKtKuKK·KÛKîKñKìKêKëKëKêKëKðKóKçKÄKŽK§KæKÆKíKÐKÐK÷KïKòKåKíKòKïKïK÷KÝK˜K¾KèK²KtKŒK†K„KœKˆK~KK‡KiKaKVKfK_KkKlKkKiKiKjKjKgKdK_K`KbKfKjKmKnKiKeKbK_K`K_K\K]K]K\KZKZKZKZKZKZK[K\KXKHK2K)K,K-K,K,K)K%K K K!K!K%K)K.K+K'K&K%K%K%K*K+K)K)K$KKKKK K KKKKK(K0K4K2K2K3K3K3K2K2K3K4K,K&K#K K K!K!K!K!KKKKKKKKKKKK"K+K.K)K%K$K$K$K&K%K$K(K+K,K"KKKKKKKKKKKKKKKKKAKDKCKFK8K:K\KSKJKGKWKNKK>K;K7K2K5K:K9K;K?K9K2K'K#K"K&K'K&K$K!K"K#K#K&K'K&K&K$K%K,K7KAKKDKCKFK>K2KXKRKMKDKQKTK>K;KK1K&K%K%K#K$K#KKKKKKKKKKKK K KKKKKK KKKKKKKKKK K"K$K&K'K(K)K*K+K.K1K;K¨K×KÒKÕKÒKŒKtKyKxKxKxKwKxKxKvKuKvKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKyKxKyKyKxKxKxKyKzKzKzKzKzKzKzKzKyKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KwKXKIKJKJKIKKKJKIKIKIKLKKKJKIKHKIKHKHKHKIK3KKK"KDKKKOKKKFKEKFKEKDe]q(KdKdKdKdKdKdKdKdKdKdKeKfKcKZKRKJKLKKKIKFKRKoK¡KÐKêKîKéKæKæKèKêKëKìKëKëKìKëKèKêKìKëKêKçKìKóKíKÑK£K}KlKkKsKyKyKvKrKxKK¾KÞKðKïKëKìKíKíKìKíKòKïKåKæK¼KæKóKðKðKæKïKñKñKïK÷KÇKžKÏKéK•K{KŒK†K„K¡K„K|K…K€KaKnKoKoKmKkKlKlKkKeKbKbKfKjKmKmKnKmKlKhKcKaK_K`K`K_K`K^K\K^K[K\K]K[K[KRKAK0K&K)K+K,K+K)K#KKKKK!K%K*K,K'K"K&K%K(K)K&K&K KK'K+K'K)K)KKKKK K KK KKK,K3K5K5K6K8K2K+K!KKKKK"K!KKKKKKKKKKKK!K+K-K+K(K$K%K'K&K#K"K&K+K*K*K%KKKKKKKKKKKKKKKKKKK%K&K7KDKCKCKDK.KOKTKOKFKMKYKDK:K=K=K=K:K7KKKKKKKKKK"K(K-K2K4K4K6K:KK@K;K2K(K!K!K!K$K$K#K"K"K!K!K$K%K)K*K'K%K+K5KBKMKKKHKIKIKBK@K?K9K0K$K$K$K#K"K$KKKKKKKKKKKK KKKKKK KKKKKKKKK K"K$K%K&K(K)K+K*K-K0K-KgKÒKÔKÕK×K²KvKyKxKxKxKyKxKxKvKuKuKvKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KyKxKxKxKxKxKxKzK{KzKzKzKzKzKzKzKyKxKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KrKSKIKIKIKLKJKHKHKHKJKJKHKHKIKIKIKGKFKHKHK/KKK(KEKLKPKIKFKGKDKCe]qž(KbKcKdKdKdKdKdKeKcKaKdKeKeKeKaK_KWKMKIKIKKKGKHK[K…K·KàKïKîKçKçKèKéKéKéKéKéKèKêKìKìKìKëKëKêKëKðKòKâK½KKpKhKnKvKyKwKtKuK‚K¥KÎKêKñKïKíKîKíKíKíKðKïKÎKæKïKðKíKçKñKðKñKðKöK¼K¤KÐKåKŒK}K‹K…K‰K¢KKzKyKxKsKpKnKlKmKkKiKeKbKdKgKkKmKoKoKkKlKkKkKiKbK_K`K_K`K_K]K]K\K]K]K\K[KRK@K.K(K*K-K-K+K(K#KKKKK!K%K'K'K&K%K%K$K%K)K(K%K KK"K%K(K)K)K)K*K'KKKKK KKKKK(K0K7KK7K.K%KK"K$K!K!K!K"K"K!K$K)K)K(K(K%K(K/K=KHKIKKKKKHKFKAKAKCKFKDK5K*K$K"K"K%K$K$K%K"KKKKKKKKKK K KKK +KK KKKKKKKKK!K!K#K&K)K)K)K+K*K,K/K3K;K©KØKÕKÕKÓKKuKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KyKxKzKzKzKzKzKzKzKzKzKzKzKzKyKxKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K}K|KzK|K}K}K}K}K}K}K}K}K}K}K}K}K}K{K{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KKKmKOKLKIKIKIKHKJKKKIKHKIKIKIKHKHKHKHKIKIKHK'KKK.KGKNKOKIKFKDKBe]qŸ(KfKeKdKdKdKdKdKeKdKbKcKeKdKdKdKdKdKdK\KSKLKIKJKJKHKLKgKšKÊKêKñKêKæKèKéKéKéKèKêKìKìKìKìKìKìKëKëKèKíKòKìKÐK§K~KjKiKrKuKvKtKrK{K“KºKàKñKõKìKêKíKíKíKíKçKéKëKéKâKíKòKðKðKõK²K§KÒKäK‡KKK„KK KuKuKwKtKpKoKnKlKiKfKfKgKhKmKpKrKoKmKmKkKmKmKiKdK`K_K`K_K`K^K\K[K\K]K[KPK=K-K+K+K,K,K*K%KKKKKK#K&K$K'K#K$K%K%K%K$K%K"KK K"K&K*K*K)K)K(K)K)K*K KKKK K KKKK'K3K1K)KKKKKKKKKKKKKK!KKKK K+K/K0K+K(K&K%K%K%K%K$K)K/K*K"KKKKKKKKKKKKKKKKKKK#K*K)K(K%K&K$K.KDKDKCKGK7K:K[KQKJKDKUKRK=KKBKEKAK6K,K"KK KK!K$K#K$K$K$K%K"KKKKKKKKK K +K KKK KKKKKKKKK!K!K#K&K)K(K)K+K+K/K/K5K1KdKÐKÓKÓKÛK·KvKzKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KyKyKzKzKzKzKzKzKzKzKzKzKzKzKyKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K|K~K|K{K|K}K}K}K}K}K}K}K}K}K}K}K}K}K|K{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KfKLKJKHKIKIKKKLKIKHKIKIKHKIKIKIKIKIKHKJKDK#KKK3KHKNKNKJKFKCe]q (KgKfKeKeKdKdKdKdKdKeKbKeKeKdKdKdKdKeKfKeKaKZKRKKKJKKKGKGKTK}K±KÛKðKïKéKçKèKèKêKìKìKìKìKìKìKìKìKìKëKêKëKñKñKâK¿K“KqKgKkKuKzKyKuKtK‚KªKÓKéKóKïKìKíKíKîKîKìKãKÞKêKëKèKñKòK©K­KÔKÝK€K…K‹K„KŽKšKwKxKsKqKqKoKjKeKdKgKjKnKqKrKrKpKpKpKqKpKmKmKjKdK`K_K_K_K`K^K]K^KZKMK;K.K*K*K-K,K+K%KKKKK!K"K%K&K"K#K%K$K$K$K%K&K"KKK K&K)K)K)K'K&K*K.K)K'K)K'KKKKK KKKK$K"KKKK K KKKKKKKKK KKK K"K-K4K4K1K.K+K(K%K$K$K)K,K.K+K KKKKKKKKKKKKKKKKKK K%K*K)K'K)K&K%K%K%K)K?KEKCKEK>K.KXKSKKKFKRKWKBK:K=KK2K&K"K#K#K!K!K KK"K%K$K#K#K#K$K#KKKKKKKK K K K KK KKKKKKKK K K"K#K&K&K&K*K+K*K.K.K1K5K8K£KØKÓKÙK×KKuKyKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K}K~K}K}K~K{KzK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K{K_KJKHKJKLKLKLKIKHKIKIKHKJKLKIKIKIKHKHKJK?KKKK8KLKNKMKHKDe]q¡(KdKhKfKdKdKdKdKdKdKdKcKeKeKdKdKdKdKdKdKdKdKeKfK_KUKNKJKIKHKCKIKbKKÅKçKñKëKèKèKêKêKêKìKìKìKìKìKìKìKìKëKëKêKìKóKïKÖK«K€KlKlKrKvKuKsKrKyK’K»KáKôKòKíKìKíKíKåKâKìKéKèKòKîK¡K±KÙKÔKxK†K{K}KKšKzKvKpKpKnKiKgKgKkKoKrKtKrKnKmKqKrKpKpKnKlKjKdKbK`K_KaK_K_KaKYKJK6K+K,K-K.K+K*K$KKKKKK!K$K$K!KK K$K#K#K$K!KKKK K$K%K&K*K)K(K(K/K9K8K-K'K)K(K$KKKKKKKKKKKKKKKKKKKKKKKKK#K/K4K5K2K0K0K-K*K&K&K,K.K,K$KKKKKKKKKKKKKKKKKKK$K)K)K(K'K(K(K)K%K&K'K&K%K:KEKCKCKDK*KOKWKMKFKKKXKGK;K=KK=K=K%KK"K#K$K'K)K)K*K,K0K1K/K(K!KKKK!K!KK K K#K%K%K%K%K"K#K&K2K@KFKIKGKAKAKDKGKGKGKAK@K8K-K#K"K#K"K KKK K$K%K'K)K(K%K$K%K$K#K%K"KKKKKKK K +KKK KKKKKKKKK K!K#K&K(K(K+K,K,K-K0K0K4K0KdKÐKÔKÖKÜK¹KxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKzKzKzKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K|K|K}K}K}K{KzK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K}KzKUKGKJKJKJKJKIKHKIKIKHKJKLKIKHKHKJKHKHKIK9KKKK=KJKOKJKEe]q¢(KKhKbKdKhKfKeKdKdKdKdKdKdKdKdKdKdKeKeKeKeKdKdKfKfKbK[KQKIKGKFKGKFKOKsK¨KÖKîKðKêKæKèKìKìKìKìKìKìKìKìKìKìKìKëKìKíKñKôKèKÄK”KqKiKlKrKuKtKqKnKK¥KÑKíKöKïKìKãKãKíKëKëKóKèK›KµKÞKÍKsKˆK†K~K’K˜KvKsKkKgKgKgKkKnKrKrKqKpKnKnKoKnKmKnKoKmKjKeKaK_K_K_KbK`KYKIK1K*K*K-K/K.K(K"KKKKKK!K"K$KKKK K"K$K$K!KKKK!K!K#K$K$K&K)K,K3K:K=K;K8K6K-K(K'K&K!KKKKKKKKKKKKKKKKKKKKKK(K1K8K:K6K1K/K/K,K,K-K0K1K-K"KKKKKKKKKKKKKKKKKKK)K+K(K(K(K)K)K)K(K(K*K)K)K)K"K1KCKCKCKGK.KCKYKNKJKHKUKLK=KK:K:KK5KK K!K"K&K*K(K&K"K KKK KKKKK"K#K%K&K$K"K K%K0K:KEKFKDKAK=K>K=KBKFKGKDK:K.K%K#KK$K KK!K K&K)K+K-K,K*K'K*K,K-K0K.K)K&K$K#K#K!KKKKKKK K +K K K KKKKKKKK K!K#K&K)K*K,K+K,K/K0K/K0K8K5KdKÐKÔKÕKÛK»K|KzKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|K}K|K}K}K}K}K}K|K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KlKMKHKIKIKHKHKIKIKHKIKJKIKHKHKIKHKHKHKIKGK/KKK'KEKNKLe]q¤(KëKðKïKßK¸KKmKdKeKhKiKgKeKeKdKdKdKdKdKdKdKdKdKdKeKdKdKdKfKgKcK]KRKJKFKGKHKGKLKmKŸKÑKêKïKéKèKëKëKìKìKìKëKíKîKîKîKîKîKíKìKíKðKòKçKÃK“KtKgKiKnKpKlKfKdKzK£KÒKêKîKçKìK÷KÓKœKÄKäK¤KrKŒK‹K~K˜KlKMK]KdKiKoKuKsKsKtKtKrKqKpKmKoKmKlKiKhKhKaK_KbK^KUK@K1K*K,K.K/K-K(K"KKKKKK$K$K KK KK K!K!K!K!KKKK K"K K!K K K K)K3K8K=KK>KK>K@K0K$K&K&K#KKKKKK K KKKKKKKKK#K-K7K;K9K5K5K5K3K3K6K7K7K4K)KKKKKKKKKKKKKKKKKKK'K-K.K+K(K(K(K)K*K*K)K*K,K)K&K$K%K$K!K#K#K>KEKBKDK?K,KXKTKOKJKUKWKCK9K>K=K=K=K;K$KK"K%K$K!KKKKKKKKKK"K"K$K$K"K KK(K6KCKGKFKEKDKCKK¢KÙKÔK×KÚK˜KvKyKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK}K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KeKKKHKIKIKHKHKHKIKHKHKHKIKHKHKHKHKIKIKGKCK(KKK-KEKJe]q¥(KíKèKéKîKóKìKÓK«K‚KiKbKeKgKgKgKfKfKfKfKeKdKdKdKdKdKdKdKdKdKdKdKeKgKbKYKPKHKGKGKFKDKXK‚K·KáKñKïKèKçKëKìKìKìKîKîKîKîKîKîKîKîKíKìKïKóKðK×K­K‚KlKfKfKfKaK]KUKÀK÷KëKåKíKôKÉK­KÔKèK”KvKŒK…K‚K—KVKHKaKsKŽKŒKtKyKwKuKsKtKrKpKmKlKkKlKgKbKcKdKaKTK?K/K+K-K/K-K+K&KKKKKKK"K%K KKKK!K!K!KKKKKKK!K!K K!K K!K*K4K8K:K7K:K=K=KKHKKKIKHKEKCK?K;K=KBKCK:K-K%K$K%K%K#KK!K%K&K,K,K+K*K)K)K,K1K2K3K5K4K3K0K.K+K/K1K-K+KKK$K$KKKKKKK K +K KKKKKKK K!K!K#K&K)K+K+K+K,K0K2K2K3K2K8K5KaKÏKÕKÖKÛK¾K{KyKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKzKzKzKxKzK{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK}K}KzKzKzKzKzK}K}K~K}KzK|K~K{K{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K{K{K^KIKJKIKHKFKGKIKHKIKIKHKHKHKHKHKIKJKGKIKEK%KKK/KHe]q¦(KÕKîKôKíKéKèKïKñKæKÈKœKwKbK`KfKiKhKfKfKdKdKeKeKdKeKeKdKdKeKeKeKdKdKeKhKgK_KTKKKGKFKHKFKJKhK™KÎKëKñKîKêKêKëKîKîKíKîKîKîKîKîKîKîKíKìKìKòKôKæKÃK—KtKbK[KZK_KÐKóKíKîKîKòKÑK¸K×KàK‡K}KŠK‡K‚K–KFK9KfKŸK›K€KxKwKuKsKsKtKrKoKkKkKnKjKdKaK^KRK>K.K-K-K.K/K,K$KKKKKKK!K!KKKKKKK!K KKKKK K KK K KK"K+K1K5K8K7K:KKKKK7e]q§(K¢KžK»KÝKóKóKìKéKìKòKðKßK¹K‹KpKdKdKgKgKgKfKgKfKdKfKgKeKdKdKdKdKdKdKdKdKgKgKeKeKZKPKHKFKFKDKFKUKzK±KÞKðKïKêKêKëKìKîKîKîKîKîKîKîKîKîKíKìKìKïKôKñKØK¬K„K`KXKßKñKíKíKîKñKÝK¿KÚKÜK‡KƒK‰K†KƒK”K7KBKvKtKrKxKtKsKtKsKpKqKqKnKiKiKlKgK^KMK9K/K,K.K/K/K*K"KKKKKK"K#K!KKKKKK K"K!KKKKKKKKKKK"K(K2K6K5K5K4K8K:K9K;KAK@K8K-K,K-K+K,K-K*K'K&K%K&K%KKKKK +K KKKK(K0K4K8K8K7K6K9K=K;K3K(K#K"K$K KKKKKKKKKKKKKKK&K*K*K)K)K*K+K+K)K'K)K'K&K&K&K%K&K(K%K$KKKKKKKKK&KDKCKCKFK9K7K\KTKLKJKUKRK@K>K?K>KK:KKKKKKKKKK$K KK K K)K8KCKNKPKPKLKHK>K@KEKCK>K.K'K!KK K!K!K"KK#K(K,K/K.K*K)K*K-K2K4K6K9K8K9K9K9K8K8K:K7K3K*K KKK K KK#K$K%KKKKKKK +K +K KKKKKKK!K K#K%K&K'K)K(K.K0K0K3K3K2K4K8K8K`KÎKÙK×KÚKÀK|KxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KzKxKxKxKxKyKzKzK{KyKxKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK}K~KzK{K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K~KqKOKIKGKIKHKHKHKHKHKHKHKHKIKIKHKIKHKFKGKHK9KKKe]q¨(KÄKÓK·KžK¤KÆKæKôKðKéKèKíKïKíKÙK±KˆKkKcKfKiKhKgKdKdKeKeKeKdKeKeKeKdKdKeKeKeKeKdKfKgKaKWKLKEKGKGKDKFKbK’KÄKèKòKïKëKëKìKíKíKîKîKîKîKîKîKîKîKíKìKíKòKôKèK¾K•KçKðKíKîKíKðK×K¿KÜKÖK|K„K‡K‚K‹KžKrK|KvKwKxKuKtKsKsKrKqKpKpKlKkKkK_KOK8K*K+K0K.K,K(K%KKKKKK"K%K$KKKKKK K KKKKKKKKKKKK$K*K1K2K2K4K6K5K4K9K;KK=K=KAK$KKKKKKKK KKK"K.K9K@KDKDKFKIKHKHKFKHKCK1K(K"KK K"K!K"K K"K&K,K/K/K-K-K+K-K2K6K8K:K6K3K7K;KK8K-K)K&K)K-K.K)K&K$KKK#K(K'K&K'K$K&KKKKK K KKK K-K1K8K7K3K-K#KKKKKKKKKKKKKKKKKK'K/K/K+K'K(K)K)K)K(K(K(K)K(K&K#K#K$K&K'K KKKKKKKKKKK K$K(KK>K?K?K=KBK0KKKKKKKKK#K1K:K?K@K@K@K>K>K=KFKRKLKK?K;K6K5K6K8K;K:K7K7K2K(K KKKKKKKKKKKK$K%K&KKKKKKK K +K KKKKKK!K"K$K$K'K*K-K.K.K0K2K3K2K3K5K6K;K8K`KÌK×K×KÛKÅKKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KzKxKxKxKxKyKzKzKzKzKzKzKzKxKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K~K~K~K{KzKzK{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K€KK}K~K~KaKIKIKIKIKIKHKHKHKHKHKIKHKIKHKHKIKHKFKGKGK0Ke]qª(KÝKtKEKRKzK²KÑKÇKªKžK´K×KïKóKëKèKëKòKòKåKÂK—KwKgKdKgKhKgKeKdKeKeKfKfKfKfKfKfKfKfKeKeKgKgKhKhKcKWKKKEKEKEK@KDK[KŠKÁKèKôKñKìKëKìKîKîKîKîKîKîKîKîKîKîKíKìKáKêKîKæKéKïKêK¼KÆKáKÕK|K†K‚KK…KŸKvKyKwKwKvKsKpKnKkKiKlKmKcKLK4K-K/K1K/K,K(K KKKKK"K&K%K!KKKKKK KKKKKKKKKKKK!K'K-K0K.K3K4K4K3K2K4K8K;K3K,K&K$K&K)K,K,K&K KK!K'K,K.K(KK%K%K$K&K$KKKKK KKKK1K2K3K'KKKKKKKKKKKK KKKKKK!K-K2K0K-K+K*K,K*K*K*K'K&K&K'K&K#K$K%K%K#K KKKKKKKKKKK%K*K'K'K&K5KEKEKFKGKBKMK[KUKJKEKTKRK?K?K=KK@K:KKKKKKK%K,KK?K7K(K#KKKKK!K#K$K'K)K#K$K*K)K+K2K;K=K>K9K;K9K;K=K>K;K8K3K-K%KKK KKKKKKKKKKKK#K'K%K#KKKKKK K K KKKKKKK!K"K#K'K(K+K-K/K0K0K3K3K3K4K6K6K;KK>K?KKKKK#K0KBK@K;K9K8K8K9K9K6K8K3K+K"KK"K#K!KKK"K$K)K+K)K)K&K)K2K9K;K=K9KKK;K6K3K4K2K.K+K+K)K'K$K$K"KK K#K#K!K KKKKKKKKKK#K'K)K)K(K'K(K(K'K%K+KCKGKFKGKDKGKXKWKRKHKPKYKKKK?K>K>K@K-KKK"K(K2K?K;K3K1K2K6K8K8K.K%KKK!K!K!K!K#K%K(K)K(K)K)K)K,K3K;K?K>K:K3K+K:K?K;K=K9K4K(KKKKKKKKKKKKKKKKKKKKKK$K$K%K%KKKKKK K K KKKKKK K!K$K'K(K)K-K0K0K/K1K3K5K3K5K8K8K;KK;K9K;K>KAKAKCKAK8K/K!KKKKKKKKKKKKKKKKKKKKKKKKK%K&K*KKKKKKK K KKKKKKK!K$K&K)K)K,K/K0K/K1K4K6K6K7K8K8K;K;K]KÍKÛKØKÜKÎKƒKxK{KzKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K~K~K~KK~K}K}K~K€KK~K~K~K~K~K€KjKKKGKIKGKGKIKHKHKHKHKHKHKIKHKGKGKFKGKFe]q®(KgKiK_K|KÚKÒKxKaKkKiKiKcK}KÏKÑK™K°KÑKÅK©KŸK¶KÚKðKóKíKéKëKñKóKäKÁK“KqKeKfKiKjKiKiKgKfKfKfKfKfKfKfKfKfKfKfKfKfKgKhKeK]KQKEKDKDKCKBKSKzK²KàKôKòKíKìKìKðKêKßKæKïKíKíKóK¾K°KÓKâK„KlKˆKˆKtK“K‹KoKtKuKlKXK>K-K.K0K1K.K+K#KKKKK K#K$K!KKKKKKK KKKKK K"KKKKKK#K+K.K.K/K/K3K2K3K4K6K0K+K&K!K K#K$K$K%K"KKKK!K$K$K$K#K!K"K-K:K@KFKDKDKBKBKEK@K1K&K&K%K!KKKKKKKKKKKKKKKKKK-K;K@K@K=KKKKAKCKCK=K2K$KKKKKKKKKKKKKKKKKKKKKKKKKKKK*K+K,K%KKKKKK K K KKKKKK!K$K$K(K)K*K-K0K3K3K4K4K4K7K8K8K:K=KK=KK8K-K&K"K#K$K%K$K#K%K!K!KKKKKKKKKKK'K,K.K+K)K)K)K(K(K)K,K-K'K"KKKKK%KEKFKGKGKAK?KYKVKOKGKPKTKEK@KBKAK@KBKDK/KKK!K%K%K"KKKKKKKK!K%K(K(K&K(K)K,K1K8K?K=K>K=K@KBKBKCKCK>K:K*KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK$K,K*K*KKKKKKK K KKKKKK!K#K$K'K(K*K,K/K1K3K5K4K5K8K8K8K9K=K;K\KÍKÚK×KÜKÑK…KxKyKyKyKxKxKxKxKxKxKxKxKxKxKxKxKxKyKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K|K|K|K|K{K{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K~K}K}K~K~K}K}K}K~KKK~K}K}K}K~K~KKKKKKKK~K€KzKZKJKHKIKHKGKFKGKHKHKIKIKHKHKGKGKGKGe]q°(KbKiKfKiKcKeK³KêKKcKgKgKhKdKdK±KëK˜KMKHKdK˜KÆKÎK´KžK©KÍKçKôKòKëKìKðKôKëKÑK§K~KhKfKgKjKiKfKfKfKfKfKfKfKfKfKfKfKfKfKfKfKhKiKeK^KRKIKCKCKDKBKMKtK«KÜKóKíKòKîKïKïKîKîK®K¹K×K×KoKxKK~K|K•KuKQK7K1K0K/K/K.K%KKKKKKKKKKKKKKKKKKKKKKKKKKKK%K,K.K*K-K0K.K1K3K4K5K.K&K KK K"K$K$K$K"KKKK!K$K$K$K#K"K&K/K=KEK@K:K:K>K@KDKHKKKHKKK>K?KK?KCK7KKKKKKKKKKK!K#K$K&K&K(K'K(K/K7K;KBK@K>K@KCKEKHKIKEKAK/KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK+K,K+K%KKKKKK K K KKKKK!K!K$K%K&K+K*K-K0K3K5K4K7K9K7K8K7K:K@K?K—KÞKÙKØKÞK°KwK{K{KyKxKxKxKxKxKxKxKxKxKxKxKxKxKzK{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K~K~K~K~K~K{KzK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KK€K}K~K€KK}K}K}K}K}K}K}K}K}K}KK€KKKKKKKK€KK~KuKQKHKIKFKFKFKFKFKHKHKFKFKFKHKIKIKHe]q±(KKbKfKhKhKeK_KšKéK°KgKfKhKhKgK^K˜KëK¸KiKXKKKGKkK¨KÏKÉKªK KµKÔKîKôKíKéKìKóKõKèKÅKšKwKgKfKhKjKiKiKhKgKgKgKgKfKfKfKfKfKfKgKgKgKhKhKdKYKMKGKDKDKCKBK[KK§KµKíKëKëKïKêK§KÀKÛKÒKiKyK~K|K_KMKKDKEK?K:K9K=KCKGKCK8K1K.K.K0K/K*K%K&K(K"KKKK K K KKKK0K8KK?K>K>K=KAK;K)K"K"K#K#K#K$K"K!KKKKKKKKKKK$K+K,K-K,K.K-K,K+K+K-K.K)K%KKKKKKKKKKK;KHKFKFKIK,KJK\KSKIKJKYKQK@KBKAKAK?KCK?K%KKKKKKKKK K#K%K$K$K&K,K3K9KK;K@KCK?K4K+K-K0K0K1K.K&K!K%K&K&K$KKKKK K KKKK-K5K6K:KK—KÞKÙKÛKÞK±KxK{K{K{K{KzKxKxKxKxKxKxKxKxKxKxKzKzKzKzKxKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|K~K{KzKzK{K}K}K}K}K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K€K€K€K€K€KKKKKKKKKKKK€KfKIKFKHKIKGKFKFKFKGKGKIKHKHKHKIe]q³(KKáKÉKpKbKhKgKiK^KuKÓKÙK~K`KjKjKlK`KtKÒKÚK}KbKlKjKbKYK„K×KßKÇKÍK½K¥K§KÄKæKóKóKîKìKðKõKïKÖK­K…KlKdKgKkKhKhKgKiKiKgKfKfKfKfKfKfKfKgKhKhKhKiKeK[KNKGKDKJK?KcKéKåKòKÜK KÈKæK¼K_KzKtKWKKKK"KKKKK K KKKKKKKKKKKKKKKKKKKKKK K'K,K1K3K3K1K0K-K0K3K2K)K!KKKK K"K KKKKKK"K!K!K KK"K*K0K5K9K9K9K:K=K=K=K@K@K;K3K.K.K0K1K1K.K'K$K#K#K'K&K&K&K#KKKKK K KKK$K7K8K9KKAK?KDKFK?K/KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK+K.K/K)KKKKKKKK KKKKKK"K&K&K)K*K.K/K1K3K3K4K7K8K9K:K8KK[KÍKÚKÜKÝK×K‹KvK{K{KyKxKxKyKzKyKxKzKzKxKyKzKzKzKzKzKzKzKzKzKzKzKzKxKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K}K}K}K}K}K}K|KzK|K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KK~K}K}K}KKK}K~KKKKKKKKKK€K€K€KKKKKKKKKKKKK}K^KFKGKGKGKFKGKGKFKGKGKGKGKGKGe]q´(K[KoKÐKÜK€K`KhKgKiKaKiKÀKäKKbKjKjKjKdKiK¾KäK‘KaKhKkKkKaKKÔKÇKK›KËKÐK·K¢KªKÍKìKöKñKêKìKóKöKéKËK K|KgKeKjKlKkKiKfKfKgKgKfKgKgKfKgKiKhKfKfKgKiKiKbKUKHK7KŽKùKïKøKÖK–KÁKáK®K]K{KyK]K%KKKKKKKKKKKKKKKKKKKKKKKKKKKKKK"K.K/K+K0K1K2K3K4K3K.K'K#KK K!KKK!K KKKKK KKK K K#K(K4K6K6K5K7K8K9K;K>K@K@K6K/K,K/K0K0K0K-K$KK!K'K.K.K-K(K%K%K&K!KKKKK KKKK7K?K8K-K!KKKKK KKKKKKKKKKKK K+K1K1K.K)K,K-K,K)K.K2K-K%KKKKKKKKKKKKKKKKKKK-KFKGKFKGKDK.KTKXKPKHKKK[KOKEKDKBKAKAKHK?K)KKKKKKK$K+K.K5K6K8K;K?K?KAKCK=K5K&KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK%K/K.K0K KKKKKKK KKKKKK"K%K&K)K)K-K.K0K3K3K4K7K8K9K:K9K;K=K@K?K–KßKÚKÛKáK·KxK{K{KyKyKyKyKzKyKyKzKzKyKyK{KzKzKzKzKzKzKzKzKzKzKzKyKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K{KzKzK{K|K~K}K}K}K}K~K}KzK|K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KK~K}K~K~KKK~K~K€KKKKKKKKK€K€K€KKKKKKKKKKK€KK€KzKVKHKFKFKGKFKFKFKFKFKFKFKFKGe]qµ(KiK`KeK¾KåK“KbKfKgKhKeKbK§KêK§KeKeKhKhKgK`K¥KëK¥KdKeKjKlKcKqKËKÚKrKOKyKªKÏKÌK±K¢K³K×KïKôKïKëKíKôKóKåKÀK–KtKeKhKiKiKiKjKiKhKjKjKgKfKfKfKfKiKiKiKiKkKlKgK\KªKøKðKúKÎK’K»KÜK“K\KzKwKYK'KKKKKKKKKKKKKKKK K KKKKKKKKKKKK#K)K-K-K,K0K2K3K2K,K%K!K K"K$K"K!KKKKKKK K K KKK%K0K4K6K5K4K6K8K5K8KKCK@K4K&KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK+K/K1K)KKKKKKK K KKKK K!K$K(K)K(K+K.K1K3K3K5K4K7K:K:K9K9K;K?KK;K8K5K5K2K0K,K-K/K)KKKKKKKKKKKKKKKKKKK)K1K2K0K/K.KK_KTKNKFKRKVKEKBKDKDKEKFKLK1K#KKKK!K%K(K.K5K5K;K?K6K)KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK KKKKKKKKKKKKKK(K1K/K/K KKKKKKK KKKKK!K#K'K)K)K+K,K0K3K3K4K5K7K9K:KKBK@K“KÞKÚKÜKàK¶KyK{KzKzKzKzKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K{K|K~K{KzK|K}K}K}K|K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K~K~K~KKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€KKKKKKnKMKGKFKGKGKFKGKFKGKGKGKEe]q·(KhKgKgKgK\K’KèK¾KlKcKhKgKiK]K{KÜKÐKtKcKhKgKiK^K|KÜKÐKvKbKkKkKhKbKKìK³KkKaKSKDK[K”KÅKÈK­K£KªKÇKèKöKòKìKëKïKõKíKÑK§K~KkKgKiKjKkKjKhKjKjKjKiKiKiKiKiKiKlKnKÈKùKïKøKµK—KÅKáKªKqKwKyKSK+K&KKKKKKKKKKK K KK KKKKKKKKKKK K)K,K*K,K0K-K(K$K"K#K#K$K$K#K"K KKKKKKKKKKK#K-K5K7K5K5K5K4K4K8K:K6K/K)K*K*K)K+K,K)K'K%K%K+K1K1K2K/K-K/K3K=KIKOKOKNK;K$K$K&K#KKKKKKKKKKKKKKKK KK KKK)K6K@KAK@K?K;K;K9K6K4K5K-K"KKKKKKKKKKKKKKKKKK"K,K3K4K1K/K/K0K/K8KEKEKFKIK=K4K]KXKQKHKNKWKKKCKDKDKBKJKMKKCK@K>K?K=K=K>K;K:K5K)KKKKKKKKKKKKKKKKKKK(K0K2K4K5K3K2K1K/K0K3K8KEKHKFKGKFK/KXKZKQKIKJKVKNKEKFKDKZKŠK\KBK+K&KKKK&K+K)K KKKKKKKKKKKKKKKKKKKKKK"K&K,K)KKKKKKK K K K K K K KK K"K K K!K K K K KKKKKKKKKKK,K1K1K1KKKKKKKKKKKKK"K%K(K*K+K+K.K3K3K4K6K9K:K:K:KK=K?K?K>K=KK>K?K@KK@KCKAK‘KÞKÛKÝKãK¾KzK{K{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KK~K}K}K~K€KK}KKKKKKKKKKKKKKKKKKKKKK€K€K€K€KKKKKKKKK€KK€KrKOKFKGKGKFKGKGKFKFe]q»(KtKÒKÛKƒK`KhKgKjKgK_KŸKìK²KhKgKjKgKhK`KˆKâKÆKpKfKiKgKjK_KˆKåKÅKpKdKkKlKeKbK¨KéK£KdKiKkKlKcKzK×KÒKiKLKdKKÂKÒKÀK©K¬KÍKëKõKñKìKìKóKøKìKÍK¡K}KkKhKlKmKnKnK˜KóKóKòKòKÁKªKÎKáK™KpKuKpKKDKDKDKFKIKJKMKOKOKIK?K4K,K)K)K'K&K&K%K&K KKKK K KKKK"KK9K4K-KKKKKKKKKKKKKKKKKK#K-K4K5K5K2K4K4K4K5K7K7K3K(KKKKKKK*KIKFKFKIK?K5K^KYKQKHKPKXKxKÀKÍKÍKÒK¹KYKFK,K*K'KKKK KKKKKKKKKKKKKKK!K#K)K,K)K*K5KIKaKpKwKxKvKAKK#K KKK!K!K!K!K!K!K!K!K!K!K!K!K!K!K!K!K!K!K!K!K!K!K KKKKK*K4K2K5K%KKKKKKKKKKK K"K%K(K+K+K.K/K1K4K7K9K8K8K9K:K=K=K>K@KBKAK[KÉKÞKÞKàKÛK’KxK{K{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K{KzK{K{K{K{KzK|K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K€K~K}K~K~K€KK}KK€KKKKKKKKKKKKKKKKKKKK€K€K€K€KKKKKKKKKKKKƒKmKJKGKGKFKGKFKFKFe]q¼(K`KfK¾KèK–KbKhKgKgKgK]KŠKåKÇKpKdKlKjKkK]KuKÕKØK|KcKiKiKlK_KwKÕKØK}KcKlKkKjK_K”KèKºKlKfKkKlKcKlKÄKçKKZKRKKKfKžKÌKÐK±K¤K·KÔKîK÷KóKîKðKöKõKäKÁK—KwKjKkKpK¥K÷KñKôKêK¨K°KÓKàK…KoKtKjK9K1K KKKKK!KKKKKKKKKK K KKKKKKKKKKKK!KKKKKK#K$K$K$K"KKK$K+K0K,K'K*K*K)K)K)K*K+K&K!K$K$K'K'K$K$K"K"K"K&K(K*K)K(K'K*K1KK?K>K;K/K$KKKKKKKKKKKKKKKKKK'K0K4K4K4K5K2K1K5K7K9K7K/K KKKKKKKKK)KEKGKFKGKEK/KUKZKSKKKLKWKyKÏKÎKÏKÏKÌKoKIK6K*K,KKKKKKKKKKKKKKKKK$K(K,K)K&K.K?KUKkKsKuKtKrKrKtK[K#K!K KKK K!K K K K K K K!K!K!K K#K$K K!K$K"K K!K!K K K!K KKK#K2K3K3K.KKKKKKKKKKKK!K%K&K(K+K*K.K1K1K5K8K:K9K8K;K=K=K>K=K?KFKCK‘KáKÛKÝKäK·KxK{K{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K~K|KzK}K}K~K|KzKzKzK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K€K~K}KKKKKKKKKKKKKKKKKKKKKKKK€K€K€K€K€K€K€KKKKKKKKKKKKK~KaKFKFKGKFKGKFKFe]q½(KkKeK`K§KëK«KeKeKiKhKkK_KvK×KÛKKbKjKjKkKcKjKÂKäKKcKkKiKlKdKiKÁKäKŽKaKkKjKlK`KKÞKÍKvKeKlKkKhKbK­KêK¡KiKmK_KHKUK…KÀKÚKÄK±K¨K»KßKõK÷KñKîKòK÷KôKÛKºKKwK°KûKñKûKÕKŽKºKÖKØK{KoKtK_K4K2KKKKKK K KK KKKKKKKK KKKKKKKKKKKKKKKK!K"K$K"K"K KK'K,K0K0K-K)K'K*K*K(K&K%K#K$K#K#K!K!K#K"K K"K$K'K'K)K)K&K'K+K-K7KAKBKBKBKBKDKFKFKCKK=K?KKHKGKGKIK1KIK_KWKPKJKVKeKÁKÒKÏKÏKÐK«KªK‚K(K.K'KKKKKKKKKKKKK"K'K+K)K%K)K5KNKeKsKvKtKsKqKsKsKsKrKnK0K!K$K#KK K"K"K"K"K"K"K"K!K K"K"K#K$K"K"K$K#K"K!K K"K"K!K KK!KK,K6K3K5K$KKKKKKKKKKKK%K'K(K+K,K/K0K1K4K6K9K:K9K;KK@K>K?KDKBKYKÇKÝKÝKßK×KKxK{K{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K~K|K{K}K}K}K}K{K{KzK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K~K~KK€K~K~KKKKKKKKKKKKKKKKKKKKKKKK€K€K€K€K€K€K€KKKKKKKKKKK€KK€K{KYKEKFKGKFKFKFe]q¾(KjKiKgK^KŽKçKÂKnKdKlKiKlKaKiKÃKæKKbKiKiKkKdKbKªKìK¦KcKhKjKlKgKaK«KêK£KeKjKkKkKaKpKÊKÜKƒKbKjKkKiK_K™KêKµKjKlKqKhK]KsKËKèKÌKÎKÉK­K©KÆKãKòKóKïKñKóKìKôKœKºKýKóKýKÆK‘K¿K×KÅKpKpKrKRK3K3KKKKKKKKKK KKKKKKKKKKKKKKKKKKKKKKKKKKKKK(K/K.K-K-K,K)K(K)K&K#K#K!K!K$K$K!KKKK!K"K&K&K&K&K#K$K(K/K4K6KGKOKCK>K@KCKCK@K;K1K.K/K.K1K/K)KK K K%K.K-K%K%K%K&K%K!KKKK K KKK,K=KKHKIKHKJK7K>K`KXKRKIKVKZK¬KÖKÎKÐKÍKÜKúKÕK:K)K,KKKKKKKKKK K$K(K*K&K&K.KEK`KpKvKsKpKsKsKtKtKsKsKsKsKwKGKK%K#KKK#K$K$K$K$K$K$K"K K#K$K$K$K$K$K$K$K$K#K#K$K#K K!K!KKK'K4K4K8K-KKKKKKKKKKKK"K'K)K(K,K-K-K1K4K4K9K:K:K:K=K=K?K?K?KAKCKCKKàKÜKÞKäK¼KzK|KzKyK{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K}K~K~K~K~K}K}K~K|KzK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KK€KKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€K€K€K€K€KKKKKKKKKKKK€KKKwKSKFKGKGKGKFe]q¿(KjKiKjKjK\K{KÚKÕK{KcKlKiKlKfK`K¬KëK¦KcKgKiKjKiK_K•KêKºKlKfKkKkKgK^K”KçK¹KkKfKjKkKfKeK¶KçK™KdKjKlKmKaK„KáKÍKtKfKmKpKgKmKÀKÒKK’KÇKÓKµKµKÇKáKïKïKéKâKðK•KÉKúKòKýK¹K”KÁK×K·KjKqKqKJK2K0KKK KKKKK K!K KKKKKKKKKKKKKKKK KKKKKKKKK!K!KK$K(K*K-K-K-K-K&K#K$K#K K"K KK K KKK K!K#K&K%K%K#K#K'K1K5K4K3K:KHKFK@K>K?K=K3K.K.K0K0K.K+K%KKK"K+K0K-K.K)K$K-K(K#K$K#KKKKKKKK$K*K#KKKKKKKKKKKKKKKKK(K1KKDKGKHKIKHK=K5K^KYKRKIKSKWKKÖKÎKÐKÎK×KöKõKdK%K.K%KKKKKKK%K(K)K*K'K+K=KUKhKtKwKtKrKrKrKsKsKsKsKsKsKsKsKwKaK$K#K#K"KK#K$K$K$K$K$K$K#K"K#K$K$K$K"K"K$K$K$K$K%K$K#K#K"K!KKK#K1K5K6K4K"KKKKKKKKKKK K$K'K(K*K+K-K1K4K4K8K:K:K:KK?K?K?K>KAKEKXKÈKÞKÜKßKÝK—KyK}K{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K|K}K~K|K{K{K|K}K}K}K}K|K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KK~K}K~KK~K}KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€K€KKKKK€K€KKKKK€K€KKK‚KrKLKGKFKFKGe]qÀ(KgKhKjKjKmK_KnKÉKäKKbKjKjKkKgK[K–KêKºKkKfKkKjKlK`K€KßKÏKvKdKkKkKlK^K€KàKÍKsKdKkKlKgK`KŸKêK¯KkKjKnKqKeKtKÏKÙKƒKfKhKmKoK{KÐKáK©KÈKòKþKòKÖKÒKðKíKéKæKéK‘KØKøKóKûK«K˜KÄKÙK¬KiKpKnKFK6K0KKK +K +K KKKK K KKKKKKKKKKKKK +K +K K KKKKKKKK#K*K&KK$K#K'K*K,K%K!K K$K#KKK!KKKKKK K"K!K K!K!K%K*K/K3K4K5K5K7K=KAK@K=K7K-K)K-K1K4K5K0K'K#K!K%K-K0K3K.K'K+K5K@KNKEK$K#K$K KKKKKKKKKKKKKKKKKKK KKKKK-K>KKKDK;K8K;KKAKHKHKIKGKEK/KUK\KTKMKMKXKvKÏKÐKÐKÏKÒKïKÿK˜K(K.K+KKKK#K&K*K+K(K(K8KLKaKrKxKrKqKsKsKsKsKtKsKsKsKsKsKsKsKsKsKtK4KK'K'K!K!K$K$K$K$K$K$K$K$K$K$K$K$K$K$K$K$K$K$K#K$K$K$K"K K!K!K K+K6K5K8K,KKKKKKKKKKK K#K&K)K,K,K/K1K5K4K7K;K7K6K;K?K?K?K?K@KDKFKBKŒKßKÜKÝKãKÅK}K~K|KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K}K}K~K|KzKzKzK}K}K}K}K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KKK}K~K€K~K}KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€K€KKKK€K€K€K€KKKKK€K€K€K€K€KhKKKIKFKGe]qÁ(K¿KnKgKkKjKkKeKcK´KìK¡KcKjKiKiKlK_K‚KÞKÏKvKbKkKjKlKcKpKËKàK†KdKlKkKlKcKnKÌKßK„KcKkKlKmKaK‹KäKÄKrKeKeKkKhKrKÉKßK¨K¸KÍKáKíKðKöKõKëKÍK°KÓKÚKÖK÷KïKèKçKàK’KäKöKôK÷K KKÆKÌKKdKqKjKBK7K/KKK K KKKKKK#K K"K KKKKKKKK K K K K K KKKKKKKKK#K$KK K K"K&K&K!K"K$K$K#K K KKKKK"K"K"KKK K#K(K0K3K5K5K4K4K6K;K>K:K3K,K)K+K1K4K2K.K&K"K$K)K/K/K.K*K-K,K8KMKUKKKGKNK6K K$K%KKKKKKKKKKKKKKKK K"KKKK&K6KBKNKNKIKFKK>KFKIKHKHKJK5KLK^KWKOKJKZKbK¼KÓKÎKÐKÍKèKÿKÉK5K0K/K'K%K*K+K)K'K.KCKZKnKvKsKrKrKpKqKtKsKsKsKsKsKsKsKsKsKsKsKtKrKvKMK!K'K&K"KK#K&K%K%K%K%K%K%K%K%K%K%K%K$K#K$K%K%K%K%K%K#K#K#K!K K K#K2K6K9K3K KKKKKKKKKKK#K&K)K+K,K/K.K4K5K7K8K8K9KK?K?K?KAKCKEKEKYKÇKàKÝKÞKàKœKxK|K}K{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|K}K}K}K{K{K{KzKzKzKzK{K{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€K€KKKK€K€K€K€KKKK€K€K€K€KK€KK`KKKGKIe]qÂ(KßKÓKzKcKkKjKkKhK^KœKêKµKiKeKkKhKlKaKmKÍKßKƒKaKkKiKkKdKeK¸KëK™KcKjKkKmKeKcK¹KêK˜KgKhKgKiK^KxKØKÏK“K¡K¹KÍKÝKæKöKõKòKèKÛKÊK·K›KŒKÒKÅKmKÍKÛKÙKøKñKçKîKÓK•KîKôKöKòK™K K°K†KVKeKmKfK>K7K*KKK K KKKKK"K K K!K"KKKKKKKKK K +K +K K KKKKK K"K#K K!K%K KKK#K&K&K"K#K$K$K"K KKK K K!K"K KKKK&K+K/K4K6K4K4K5K6K7K4K*K#K!K#K)K0K0K(K"K K%K,K0K0K/K-K,K3K?KEKNKYKVKHKK=K/K KKKKKKKK!K$K"K!K"K&K.K7K=K>K>K;KK>K@KBKEKHKHKIKIKJKOK_K[KSKMKXKZK¢K×KÏKÐKÎKàKúKîKTK(K3K.K.K)K-K;KTKjKsKuKrKpKpKsKsKqKrKsKsKsKsKsKsKsKsKsKsKsKsKtKsKtKgK,K%K%K#KK#K&K&K&K&K&K&K&K&K&K&K&K'K&K$K%K&K&K&K&K%K$K$K$K"K!K!K K-K8K7K8K*KKKKKKKKKKK K&K(K+K,K/K.K3K4K6K8K9K:K=K=K>K?K?KAKAKAKGKDKŒKàKÝKÝKãKÉK}K|K~K{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|K~K}K}K{K{K{K{K{K{K{K{K{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K~K~KK€KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€K€KKKKK€K€K€KKKK€K€K€K€K€KKK}KZKHKGe]qÃ(KrKÏKàKŠKcKjKjKkKjKZK‡KãKÊKvKfKlKhKkK`KbK¹KëKšKdKhKiKkKiK`K¢KîK±KlKgKhKiKdK[K›KäK¬KK•K¥K·KÄKÝKöKðKñKðKíKÞKÊK±KKÖKÉKvKfKhKhKaKxKÕK×KäKÒKáKõKòKéKòKÅKšKôKñK÷KëKK“K}KXKNKhKlKaK:K5K)KKK K KKKKKKKK K!K"KKKKKKKKK +K +K KKKKKK#K%K%K&K%K$K#K!K"K(K'K$K$K#K"K KKK!K"K KKKKKK"K$K'K,K/K2K4K3K5K3K.K'K KK KKK K$K KK$K*K0K0K0K.K.K6KEKPKUKSKPKSKTKVKOKMKIK/K"K$K$K#KKKKK K K KKKKKKK-K:KIKPKOKKKJKFKAKJKMKEK5K%KKKKKKKKK K K"K!K"K*K/K7KAK>K?KBK@K?K?K@K@K@K8K'K/KJKHKIKHKMKNK_K\KTKNKVKXKˆKÓKÎKÐKÎKÖKóKýKƒK&K1K0K8KNKdKrKwKuKsKrKpKrKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsK:K"K'K)K$K#K%K%K%K%K%K'K%K&K(K&K%K&K&K%K&K&K%K%K%K%K&K%K#K$K#K$K#K)K8K8K8K2KKKKKKKKKKKK$K&K)K,K/K0K/K2K5K9K9K:K=K=KK?KAKAK@KEKFKWKÇKáKßKâKâKœKzKK{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|K~K{K{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K€KKKKK}K~KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€KKKKKKKKKKKKKKKKKK€KƒKK~K‚KxKPKFe]qÄ(KeKgK·KìK KdKiKkKjKlK^KsKÖKÞK‚KeKlKjKkKiK\K¡KíK°KkKhKjKjKkK[KˆKÞK¿KwKwK†K•K¨K²KÝKóKçKïK÷K÷KíKÜKÄK´KàKÁK{KpKlKfK^K~KÚKÔK{KhKoKpKgKnK·KèKËKåKòKñKéKôK·K¢KùKòKùKâKKpK[KOKPKeKiK\K8K5K(KKKKKKKKKKKKK K!K!KKKKKKKKK +K K KKKKK%K)K(K%K"K#K%K(K)K(K#K!K!KKK!K%K#K!K KKKK!K'K(K(K'K'K+K0K3K2K/K*K%K!KK K K"KKKK K&K,K+K-K-K-K3KK3K/K+K(K$K"K%KKKKK K +K KKKKK-K@KMKQKQKLKIKIKLKIKHK>K1K KKKKKKKKK!K!K"K#K'K-K6K;K>K?K@KAKAKAK=K?K@K;K.KKKK%KGKIKIKHKIKLKYK]KUKOKSKWKmKÈKÑKÏKÏKÑKïKÿK¸K4KIK_KnKwKuKsKsKsKsKsKqKrKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKrKwKTK"K'K+K(K!K'K'K'K'K%K'K'K%K"K&K'K&K&K'K&K&K&K'K'K&K&K%K$K$K%K#K"K!K1K9K7K8K(KKKKKKKKKKK$K&K(K+K-K/K/K2K5K8K9K:K=K=KK?KAKBKAKEKJKFKŒKáKßKàKåKÉK€K}K|KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|K~K{K{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K~K}K}K}K}K}K}K~KKKKKK~K~KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€KKKKKKKKKKKKKKK€KKKKKKK€K‚KpKMe]qÅ(KkKgK`K¢KêK¶KkKfKkKiKmKeKiK¿KèK–KcKiKkKkKkKZK…KÞKÃKtKfKoKxKˆKK¸KïKÚKÜKíKõK÷KóKäKÐKÍKäK¯K†KKuKlK^K‘KäK·KlKjKnKoKdKnKËKãK‡KfKoKqKgKƒKìKÉKëKïKðKéKôK§K¬KøKëKéK»KjK^KWKOKOKcKhKXK6K6K&KKKKKKKKKKKKKK"K!K KKKKKKKKK K KKKKK$K'K#K#K#K'K&K&K%KKKK!K!K!K$K$K!KKKK#K)K+K)K)K(K)K)K'K*K+K(K#K K K!K!KKKKK#K&K*K,K-K+K-K1K=KGKMKNKOKKKNKSKUKSKIK:K0K/K,K-K*K%K#K$K#K"KKKKK K +K KK"KCKGKMKLKKKJKLKMKIKBK4K(KKKKKKKKKKK K"K$K*K1K8KK?KAKBKAKBKGKIKWKÄKáKßKäKåK¤K{K|KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|K~K{KzK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K€KK}K}K}K}K}K}K}K}K~K€KKKKKKKK~K}KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€KKKKKKKKKKKKKKK‚KƒKƒK‚KKKKKKKge]qÆ(KkKkKiK_KKåKÉKtKeKlKjKnKiK`KªKëKªKiKdKeKiKrKkK•KéKÏK¹KÒKãKîK÷KóKéKÝKæKÔK¬KœK‰K|KnKlK¾KÝK‰KaKlKmKmK`K€KãKÎKtKfKlKnKhKeK³KêKKgKqKkK›KïKÇKïKîKïKêKóK™K“K¯K‘K~KaK^KZKSKLKQKfKgKTK6K5K!KKKKKKKKKKKKKKK!KK"KKKKKKKK K +KKKKKKK!K%K&K'K%KKKK!K%K$K"K!K!KKKK#K&K+K)K(K*K*K*K(K&K$K#K"K#K!KKKKKK!K#K%K)K(K&K)K/K4K;KCKEKGKLKLKMKLKQKQKCK5K.K-K-K1K.K'K!KKK$K"K#K"KKKKK KKK KCKGKLKJKIKLKHK=K/K!KKKKKKKK K!K"K K K$K+K5K9K;K>KK=KDKHKIKIKFK>K3K.K.K1K2K.K'K!KKK K'K&K"K#K$KKKKKKKKK6KIKKKHKDK7K(KKKKKKKKK!K!K K#K$K)K/K5K;K=KKAK>KK?KAKBKBKDKEKGKGKYKÈKäKâKãKäK¢KyKK~K|KzKzKzKzKzKzKzKzKzKzKzKzKzK{K~K}K}K~K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K€KKKKKKKKKKK€KKKKKKKKKK€K€K€KKKKKKKK€K€K€K€K€K€K€KKKKKKKKKƒK€KKKKƒKƒKƒK€KKKKƒKKK‚KƒKƒKƒKƒKƒKƒK€K€e]qÈ(KfKlKlKjKjK_KhK¾KàK™KKK¡KµKÆKÐKéKòKêKíKêKäKÒKÀK¬KK£KãK¨KdKfKhKiKhKaKšKìK»KoKjKmKmKkK\K›KðK¸KkKiKmKmKeKfKºKêK—KeKlKmKmKbK‰KæKÉKnK¾KæKÍKóKðKëKíKèK‰KZKUKVKPKBKWKTKQKGKTKdKdKIK6K7KKKKKKKKKKKKKKKK+K'KK"K KKKKKKKKKKKKKKKKKKK$K&K'K%K!KKKK"KKK K!K'K(K(K$K$K!K K!K KKKKKKK$K%K'K'KK K'K(K-K8K;K;K9KK?K=K>K>KAKBK?K8K(KKKKKKKKKKKKKKK)KHKIKHKFKJKBKTK\KWKPKTK[KhKÄKÓKÏKÑKÐKêKýKÑKuKvKuKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKuKtKsKtKtKsKsKsKsKuKlK2K(K*K+K&K'K+K+K)K)K)K*K+K+K*K*K*K*K*K*K)K)K)K)K)K)K)K)K'K%K&K&K#K*K9K9K9K8K#KKKKKKKKKKK$K(K+K-K1K3K3K3K7K8K;K:K;K?K?K@KCKBKBKDKDKHKGKŽKäKßKàKçKÑK€K{K~K|KzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K|K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KK~K}KKKKKK~K~KKKKKKKKKKKKKKKKK€K€K€KKKKKKKK€K€K€K€K€K€K€KKKKKKKKKƒKK€K‚K‚KƒK‚K‚K€KKKKƒK‚K‚KƒKƒKƒKƒKƒKƒKƒK€Ke]qÉ(K¦KlKoKxK†K˜K¡K¶KèKéKàKëKõKõKíKáKÎK´K¼KãK§KsKoKkKgKaK]K™KìK¼KlKiKlKlKiK_K†KßKÎKvKgKmKjKkK`K‡KæKÍKrKfKlKkKiKaK£KðK®KgKiKmKnKdKwK×KÕKØKÚK×KôKòKéKñKàKKYKQKQKHK@KXKSKPKFKUKcKbKGK9K2KKKKK KKKKKKKKK#K/K;K=K&KK K KKKKKKKKKKKKK KKKKKK%K#K!K!K$K'K'K&K"KKK"K#K$K!KKKKK K#KKKKK K$K%K&K&K&K"K#K)K1K6K8K9K:K:KK6K1K-K/K0K0K-K)K%K KK$K)K.K.K.K*K)K/K:K(K!K#K!KKKKKKKK#KKKKKKKKKKKK K"K&K+K7K=KAK@K@K?KK@KCKAKBKDKDKHKLKYKÆKãKßKäKéK¢KyKK|KzKzKzK{K{K{K{KzKzKzKzKzK{K{KzK|K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KK~K~KKKKKK~K~KKKKKKKKKKKKKKKKK€K€K€KKKKKKKK€K€K€K€K€K€K€KKKKKKKKK‚K€K€K‚K‚KƒK‚K‚K€KK€KKƒKƒKƒKƒKƒKƒK‚K‚K‚KƒK€K€e]qÊ(KêKÇKÉKÞKìKóKöKòKäKÐKÖKßK¬KŽK†KwKlKdKfKµKèKžKeKjKnKmKlK\K€KâKÏKyKfKkKjKlK_KsKÓKàK…KdKmKlKnKbKwKØKÞKKcKmKlKjKbKKêKÄKpKhKmKmKgKlK¸KæKÐKßKöKóKçKñKÔKxKVKPKPKEKBKYKRKNKGKXKaK^KCK7K0KKKKK KKKKKKKKK)K5K?KIKAK&K!K!K KKKKKKKKK K +K KKKKKK K#K,K0K.K*K)K)K&K&K&K$K!KKKKKK K KKKKK K#K$K$K#K"K"K$K%K&K'K.K5K9K:KK!K$K$K KKKKKKKKKKKKKKKKK K$K+K1K6K:KDKEKDKBK>K>K?K9K2K#KKKKKKKKKKKKKKKKKKKK#K=KJKHKHKKK:K:K`KYKRKHKQKWK“KÖKÎKÐKÎKÖKöKûK¤KnKuKvKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKuKuKvKtKrKwK[K,K-K*K+K&K*K+K+K+K+K+K*K+K&K(K)K+K+K+K*K*K+K+K+K*K(K)K)K)K(K%K%K#K*K8K:K:K6K KKKKKKKKKK K$K'K*K.K0K2K3K3K6K:K;K=K>K?KAKAK@KDKDKDKGKLKFKŽKæKáKâKçKÎKK}K}KzKzKzK}K}K~K|KzKzKzKzK{K}K|KzKzKzK}K}K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€KKKKKKKK€K€K€K€K€K€K€KKK‚K‚KKKƒKƒKƒK€K€KƒKƒKƒK‚K‚K‚K‚KƒKKKKƒKƒK‚e]qË(KåKèKèKÙKÆK·K¡K‘K‚KlK|K×KÍKxKbKjKjKlKhK^K¢KïK·KiKiKmKlKkK]KpKÓKáK„KcKlKkKkKeKiK¿KìK–KdKkKlKnKfKhKÀKêK“KcKkKkKmKaKzKÜK×KzKfKmKoKhKvKèKÍKåKôKóKåKîKÈKqKSKQKPKKKKKVKRKMKKK]K`K\K=K7K0KKKKKKKKKKKKK'K1K;KGKKKJK.K K!K!KKKKKKKKKKK KKKKKKK2KAK:K0K)K(K*K%K$K%K"KKKKKKKKKKK!K"K K"K#K"K#K%K%K$K%K&K'K+K0K6K8K3K,K)K,K-K.K/K1K)K KK$K*K.K0K-K-K-K3K=KGKPKPKMKMKJK,K"K#K#KKKKK K KKKKKKKKK"K'K,K4K:K?KCKEKDKDKDKCK?K4K'KKKKKKKKKKKKKKKKKKK K!K$K'K'K3KJKHKHKJKDK0KZKZKSKMKKKZKxKÑKÑKÑKÑKÐKîKKÉKsKvKvKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKtKtKtKsKsKuKuKuKtKsKtKoK9K)K,K+K(K(K+K,K+K*K+K,K+K(K)K*K+K*K)K+K,K+K+K+K*K)K)K)K)K(K'K$K!K$K5K:K:KK4K*K&K!K#K#KKKKKKKKKK!K,K4K7K=KEKCKDKFKGKGKBK7K'KKKKKKKKKKKKKKKKKKK K"K#K&K'K&K*K:KRKhKqKQKGKIKHKKK3KDKbKZKSKJKVK\K¥K×KÏKÑKÏKÝKùKöK–KqKwKuKuKuKtKsKsKsKsKsKsKsKsKtKuKtKsKsKsKtKuKuKuKuKuKtKuKuKuKuKuKtKwKbK,K-K.K*K%K*K.K.K.K0K,K+K-K,K,K,K-K.K+K*K+K+K+K+K+K*K*K*K*K)K(K)K'K'K8K:K;K=K'KKKKKKKKKK K#K%K)K.K/K1K2K5K9K;K;KK2K*K'K%KKK%K!K!KKKKKKKKK(K1K=KCKEKCKAKBKCKK:KaK[KSKJKRKWK‡KÕKÎKÐKÐKÕKóKÿK³KpKwKvKuKvKuKsKsKsKsKsKsKsKsKtKvKtKsKsKtKuKvKuKuKuKuKvKuKuKvKuKuKuKuKrK:K+K-K+K'K(K.K-K-K/K-K-K.K.K.K.K.K.K+K*K+K+K+K+K+K+K+K+K*K)K)K)K'K$K2KK>KBKBKDKCKDKDKBKKKHKKäKáKæKêKÕK†K|K}K~K}K}KzKzKzKzKzK}K}KzK{K~K~K~K}K}K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K€K~K}K}K}K}K~K€KKKKKKK€KKKKKKKKKKKK€K€K€K€K€K€K€KKKKKKKKKKKKKKKKKKKKK€KƒK‚KK‚KƒKƒKƒKƒKƒKƒKƒKƒKƒK‚KKKƒKƒKƒKƒKƒKƒKƒKƒKKK‚Kƒe]qÏ(KçKæKìKÏKpK‘KéKÈKwKeKmKkKmKmK_KŒKæKÌKuKeKkKkKnKgKaK¯KðK¨KhKjKmKkKkK_K{KÜKÖKzKeKmKjKlKcKlKÊKçK‹KbKkKjKlKbKkKËKæK‹KbKkKjKmK]KKåK¿KœK²KnKkKmKkKoKuKxK^KKKNKJKIKPKRKNKKKQK[K^KQK9K8K1KKKKKK +K KKKKKKKKKKKKKKKK!K!K"K"KKKKKKKKK KKKKKKKK K$K!K#K#K!KK!K%K%K$K#K!KKKKK!K!K K#K&K%K'K'K$K$K$K$K%K$K%K%K$K KK K%K,K.K.K.K,K.K4KAKKKOKIKIKHKEKMKHKCK:K3K,K'K,K'K KKK K#K$K#KKKKKKKK'K1K=KDKEKBK;K1K#KKKKKKKKKKKKKKKKKKKK!K%K)K'K'K-K=KWKhKsKtKqKpKpKrK`KFKIKHKJKCK1KYK]KWKMKMKYKnKÍKÒKÏKÏKÏKëKýKÓKvKvKvKuKtKtKsKsKsKsKsKsKsKsKsKtKsKsKsKsKtKtKtKtKtKtKtKuKuKsKtKuKuKuKwKQK*K/K0K.K'K,K/K/K/K-K-K.K.K.K.K.K.K-K-K-K-K-K,K*K+K+K+K*K(K)K)K)K'K+K;K=K=K:K#KKKKKKKKKKK#K&K(K-K1K1K4K4K7K8K9K>K>K?KBKBKBKCKDKDKGKJKKKYKÈKæKãKæKéK«K{KK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KKKKKK}K}K}K~KKKKKKKKKKKKKKKKKKKK€K€K€K€K€K€K€KKKKKKKKKKKKKKKKKKKKKK€KK‚KK€K‚KƒKƒKƒKƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒKƒKƒKƒKƒK‚K‚KƒKƒe]qÐ(KçKæKåKíKÒKsK|KÝKÛKƒKfKmKlKlKnK`KxKÕKÝK„KdKlKkKjKjK_K–KìK¿KnKhKlKiKnKaKkKÉKçKKeKkKkKmKdK_K²KîK¡KeKiKjKmKeK^K¶KñK¢KiKiKjKmK`KhK€KeK\KgKrKqKkKoKrKwKYKKKNKIK=KPKQKNKDKJK]K]KKK8K8K0KKKKKK KKKKKKKKKKKKKKKKKKK K!K KKKKKKKK KKKKKKKK#K$KKKK#K$K KK#K"KKK"K$K#K"K!K!K!K#K%K%K%K$K#K#K#K%K'K$K!KKK!K)K,K+K,K-K-K-K.K7KCKFKEKCKEKGKJKDK;K7K/K,K,K.K)K$KKK!KKK#K#K KKKKKKKK K6K@KAK7K&KKKKKKKKKKKKKKKKKKKKK%K&K(K&K(K3KMKdKrKsKqKnKpKpKpKpKqKkKKKHKIKIKJK/KOK`KXKPKKKZK_K¶KÖKÏKÏKÎKàKúKîKˆKrKvKuKtKsKsKsKsKsKsKsKsKsKsKsKsKsKtKtKsKsKtKtKtKsKtKuKuKsKtKuKuKuKuKgK2K.K0K/K)K*K/K0K/K.K.K.K.K-K-K.K.K.K.K.K.K.K,K+K+K+K+K+K)K)K)K)K*K(K5K>K=K=K.KKKKKKKKKKK"K&K)K-K0K1K3K4K7K7K9K=K?K?KAKAKAKCKCKDKGKGKLKIKŽKçKãKæKêKÖKˆK}K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KKKKKK~K~K}K~KKKKKKKKKKKKKKKKKKKK€K€K€K€K€K€K€KKKKKKKKKKKKKKKKKKKKK€K€KKƒKK€K‚K‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒe]qÑ(KçKçKçKåKëKÑKtKlKÉKèK–KfKlKlKiKlKcKjKÃKêK˜KdKjKlKkKkK\K€KàKÔKyKeKmKiKmKdKcKµKðK¤KfKjKlKmKhK\K›KïKºKjKgKjKlKgKZK˜KÈKvKgKjKiKnKcKIKaKbKgKpKoKjKnKsKvKSKJKNKGK;KSKQKOKDKKK\K]KJK8K:K/KKKKKKKKKKKKKKKKKKKKKKKK*K*K K!K!KKKKKKKKKKKKKKKKKKK$K&K%KKK#K&K$K(K(K%K&K%K"K!K!K"K!K K#K'K&K'K&K#KKK!K"K(K*K*K)K)K)K(K-K2K7K9KKAKDKDKDKDKHKKKLK\KÌKéKçKèKíK­KyK~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KKKKKKKKKKKKKKK€K€K€K€K€K€K€K€K€K€K€KKKKKKKKKKKKKKKKKKKKKKKKKKKK€KƒKƒKƒK‚K‚KK€KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒe]qÒ(KæKçKçKåKåKëKÒKxKaK±KîK­KhKjKkKjKnKfK`KªKðK«KhKkKlKjKlK`KqKÏKäK‰KeKlKiKmKjK[KšKðKºKlKgKlKkKlK[KKæKÌKmKhKkKlKlKYKOKbKjKiKkKkKmK\KcK`KiKqKpKlKoKtKrKPKJKNKFK@KUKPKOKDKMK\K^KGK8K9K.K"KKKKKKKKKKKKKKKKKKKK K2KCKNKDK(KK#K!KKKKKKKKKKKKK K KKKK"K"K!K$K-K8K6K-K+K+K'K&K%K!KK KK K!K"K&K&K"KKK$K*K,K*K)K(K&K%K&K'K-K0K3K5K6K9KK=K=K-KKKKKKKKKKK K%K)K-K0K3K5K5K6K9K:K>K>K?K?KAKCKCKCKDKGKHKLKKKŽKéKçKçKìKÕK†K}K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K~K~K~KKKKKKKKKKKKKKK€K€K€K€K€K€K€K€K€K€K€KKKKKKKKKKKKKKKKKKKK€K€KKKKKK€KKƒKƒKƒK‚K‚KKKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒe]qÓ(KçKæKçKçKçKåKêKÏKyK]KKìKÀKqKgKlKkKmKhK^K˜KîKÄKqKgKmKlKnKeKeKºKïK KeKlKlKkKjKZK„KçKÑKyKhKiKkKlK[KfK‹KoKiKlKiKkKkK_KLK[KiKjKjKkK[KeK_KdKhKiKgKkKtKoKNKKKNKDKCKVKPKNKBKRK]K]KEK8K6K,K&KKKKKKKKKKKKKKKKKK"K9KMKSKRKNKLKCK&KKKKKKKKKKKK K +K K KKKKKK#K-K:KAK@K8K0K-K,K'K"K K K K K!K!K!KKKKK&K*K,K,K,K+K&K!K"K#K%K*K-K/K2K5K5K5K3K1K.K/K2K3K*K$K$K!K K"K#K"K%K,K3K;KAKCKEK:K&K"K$K"KKKK KKK;KKKKKKKKKKKKKKKK#K(K'K'K'K0KEK[KmKtKrKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKaKFKLKLKJKEK0KXK\KUKMKMK[KjKÈKÕKÒKÓKÐKçKüKäKKtKvKuKuKvKuKsKsKsKuKuKsKsKsKtKvKuKuKsKtKuKuKuKuKuKuKuKuKuKuKuKuKuKwKkK6K1K4K1K*K,K0K/K0K0K0K0K0K0K0K0K0K0K0K/K-K.K-K.K.K-K-K.K,K+K)K(K)K'K/K>K?K?K8K!KKKKKKKKKKK#K(K,K.K1K6K3K4K9K:KK@KBKAKBKCKDKFKGKLKMK]KËKëKçKçKïK®KzKK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K€KKKKKKKKKKKKKKKKK€K€K€K€K€K€K€K€K€K€K€KKKKKKKKKKKKKKKKKKKK‚K‚KKKKKK‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒe]qÔ(KìKèKåKåKâKÞK×KÖK®KoK^K…KáKÕKKhKmKkKmKmK_K‚KãK×K~KfKlKjKkKhK]K KñK¶KhKgKkKiKnK]KnKÑK¾KhKiKjKiKlKaKEKSKdKhKiKiKiKkKdKPKYKhKjKiKZKbKjK‘K­K­K KK…KjKKKKKLK?KGKVKPKLKCKVK\K\KCK9K6K)K)KKKKKKKKKKKKKKKK&K:KOKVKTKUKSKSKPKGK/K!K K"KKKKKKKKKK +K KKKKKK$K/K5K;K=KAK=K5K.K&K"K K K"K"K$K!KKKK K(K*K)K,K,K(K#K$K"K"K%K%K&K(K*K+K/K1K.K0K2K4K5K/K)K%K KK K!KK"K*K/K5KKAKAKBKBKEKEKCKFKJKNKJKKäKßKâKæKÒKƒK|K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KK~K}K}K~KKKK~K~KKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€KKK€KKKKK€K€K€KKK‚K‚KKKKKK‚KƒKƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒe]qÕ(K…KÛKÙKÍKÁK´K£K‘KKiKjKbKuKÐKåKŽKcKmKlKjKlKbKoKÐKæKKeKlKiKkKmK[K‹KèKÌKvKgKjKjKlKaKSK_KeKgKjKjKjKjKiKPKNKbKhKiKjKiKlKgKQKSKgKdKfKK¬KùKùKöKìKõK¦K_KLKLKMK>KJKVKQKLKDKXK\KWK>K9K6K'K)KKKKKKKKKKKKKKK-KEKMKSKVKYKYKXKHK3K"K K KK!K KKKKKKKK K +K +K KKKKK'K+K0K8K?K=K5K*K!KK K!K!K!K!KKKK K&K%K(K(K(K$K#K KK#K$K$K%K&K%K%K)K-K,K.K1K3K4K.K'K"K K K K K"K%K*K1K7K;KK@K5K"KKKKKKKKKK!K%K)K+K/K1K4K5K7K6K9K9K>K@KK:K5K)K'KKKKKKKKKKKKKKK7KLKQKVK^K]KHK3KKKKKKK K K!KKKKKKKK K +K KKKKK$K+K2K6K3K'KK"K!K K"K KKKKK#K'K'K&K$K%K%K KKKK"K$K$K#K$K'K(K(K,K/K.K/K0K,K&KKKK!K K$K(K.K0K3K7K8K=K@K@K?K>KK8KaK\KUKKKQKYKxKÏKÐKÏKÐKÏKêKüKÕKxKwKwKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKmK9K1K2K3K0K,K2K1K2K2K0K/K0K/K2K2K1K0K0K0K0K0K/K/K/K.K-K/K.K.K,K*K+K)K/K>K?K?K=K'K KKKKKKKKKK!K&K+K,K/K2K3K4K4K5K9K=KK;K4K(K&KKKKKKKKKKKKKK$KCKSK\KTKEK.KKKKKKKKKK!K KKKKKKKKK K KKKKK$K)K)K#KK K K$K$K!KKKK K!K$K(K'K%K"K"K"KKKKKK"K#K$K$K&K*K-K-K/K.K-K'K KKKK K"K&K,K1K5K5K3K6K8K;K?K@K;K3K$KKKKKKKK#K$K#KKKKKKKKKKK$K'K(K(K*K6KMKdKqKsKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKpKpKqKqKpKsKaKGKIKHKJKGK1KXK_KXKPKLKYKdKÀKÓKÏKÐKÎKâKùKìKˆKuKwKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKyKLK.K3K3K0K+K3K3K3K3K0K0K0K0K-K.K/K0K0K0K0K0K0K0K0K/K-K/K.K/K,K+K+K+K*K:K@K>KAK0KKKKKKKKKKK K%K*K+K/K1K2K1K7K:K=K=K=K@KBKBKAKAKFKHKFKGKLKWKcKÉKâKÚKØKßK¦KzKK~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K~K}K}K}K}K~K}K}K}K~K€K~K}KK€KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€KK€K€K€K€K€K€K€KKK€K€K€KKƒK€KK‚K‚K€K€KK‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚KƒKƒKƒKƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒe]qØ(KeKMK3K;KPKRKQKQKPKPKPKSK¡KéKÊKšK¥KâKÉK|KjKlKkKmKlKZKvKŒKgKhKjKiKiKjKeKOKOK_KhKhKiKiKjKlKYKEKVKeKiKjKiKiKlKaKLKœKÉK}KgKlKlKoKbKÚKßKàKKùKïKõKçKKWKLKNKKK:KQKSKOKEKFK[K\KSK;K;K4K&K'K KKKKK KKKKKKKK3KRKQK>K(KKKKKKKKKKKKKKKKKKKKKKK +KKKKKK!K KK K K"K!KKKK%K)K)K&K%K&K$K%K%K$K#KKKKKK"K$K%K)K*K,K*K'K'K#KKK KK!K$K)K+K1K4K3K5K5K5K6K7K9K7K*KKKKKKKKKKK K$K#K!KKKKKKK"K'K(K'K)K0KDK[KlKtKrKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKtKqKpKsKsKsKtKjKJKHKIKHKIK1KNK`KYKSKHKWKZK¦KØKÑKÐKÎKØKõKùK¢KrKwKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKtKzK`K/K2K3K2K,K/K3K3K3K3K3K3K1K-K2K2K0K/K/K0K0K0K/K/K/K/K/K0K.K-K+K)K&K(K1K?K?K@K9K#KKKKKKKKKKK$K(K+K,K+K.K3K:KAK=K8K=K?K?KBKBKEKGKFKFKGKLKUKRK“KáKÜKàKãKÐK„KKK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KKK}K}K}K~K€K~K}K}K~KKKKKKKKK~K}KKKKKKKKKKKKKKKKKKKKKKKKK€KƒKKKKKKKKKKKK‚K‚KƒKKKKKK€K‚K‚K‚KƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒe]qÙ(K/KMKFK0K9KOKQKPKQKQKQKRKQKKðKìKØKÕKäKÃKsKkKlKlKjKlKZKDKUKeKhKjKiKhKkKhKPKKK\KeKiKjKiKiKkK^KEKPKcKiKjKjKiKlKhKXKhKqKcKeKmKmKmKÍKºKK·KÎKÊKÑKÌKzKSKMKNKIK;KSKSKOKDKGK\K]KRKKBKAKBKEKGKGKFKGKNKRKTKfKËKåKâKâKåK«K|K€K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KK}K}K}K~KK~K~K~K~KKKKKKKKKK~KKKKKKKKKKKKKKKKKKKKKKKKK€K‚K€KKKK€K€KK€K€K€KK‚K‚K‚KK€KKK€KK‚K‚K‚KƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒe]qÚ(KK4KEK;K1K5KMKQKQKTKRKTKUKVKwK{K€K‹KxKlK^KcKiKjKjKiKlKbKLKQKbKiKiKkKkKiKjKVKIKWKbKhKjKiKiKlKcKHKJKbKiKdKkKlKlKkKTKTKƒK„KkKmKcKhKuK‹K€KwKtKsKxKvKPKMKOKGK;KTKRKPKCKKK]K_KOKKVKhKrKtKpKoKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKrKqKpKpKqKtKrKqKrKrKsKsKtKaKFKIKHKIKEK/KYK^KYKQKKKWK`K¼KÖKÒKÓKÐKÝK÷KñK•KtKyKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKxKdK5K5K4K0K-K1K3K2K3K3K3K3K4K3K3K3K3K3K3K4K2K1K3K2K1K0K0K/K/K.K-K*K,K*K.K=K@K?K@K+KKKKKKKKKKKK(K8K@K@K-KKK,K9KK?KAKBKEKGKFKFKFKNKQKRKWKcKËKåKáKâKçK­KzKKKK~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KKKKKKK~KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€KKK‚KƒK€KKKKKK‚K‚K‚K‚K‚KƒKƒK‚KƒKƒKƒKƒKƒKƒKƒKƒK‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒe]qÜ(KjKVKEK:KHKFK/K:KXKbKoK€K‘K¢K³K½K«KtKdKfKeKdK`K\K]K`KbKcKhKiKPKKK_KfKgKkKkKiKlKdKOKNK]KfKjKkKkKmKkKTKEKÁKÑKqKgKmKlKoK^KwKàKØKºKöKÏKõKôKôKíKÿKºKdKLKMKPKBKDKVKPKMKBKQK\K^KGK:K@KBK'K&K&KKKKKK KKKKKKKKKKKKKKKKKK#K1K@KMKSKMKGKGK>K'KKKKKKKKKK K K K +K KKKKK!K$K(K/K0K.K.K+K*K(K)K)K&K%K&K&K*K'K%K KKK K!K#K%K%K)K+K+K+K)K+K-K.K/K/K+K#KKKKKKKKKKKKKKKKKKKKK"K'K(K*K*K4KIKbKqKsKoKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKrKtKqKpKpKqKtKqKpKpKqKsKsKuKiKJKIKIKHKIK:KRK`KYKQKIKTKWK KÙKÒKÓKÒKÖKòKúK²KrKyKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKsK@K3K5K7K3K.K3K2K3K3K2K4K5K3K3K3K3K3K2K3K0K/K3K2K/K/K0K0K0K.K-K+K+K+K+K8K?K>KBK8K KKKKKKKKKK&K;KAK;K+KKK&K4K9KK2K"KKKK$K-K6K6K9KKNK0K'K*K KKKKKKKKKKKKKKKKKK*K6KK%KKKKKK1K?K=K-KKKKKK&K2K7K8K8K:K=KAK@KCKCKFKGKGKGKGKKKPKTKTKbKËKåKáKáKæKªKzK€KKKKK€K~K}KKK}K}K}K~KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€KK€K‚K‚K‚KKKKK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒK‚KƒKƒKƒKƒe]qà(K{KªKKSK_K@KKuKðKÁKLKŠKíKêKçKéKéKéKæKëKÙKzK|KÐKéKïKïKíKíKÊK‡K_K€KÈKîKðKçKæKÜK´KsKiKkKlK`KEKOKbKiKlKlKlKnKkKTKPKdKeKbKkKqKgK¦K£KsKŒK£K¨K¦K°K|KYKKKMKJKBKQKUKPKJKOKZK[KXKAKK:K'KKKKKK"K*K3K6K4K5K:K;K=K?KCKCKEKGKGKGKGKIKLKRKTKQK•KæKßKÝKßKÌK†K€K€KKKKK~K}KKK~K~K~KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€KK€KK‚K‚KK€K€K€K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒe]qá(KÀKäK€KK7KOK@KKzKïKÆKSKŠKíKêKèKéKéKéKåKëKÚK~KcK‚K¦KËKÏK™KfKsKµKèKðKëKéKïKîKÉKšKdKaKeKhKlKdKGKIK_KhKfKjKlKlKnK`KSKŽK¤KzKnKjKkKwK­KœK…K|KKvKxKUKJKLKGKEKSKSKLKLKTK\K\KUK?K=KDKPK;K#K&K'KKKKKK KKKKKKKKKKK!K+K5KKAKBKDKEKFKGKHKIKHKKKSKVKUK–KåKÞKßKáKÒKŠK~K€K€KKK~K}K~KK~KKKKK~K}KKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€KK€KKKKKKKK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒK„KƒKƒKƒKƒKƒKƒK‚KƒK…K„K„KƒKƒe]qã(KÝKÆK;KKKKKK®K&KvKïKÈKSKKáKæKçKçKéKêKçKíKÞK†KbKdKbKcKfKyK›KÄKãKâK¬KjKeK¦KìKªKSK\KZKYKWK[K_KLKNKËKÐKyKjKqKpKqKdKbK½KêKÉKòKÏKòKñKóKîKüKÆKlKQKNKLKKKLKWKRKMKKKUKZK^KPK;K=KHKOKDK&K%K'KKKKKK K K KKKKKKKKKKKKKKKKKKKKKKKK K!K"K#K)K-K%KKKKKKKKKKKKKKKKKK K&K$K!K#K&K'K+K,K.K/K.K,K)K$KKKKKKKKKKKKKKKKKKKKKK"K$K(K)K*K4KJKaKpKrKrKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKtKrKpKsKtKsKtKtKsKtKqKpKsKtKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKvKaKHKIKHKHKJKEKXK_KWKQKIKYK[K©KÕKÎKÐKÎKÖKðKúK³KrKxKyKwKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKyKwKuKxKyKyKxKyKwKuKxKxKzK^K6K9K8K7K/K2K8K8K8K8K5K4K5K5K5K5K5K5K4K4K5K6K4K2K3K3K3K2K0K/K-K.K.K+K*K:KCKCKDK8K"K#KKKKKKKKKKK"K*K1K2K4K6K;KKDKGKFKGKIKHKIKJKMKQKcKÎKäKáKßKäK®K~K€KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€K€KKK‚K‚K‚KƒKƒKƒK‚K‚K‚K‚K‚K‚KƒKƒKƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒK…K„KƒKƒKƒKƒKƒK…K…K…K…K…KƒKƒe]qæ(K¼KWK>KAK9K)KKK1KaKiKpKqKgK‡KkK2KJKK‚K|KK‚K‰KKK¡K®K˜KuKpKmKiKjKdK[KQKGKJKUKIKHKPKRKUKVKWKWKYKYK’K¸K¦K§K±K°K£K‡KpKrKoKÛKçKÂKñK÷KôKñKýK™KYKJKLKNK:KDKWKOKMK>KRK\K]KIK=K?KLKNKJK3K"K&K#KKKKK K +KKKKKKKKKKKKKKKKKKKKKK&K(K*K)K)K)K+K(K'K$K K!KKKKKKKKKKKKKKKKKK"K$K&K%K!KKKKKKKKKKKKKKKKKKKKKK"K$K'K(K'K/K@KZKmKtKtKpKoKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKrKtKqKpKsKsKpKpKpKrKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKRKFKIKHKJK=K3K^K^KYKOKPK[KdK¿KÓKÏKÐKÍKÚKóKöK KtKzKxKxKvKuKuKuKuKuKuKuKvKxKxKuKwKyKvKuKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxK{K`K8K9K:K:K2K3K8K8K7K8K8K8K7K5K6K6K7K8K5K5K4K5K5K5K5K3K2K0K0K0K-K+K%K$K2K>KCKCKEK?K$K K KKKKK KKKK#K'K*K0K4K8K:K:K:K:K>K@KDKCKEKGKEKHKIKHKHKMKQKSKQK—KäKßKÞKáKÒK‰K}KK€K€K€KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK‚KƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒK‚KƒK‚K„K…KƒKƒK‚KƒK…KƒK‚K„K…K…K…K…K…K…K…K…e]qç(KÎKNKKŠK|K=KeKÁK¼K°K£K—K‹KK}K©K¼KjKfK‚K{KlKkKjKdK\KNK>K;K8K8K>KCKMKSKWKYK\KÇKüKòKëKãKÖKÌK¼KK}KgKŒK’KiKxKŠK“KŠK KKXKIKLKKK8KKKTKNKKKAKWK[K\KGK=K?KLKMKJK9K$K&K%KKKKK K KKKKKKKKKKKKKKKKKKKK!K$K(K)K&K'K'K(K&K$K$K#K"K$K"KKKKKKKKKKKKKKKKK%K%KKKKKKKKKKKKKKKKKKKKKKK!K)K)K%K+K:KPKfKqKsKrKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKqKpKqKsKqKpKsKsKpKpKpKrKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKvK]KGKJKHKIKHK.KVK_KYKPKMK[KYK¥K×KÎKÐKÐKÔKíKùKÉKuKyKyKxKvKuKvKvKuKvKvKuKvKxKwKuKvKxKvKuKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKpK@K8K9K;K5K/K7K8K9K8K8K8K8K9K9K9K8K7K5K5K6K5K5K4K4K3K2K0K0K/K.K*K(K5K?K>K?KCKCKDK/KK KKKKK K +KKK"K(K+K/K3K7K9K:K9K:K>K@KBKDKFKGKEKGKIKIKHKIKQKSKVKcKÈKßKÝKÞKâK¬K~K‚K€K€K€KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€K€KK‚KƒKƒKƒK‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒKƒKƒK‚K„K„KƒKƒKƒK„K…K„KƒK„K…K„K„K…K…K…K…K…e]qè(K½KNKDKGKGK=KKHKOKcKÛKõKëKìKïKóK÷K÷KõKæKÇK—KK¸K®K•K†KKzKuKYKKKLKJK7KOKSKOKJKBKXK[K[KFK=K@KLKLKJK>K$K#K#KKKKKKKKKKKKKKKKKKKKKKKKK K!K!K%K&K'K$K!K"K!K&K%K#K"KKKKKKKKKKKKKKKKK K$K$KKKKKKKKKKKKKKKKKKKKK!K&K(K(K&K/KCK\KnKrKqKpKpKpKqKpKnKoKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKtKsKpKpKpKpKpKsKsKpKpKpKrKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKvKeKJKIKHKHKKK0KHKaK[KRKNKYKXKŠKÕKÐKÏKÐKÒKæKõKçK‚KwKyKxKvKuKyKxKuKwKyKvKuKuKuKuKuKuKuKvKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKxKzKOK8K:K9K4K/K5K7K7K7K8K8K8K8K8K8K8K8K7K7K8K6K5K3K2K3K2K/K0K-K)K/K;K?K=K'K4KDKCKCK>K#KKKKKKKKKKK%K+K/K1K4K7K:K9K:K>K>K?KDKGKGKGKGKHKIKHKHKLKSKYKRK–KáKÝKÞKáKÓKŠKK€K€K€KKKKKK~K}KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKƒKƒK‚KK€KƒKƒKƒK‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒK‚K‚K‚K‚KƒKƒKƒK…K„K‚K‚K‚K‚KƒK…K…K…K…K…K…K„K‚KƒK…K…K…K…K…e]qé(K†K,KSKCKBKBKK?KVK€K®KØKðKõKòKñKîKîKïKòKðKîKîKáKèKÈKqKQKKKLKHK9KVKTKNKDKEK]K]KZKAK>KAKLKJKFK@K'K K"KKKKKKKKKKKKKKKKKKKKKKKKK K KKKKKK"K#KKKKKKKKK K#KKK!KKKKKKKKKKKIKKKKKKKKKKKKKKKK!K$K%K$K&K3KGK^KmKrKoKnKmKnKnKoKpKpKpKpKpKnKoKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKtKrKpKsKtKsKsKtKtKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKrKSKHKMKIKJK@K4K\K\KYKQKSK[K`KºKÖKÎKÐKÎK×KñK÷K´KsKzKxKyKxKuKuKuKuKuKxKyKyKxKuKwKyKvKuKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKtKBK8K:K;K7K/K9K:K:K:K8K7K8K8K8K8K8K8K7K4K4K4K6K4K3K2K/K/K7K?KCK6K KKKK;KGKFKHK:K"K!K KKKKKKKK#K(K,K1K4K7K:K:KKBKCKDKGKFKFKHKIKIKIKLKRKTKUKiKÎKàKÝKÜKáK¬K|KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€KKKKKK€KƒK‚KKKƒK‚KƒKƒKƒKƒKƒKƒK‚K‚K‚K‚KƒKƒKƒK‚K‚K‚K‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K„K„KƒKƒKƒKƒKƒK‚KƒK…K„K„K„K…K…K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…e]qì(K;K=K4KdKŽKcKEKIKIK=K–KðKæKˆKDKeKKnKKuKîKÔK_KƒKëKêKçKéKìKìKëKíKÙKK·KîKïKïKÎK\KQKRKOKOKTK[KbKkKqKnKmKjKbK\KVKQKVKhK†K­KÖKîK÷K÷KôKðKãKîK­KgKMKMKMKCK@KWKPKOKCKJK]K^KVK>KKAKXKQKMKAKMK]K^KSK?K?KDKJKGKEKAK0K!K KKKKKK K K KKKKKK K"K#K$K$K!KKKKKKKKKKKK K-K)K K!K(K+K/K1K0K2K3K3K2K.K"K KKKKKKKKKKqK!KKKKKKK!K#K(K'K'K.K>KVKjKsKsKoKmKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKsKsKpKrKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKuKuKuKuKsKuKuKuKvKmKJKHKIKHKLK7KK=K5K1KKrKìKÒK^KƒKëKïKëKëKëKìKëKìKëKéKïKèKKOKSKRKQKQKPKPKQKQK]KÑKóK×K¸K—K|KrKnKnKmKhKcK]K\KaK{KK|K™K‰K_KIKJKIK:KEKXKQKMK@KNK^K^KQK@K@KEKJKFKBK@K7K!KKKKKKK KK K KKKKK!K&K'K KKKKKKKKKKKKKKK,K,K)K)K-K1K1K0K/K1K0K,K!KKKK!KKKKKKKKKrK#KKKKK!K&K'K'K)K5KMKcKoKrKpKpKpKoKoKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKqKpKpKpKpKpKpKpKpKpKpKpKpKsKsKqKrKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKtKuKuKuKuKtKuKuKuKuKtKTKGKIKHKLKBK1K\K^KZKQKJKZK^K³KÖKÏKÐKÐKÔKíKøK¹KuK|KyKxKxKxKxKxKxKxKxKxKxKvKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKwK{KYK9K:K:K;K4K6K:K:K:K:K:K8K9K9K7K8K8K8K7K5K3K7K>K@K/KKKKK K$K'K!KK"K.KCKEKDKEK1K#K%K!KKKKKKK!K%K*K0K2K5K8K:K:K>K>K>KAKDKEKBKEKHKHKIKJKKKJKLKSKXKQK˜KâKÚKÝKáKÑKŠK‚KK€KKKKKKKKKKKKKKKKKKKKKKKKKKKK€K‚K‚KK€K€K€KK‚KƒK‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒKƒK„K„KƒKƒK„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]qï(KšKÅK›K±KƒKvK´K·KfKiKÛKêKyKNKÆKÍKnKgK\KPK>K%KzKÕKÎKcKKëKïKêKìKìKìKëKêKîKÑKyKTKRKQKQKQKPKMKOKRKPKiKÞKðKðKõKñKÞK¾K™K~KpKnKnKlKhK\KMKQKtKmKwKYKFKHKKKK@KHKJKFKDKBK:K!K KKKKKK KK K KKKKK KKKKKKKKKKKKKKKKK%K*K+K.K-K,K/K.K/K-K'K KKKKKKKKKKKKKKKrK$KK K%K'K'K'K/KCKZKmKrKqKnKmKnKoKqKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKsKsKpKpKpKpKpKpKpKpKpKpKpKpKsKsKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKuKvKuKuKuKuKuKuKuKuKuKxK]KHKKKHKHKHK.KSK_KZKTKIKWKWK—KÙKÏKÐKÓKÓKèK÷KÖK{KzKyKxKxKxKxKxKxKxKxKxKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxK{KkKK7K3K4K;K9K:K:K:K9K7K9K:K8K8K8K7K4K4K>K=K'KKK"K&K(K*K(K*K,K(K)K*K=KGKFKIK=K%K&K"K KKKKKKK#K*K.K2K6K8K:K9K;K>K>KCKDKCKCKEKHKIKIKIKHKHKJKTKWKTKiKÌKÞKÜKÜKàK¬K~KƒK‚KKKKKKKKKKKKKKKKKKKKKKKKKKKK€KƒK‚KKKƒKƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚K„K…KƒKƒK…K„K‚KƒKƒK‚KƒK…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]qð(K§K”K±K K[KK¬KãK¿K…K»K»K`KCKYKÉKÏK~KnKqKnKQK’KÁKßKÚK]KsKØKåKçKêKêKêKéKìKÚKKNKQKOKOKMKMKMKNKPKNKzKëKñKîKîKðKôKöKñKàKÁKKKuKmKpKXKxKîKÌKtKQKHKHKKK;KMKVKOKHK?KXK_K^KKK?KAKGKHKFKBK@K;K"KK KKKKKKK KKKKKKKKKKKKKKKKKKKKK'K+K,K+K*K-K-K-K,K'K#KKKKKKKKKKK"K#KKKKKKDK(K%K*K(K*K8KPKeKrKrKpKoKoKoKoKoKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKsKsKpKpKpKpKpKpKpKpKpKpKqKrKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKtKsKsKtKtKtKtKtKuKuKuKuKuKuKtKuKuKwKfKIKIKHKIKLK1KGKaK[KTKLKSKXKzKÓKÐKÏKÑKÏKàKóKêKKvKzKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKwKGK9K=K7K6K2K:K:K:K:K:K9K7K9K:K8K8K8K8K5K7K:K#KK%K*K,K/K2K2K1K.K/K,K,K*K3KFKGKFKEK/K#K#K KKKKKKK K&K-K2K5K8K9K:K:K=K>KAKCKCKCKEKHKGKGKGKHKIKKKOKSKWKVKKáKÚKÝKàKÓKŠKKKKKKKKKKKKKKKKKK€KK€KKKKKKK€KK€K€KKKK€KK‚KƒKƒKƒK‚K‚K‚KƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K„K…K„K„K…K„K‚KƒKƒK„K„K…K„KƒK„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]qñ(KŒKfK¡KXKTKKµKÕKÙK‘KsKpKJKSKFK[KËKËKqKnKqKmK»KÛK—KÎKËKSKcK²KÃKÉKÐKÖKÜKßKêKáKyKJKOKMKNKNKNKMKOKMKKñKíKïKïKðKïKïKðKóKöKôKäKÉK£K‹K[K†KùKÌKqKRKGKIKIK:KRKVKMKHKAKWK]K_KIK>KAKGKGKEK@K;K9K'KK!KKKKKK K KKKKKKKKKKKKKKKKKK%K,K+K+K*K*K+K*K+K+K&K KKKKKKKKKKKKK#K%K$K$KKK'K&K'K*K0KCK]KoKtKsKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKsKsKpKpKpKpKpKpKpKpKpKpKsKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKuKvKtKtKuKuKvKtKsKuKuKuKuKuKtKsKuKuKtKnKLKHKIKKKOK9K;K^K\KWKNKNK[KfKÄKÓKÏKÐKÎK×KðKõK«KuKyKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKwK{KZK9K>K=K>K7K7K:K:K:K:K:K:K:K9K8K7K8K8K7K;K5K)K2K2K4K3K5K5K3K2K0K0K-K+K)K,KBKGKEKJK;K%K%K!K!K KKKKK K#K*K/K2K5K8K;K9K=K?K@KBKCKCKEKHKFKHKIKHKIKKKMKSKVKUKiKÉKÚKÛKÛKßK©K{K€K€KKKKKKKKKKKK€K€KK€KƒKKK‚KƒKƒK‚KKKƒK€KKKKKKK‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚KƒKƒKƒK‚K‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒKƒK‚K„K…K…K…K…K„K‚KƒKƒK„K…K„KƒK‚K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]qò(KvKjK`K.KUK{KÁKÕKÎK¥K¦K|KBKJKTKAKYKºK—KiKpKmKŽK®KQK?K©K–KBKLKyKK‚KŒK—K¤K²KÀKµKbKKKOKLKLKMKMKQKMKžKüKöK÷KõKóKñKïKïKïKðKñKôK÷KöKëKÁKÀKôK½KmKSKJKKKGK:KTKRKMKEKAKYK\K]KIK?K@KHKHKHKDK=K;K,KKKKKKKK KKK K KKKKKKKKKKKK K%K/K1K1K-K*K+K-K+K,K#KKKKKKKKKKKKKKKKK&K&K'K&K)K)K,KK;K=K=K8K3K:K:K:K:K:K;K9K8K9K9K9K8K7K8K8K7K5K2K5K5K6K7K4K3K0K.K.K-K/K-K9KIKGKHKCK+K%K$K K KKKKKK#K(K-K0K3K8K:K:K:K=K@KDKDKDKFKGKFKHKIKHKIKKKMKQKRKWKVKœKÜKÕKÙKÝKÍKˆK}K€KKKKKKKKKKKK€K€KK€KƒK‚K‚K‚KƒKƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚KƒKƒKƒK‚K‚K‚K‚K‚K‚K‚K„K„KƒKƒKƒKƒK‚K„K…KƒKƒK…K„K„K„K„K…K…K„K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]qó(KoKMKEK0KLK„KÄKÏKÂKÐKÞKÇKjKDKNKPKAKOK—KqKnKoKvKuKRKK.KmKjK9KHK‘K•K„K}KyKtKsKyKnKGKFKNKLKJKJKMKNKeKŒK£KºKÒKãKðKøKùKùKùKõKòKïKîKñKöKãKèKµKhKOKKKLKDK:KWKPKMKEKAK\K\K\KFK>KAKUKYKYKXKWKYK>KK KKKKKK K K K K KKKKKKKKKK#K,K/K.K/K/K1K/K,K)K%KCK*KKKKKKKKKKKKKKKKK!K&K*K%K'K3KFK]KpKsKpKnKpKpKnKoKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKpKpKsKsKqKpKqKqKpKsKtKtKsKpKrKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKsKsKsKsKsKtKvKtKsKsKtKuKuKuKuKuKtKtKuKuKuKuKuKuKuKuKwKZKHKLKIKHKHK.KSK^KYKTKHKTKXKKÖKÎKÐKÐKÐKæKõKãK†KyK{KyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KzKxKxKxKLK9K=KK@KCKDKFKFKFKHKHKIKIKLKKKQKSKWKWKkKÍKÜKÙKÙKßKªK|KK€KKKKKKKKK€KKK€K€KKƒK‚KƒK‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚KƒKƒKƒK‚K‚K‚K‚K‚K‚K‚K„K…KƒKƒKƒKƒK‚K„K…KƒKƒK„K…K…K…K…K…K…K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]qô(KVK=KK7K7K:K9K9K:K:K:K:K5K6K:K9K:K8K8K8K8K6K5K5K2K4K4K5K5K4K3K1K/K0K/K@KHKFKJKCK(K%K#K!KKKKKK!K$K(K-K1K5K9K:K9KK?KCKDKEKGKGKEKHKIKLKJKLKSKTKWKVKžKßKØKÙKÜKÎKŠKK‚KKKKKK€K€KKKKK‚KƒKK‚K‰K„K„K…KƒKƒK‚KK‚K‚K‚K‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K„K…K…K„K‚KƒK‚K„K…K…K„K‚KƒK„K„K…K…K…K„K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]qõ(K:KAK6KKAKYKÛKòKÚKÆK°K˜KƒKqKdK\K[KdKuKŠK£K»KÈK²KÇK—K`KIKKKLK@K?KZKPKMKAKHK_K^KZKAK?K9KKKKKKKKKKKK K +K K K K K KKKKKKK"K(K*K+K-K/K/K*K+K#KKKKK.KxKKKKKKKKKKK KK"K&K)K'K'K3KKKbKnKrKqKoKnKoKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKqKpKqKsKrKqKqKqKrKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKtKtKtKsKsKtKtKvKtKsKtKtKtKtKuKuKuKtKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKnKLKKKMKLKLK:KKCKYKPKMK>KHK^K_KWK>K?K7K*K%KKKKKKKKKKKKK K K K KKKKKKK#K$K(K)K+K+K$KKKKKKKK0KuKKKKKKKKK"K#K%K&K&K&K+KK?KAKBKDKDKCKCKHKHKIKLKLKLKLKNKQKZKUKŸKàK×KÖKÚKËKŠK€KƒKKK‚KƒK€KKKŽKªK¢K‘K“KœK©KÁKÅK©KžK”K†K‰K™KŽK€K‡K…KKKƒK‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚KƒK…KƒK‚K„K…K…K„K‚K„K…K…K…K„K„K„K…K…K…K…K„K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]q÷(K/K9K:KJK{K¦K£KÀKÛKìKáKÛKÛKÛKàKÍKmKFKMKGK_KÜKóK£KhKpKmKoKWK!KhKéKâKiKwKãKëKèKêKëKëKêKïKéK‰KJK@K2K,K3KQKK°KÚKóKúKùK÷KöK÷KôKìKßKÐK³K¹K¦KyK[KHKIKIKFKNKWKOKKKDKSK]K`KTK>KAK=K2K+K%KKKKKKKKK KRK#KK K K K KKKKK K'K)K)K#KKKKKKKKKKK/KjKK K KK KKK"K'K&K(K(K2KHKbKpKrKqKnKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKrKrKrKrKrKrKsKsKsKsKpKqKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKtKsKtKtKtKtKsKtKtKuKuKuKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvK]KHKJKJKJKJK-KRK`KZKTKJKTKXK‰KÕKÒKÓKÓKÐKãKõKíKKwK{KzKxKyKyKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKyKyKxKxKxKyKyKyKzKzKzKyK{KdK;K>KK?K@K@KCKCKEKGKFKHKIKKKLKLKJKMKTKWKUKnKÒKÜKÚKÚKáK®KKƒK‚KK€K‚K€KK„K·KÎK¬KŸK­K¼KÁKÐKÍKÂK¾KÌK­K‹K¥K KpKKK—K‰K‚K„KƒK‚K‚K‚KƒKƒKƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒKƒKƒK‚KƒKƒK„K…K„K„K…K…K…K„K‚K„K…K…K…K„K„K„K…K…K…K…K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]qø(K)K4K=KJK{KKªKÈKâKèKÜKÙKÞKßKÚKáKËKmKHKEKxKêKéK‹KjKoKoKnKrKXK"KgKêKçKmKtKàKëKêKìKìKìKêKîKìKKiKcKQK>K1K-K2KLKuK¦KÓKïKöKõKñKíKïKùKëKêKÜKxKTKHKIKIKGKPKWKNKIKKKZK\K_KRK?KCK>K4K.K)K$K!KKKKKKK K9KKK K K K K KKKK!K"KKKKKKKKKKKKKK(K[KK!K K K#K%K'K)K&K.K@KWKjKrKsKpKpKpKqKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKrKtKqKpKsKtKtKsKsKsKsKpKqKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKuKuKsKsKsKsKsKsKsKsKtKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKxKfKIKIKHKLKMK3KGK_K[KUKMKPKYKrKÌKÓKÒKÓKÐKÚKòK÷K­KuK|KzKxKzK{KyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KyKxKxKxKzK{K{KzKzKzKzK{KtKFK;KKK>K:K9K6K5K7K8K7K9K:K:K9K8K8K8K8K8K8K8K8K6K4K3K2K3K2K1K6KFKIKIKHK;K(K&K#K K!K KKKK K'K,K0K4K6K;K=K>K?K>K?KAKBKGKHKFKHKHKJKMKLKJKKKRKWKWKTK¥KäKÛKÜKßKÏK‹KKƒKƒKK„K€KƒK“K«K¯K£K™K®KÁK¯KÖKÞKÏK´KËK©KšK°KºKK„K‘K¥K¥KŠKƒKƒK‚K‚K‚KƒKƒKƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚KƒK…K…K„K…K„K‚KƒK…K…K…K…K…K…K„K„KƒK‚K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]qù(K%K3K@KGKgKˆKÁKÉKåKæKÑKÇKÁK¾KÅKÄKÛKÌKiKCK–KóKÛK\KcKrKmKoKoKrKYK"KfKÝKÔKoKsKäKîKçKëKìKìKêKíKæK™KqKxKoKdKUKDK5K,K0KCKnKžKÎKíKøKõKñKàKìKÈKpKOKGKIKHKGKTKVKOKIKMKZK\K^KNK?KBK=K5K2K/K*K&K"KKKK KKKKKK K KKK KKKKKKKKKKKKKKKKKKK*KSKKK"K%K'K%K&K5KMKdKpKsKqKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKrKsKpKpKpKpKpKpKpKpKpKpKrKtKsKsKsKsKsKsKsKsKsKsKsKsKtKsKrKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKtKuKuKuKuKuKuKuKuKtKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKkKIKHKIKIKKK9K9K_K]KVKOKLK[K`K»K×KÒKÓKÒKÔKïKùKÉKxK{KzKzKzKzKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKzKzKyKyKzKzKzKzKzKyKzKzKzKzKzK}KVK;K>K>K?K2K8K;K7K5K4K9K;K=KK?K?K?KAKCKDKFKGKGKGKIKIKKKLKKKNKTKUKUKpKÓKÜKÜKÛKÞK­K~K…K‚K„K„KKŒK€KˆK€KnKqKˆK‰KK¥K¿KÊK¯K›KuK›K¦K°KªK…K|KŽKœKŽKƒK‚K‚K‚K‚KƒKƒKƒK‚K‚K‚K‚K‚KƒK„KƒK‚K„K„KƒK„K„K„K„K‚KƒK…K…K…KƒKƒK„K…K„K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]qú(KK$K:KEK;KwK±K¸KæKÐKKnKfK[KgKlKKÞK²KaK°KúKÈKIKBKfKqKnKnKnKrKXK4K–KÛKäKrKuKåKìKéKëKëKëKêKîKæK™KmKtKsKuKrKiKYKIK8K.K0K@KcK“KÂKãKÜKïKÃKgKLKHKIKGKHKVKUKOKHKMK[K]K^KJK?KBK=K6K3K0K*K(K&K!KKKKKKK KK KKKKKK KKKKKKKKKKKKKKKKK"K5K#K$K%K&K,K>KWKkKrKqKnKnKpKpKqKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKsKsKpKpKpKpKpKpKqKpKpKpKrKtKsKsKsKsKsKsKsKsKsKsKsKsKtKrKrKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKuKuKuKuKuKuKuKvKuKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKsKPKGKIKHKKKBK7KZK]KWKOKIKYKXKŸKÙKÑKÓKÒKÒKéK÷KãK„KyK{KzKzKzKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKxKyKzKzKzKzKzKxKyKzKzKzKzK}KgK@K>K>K?K8K0K5K6K:K;KK?K>K>K@KCKDKFKGKFKGKHKHKKKMKKKLKRKTKYKWK£KÞKÚKÜKÝKÖKKK‡KK•K”KqKnKdK`K`K`KoKbKzK¢KµKÔK±KžK„KKÊKÍK¹KKKŒK›K”K„K„K‚KƒKƒKƒKƒKƒK‚K‚K‚K‚K‚KƒK…KƒK‚K„K„K‚KƒK„K„K„KƒKƒK…K…K…KƒKƒK„K…K„K„K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K„K…e]qû(KKK0K>K!KUK}K™KÂKK7K:KK?K:K0K:K=K=K=K=KK:KTK®K¿KÃKáK…K=KRKFK@KfKrKoKrKlK‡KìKàK‚KàKëKqKqKÝKìKèKèKëKíKëKîKçKœKnKqKqKpKpKpKrKsKsKlK`KOK;K)KK#KhKiKFKGKGKGKHKPKPKKKBKOK]K`K_KIK?KBKK>K5K:KK=K=KAK@KAKEKFKFKGKJKJKKKKKLKLKNKSKWKXKWK§KÞK×KÙKØKÉK®K¤K—KnKXKIK/K?KAK2K.K2KUKJK?KNK{K‰K•K…K K·K¯K´K¨K¬KÇKÈKÑKÈKŒKƒK†K„KƒKƒKƒK‚K‚K‚K‚K‚K‚K‚KƒK„K‚K‚K‚KƒK„K„K„K„K„K…K…K…K„K„K„K„K„K„K…KƒKƒK„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]qý(KKKK)K>K5KdK¬KšKIK5K:K8K9K9KK>KKKAKBKDKGKFKFKHKHKJKLKLKKKNKTKVKUKtKÏKÕKÖKÑKÁK¦KKnKJKHK:K%K2K*K"K"K1K0K"K%K8K>KBKGKK"K"K K)K4K=K;K7KƒK KwKtKmKTK?KJKLK=KK>K?K>K>K=KKIKIKKKHK-K&K%K%K!K KKKKK$K+K/K5K7K9K;K=K=K?K>KAKCKDKGKEKAKHKHKJKLKLKKKLKPKQKZKYK­KÞKÓKÉK¬KžKeKRK7K3K+K+K/K)K"K"K#KKK$K*KKK&KK5KQKwKlKKuKgK•K´KÈKÐK•K‚K…K„K„K…KƒK‚KƒKƒK‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒK„K„K…K…K…K…K…K„K„K„K„K„K…K„K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K„K…K†K…K…K…K…K…K…K…K…K…K…K…e]qÿ(K/K&KKK=KFK½KöK·KKKK K K!K6K?K7KvK´KÌK¦KgKmKSKBKFKGK?K>KfKnKhKqKsKtK\K%K7KK|KK;K6K9K@K?K?K?K?K?K>KKAKDKDKFKGKGKGKHKJKLKKKKKMKNKOKWKVKyKÕKÙKÀK¥KyK5K.K(K(K-K4K4K)K%KKKKK!KKKKKK#K7K\KgK”K›KyK“K½K´KÑK®K…K†K…K…K…KƒK‚K„K„K‚KƒK…K…K…K„K„K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K„K†KˆK†K„K…K…K„K„K„K…K…K„K…e]r(K-K-K&KK6KXKÕKõK K*K4K2K9KHKYKmKKMKXKÉKòK¥KRKsKqKVKCKEKCK?K@KaK™K§KKnKsK]K&K*KnK|KHKMK©K¶K¥KšKK†K}KsKoKpKoKqKoKoKpKpKpKoKoKpKZKXKrKUKDKGKHK8KCKWKOKKK?KKK`K`KZKKKKKFK5K0K0K/K-K+K'K$K"K.K-K)KK +KK K K KKKKKKKKKKKKKKK!K!K"K$K&K%K6KJK]KqKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKsKsKsKrKqKpKqKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKuKtKsKuKuKsKtKuKtKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKxKvKuKvKvKuKuKuKvKxKaKHKIKIKHKIKLKRK\K[KVKLKMKXKfKÅKÖKÒKÓKÒKÖKïK÷KÆKwK{K{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK}KkK>K?K?K@KK>K>K>K=KK?K?K?KBKDKDKEKGKFKHKJKLKKKKKLKLKRKVKXK]K°KÞKºKˆKBK&K&K#K(K.K1K2K*K%KKKKKKKKKKK KHKXKvK›KÂK±K¼K×KËKÎKÊK‰K„K…K…K…K„K„K„K„K„K„K„KƒKƒK„K„K„K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K„K…K‡K‡K‡K…K„K…K…e]r(K(K)K)K)K0KuKæKïKK9KQKgK„KŸK°K¼KÃK KwKÙKöKKAKpKpKnKVKAKCKJKKOK_K`KZKKKIKBK4K0K0K.K-K+K'K$K"K.K.K.KK +KK K K KKKKKKKKKKKK!K"K#K%K%K%K%K&K(K7KKK^KqKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKtKsKsKqKpKpKqKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKvKtKsKuKuKsKtKvKtKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKyKwKuKuKuKvKvKvKuKxKjKKKIKIKIKHKLKOKYK\KVKNKHKYKYK¯KÙKÑKÓKÒKÒKèK÷KàK‚KzK{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{KyKMK>K?K>K?K6KK?K?K?K?K?K?K?K=KK?K?K>KBKDKCKDKFKGKHKJKKKKKKKLKJKOKUKYKWKyKÔK£KRK4K&K)K)K,K(K)K-K+K!K KKK KKK!KKKK#K:KPKoKK¥K¢KÀK×KßKßKàKœKƒK…K…K…K…K„K„K„K„K„K„KƒK‚K„K„K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K„K…K…K…K…KˆKˆKˆK†K„K…K…e]r(K+K+K*K*K&K’KðKãKjKdKK¯K¼KÃKÆKÄKÍKÇK«KäKïKsK9KiKqKnKnKRKFKIKAK{KíKêKKoKsKrKtK`K%KQKÜKåKwKjKÝKîKèKëKêKèKèKèKàKŸKqKtKqKpKpKoKnKnKVK]KmKJKDKCKHK5KLKTKMKJK=KQK`KaKZKLKJK@K3K1K.K+K-K+K'K$K$K1K0K/KK +KK K K KKKKKKKKKKK#K$K$K%K'K(K)K(K+K(K8KKK^KpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKsKsKtKrKpKpKpKpKqKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKuKuKuKtKsKuKuKsKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKxKxKyKxKxKxKxKxKxKxKvKvKqKNKHKIKHKHKKKEKUK]KWKPKIKVKWK“KÙKÑKÓKÓKÑKâKôKñK˜KxK|KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K~K\KK9K9K?K>K>K>K>K>K?K>K9K;K=K?K>K=K=K=K=K=K=K=K=K;K9K9K:K8K4K4K5K4K4KEKLKKKKKBK*K)K&K#K#K KKKK!K*K2K3K4K8K9K;K?K>K>KBKAKBKEKEKHKIKIKIKKKLKLKKKLKQKVKWKVK§K„K4K3K%K+K'K'K&K)K)K&K$KKKKKKKKKKK#KK>K?K@KCKBKDKEKHKIKHKHKKKLKKKLKIKMKVKWKRKnKaK4K3K,K*K$K'KK K"KK#KKKKKKKKKK$K3KJKYKmKŸK²K–K«K¬K£K²K×KÆKK…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K‡K‡K…K…K…K…K…K…K†e]r(K$K#K!K5KVKÍKñKÏK¶KÌKÉKÎK×KØKÔKÕKÓK¾KÁKòKÍKCK4KQKrKpKpKrKkKSKJK®KóKçKäKåKÙK˜KpKrKwKdK+KdKÖKãK…KmKÞKòKéKëKíKíKïKóKàK‰KnKpKqKpKqKiKdKŠK^KFKFKGKDK6KPKSKMKGK=KYK_K_KTKMKLK;K-K-K.K+K(K&K&K#K$K0K2K3KK K KK KKKKKKKK$K&K#K&K(K'K+K*K*K*K*K,K-K.K=KMK`KsKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKtKqKpKpKpKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKyKxKxKyKwKuKwKyKxKxKxKxKxKxKxK{KaKFKIKHKIKKK/KBK]K[KUKMKMK[KdKÀKÕKÒKÓKÒKÖKïK÷KÐK}K~K~K{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{KzKPK@KBKAKBK:K>K?K>K?KBK@K>K@K>K>K?K?K=K;KKZK^K^KRKMKNK:K-K-K,K*K(K'K&K#K%K2K2K1KKK K K KKKKKKK"K'K)K(K*K,K,K,K-K/K.K.K/K0K0KAKNKaKrKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKtKrKrKrKrKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKtKtKsKtKtKtKtKtKtKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKwKwKwKwKxKxKxKxKxKxKwKxKxKxKxKxKxKxKxKxKzKhKFKIKJKIKKK7K6K^K[KXKPKIKZKZK§KØKÑKÓKÓKÒKèKöKèKŠKzK~K{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK}KbK>KBKBK@K9K9K=K?K@KBK@K>K?K>K>K?K?K?K?K=K=K?K>K=K=K=K=K=K:K:K:K8K8K4K/K5K4KDKNKKKLKHK.K&K&K%K#K"K KK K!K(K0K3K5K7K:KK?K?K>KAKBKEKEKHKGKIKLKKKKKKKLKKKNKTKXK\KPKAK7K7K4K*K-K1K"KK"KKKKKKKKKKKK*KcKKŒK|K™K¯KªK·KÂKÆKÑKÃK„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K†K†K…K…KˆKˆKˆK‡K†K‡KˆKˆKˆKˆKˆKˆKˆKˆe]r(K,K+K4KKK€KÎKÐKŽKtK~K‚K‚K€K¡KÄKÏKÌK§KÖKøKŽK K/K6KbKqKpKqKpKqKwKØKòKíKíKîKíKïKëK¢KqKvKqK¥KõK¼KÙKùK‡KjKÛKîKæKëKíKïKÛK‘KVKgKrKoKrKeKVKhKZKEKGKHK>K7KVKQKJKBK@K[K^K]KRKMKMK6K,K-K*K*K)K'K&K"K&K4K2K/KKK K +K KKKKKK#K%K)K)K)K+K.K.K.K.K0K0K0K.K1K3KCKPKbKrKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKtKsKtKtKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKvKtKsKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKxKyKyKyKyKxKxKxKxKxKxKyKxKxKxKxKxKxKxKxKxKyKqKKKIKLKIKJKAK/KWK\KXKQKHKVKUK‰KÖKÑKÓKÓKÑKàKôKôK¢KxKK{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{KpKEKBKCK>K7K7K?KBKBKBK@K>K>K?K?K>K>K?K?K=KKKAKBK?K@KAK?K>K>K>K>K?K?K>K>K?K?K>K>K>K=K=KKAKBKDKEKGKGKEKGKHKIKJKLKKKJKOKQKYKPKDK>K:K/K-K9K7KMK4K%K&K(K#KKKKKKKKK KMKLKtKK›KŸK«K¬KK¥K¤KºK K~KK„K†K†K‡K†K…K…K„K‚KƒK„K„K„K„K…K…K…K…K…K…K…K…K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K‡K‡K„K…K‡K†K…K‡K‡KˆKˆKˆK†K…K‡KˆKˆKˆKˆKˆKˆKˆKˆe]r(KKK@KBK@K>K?K?K>K?K?K?K?K?K?K?K?K?K=K=K=K=K=K;K9K9K6K4K5K3K>KLKKKLKLK6K'K(K'K%K$K#KKK!K&K-K0K7K8K9K;K?K@K>KBKBKCKEKGKFKGKHKIKHKIKLKLKLKLKJKUKTKIKKAKAKAKBKAKAKAKAK?K?K?K?K>K?K?K?K>K=K=K=K=K=K=K;K8K9K6K4K5K4K7KIKKKKKMK?K(K(K&K$K#K$K#KKK$K,K/K2K6K9K;KKAKBKCKEKGKGKGKHKIKKKLKKKKKLKKKOK\K^KGK7K8K-KK/KAKDKMK$KK$K(K(K%KKKKKK8K‘KÃKêKKÿK÷KóKïKèKîKôKãKÒKÑKØKÎK”K}KiK\KWKVK^KcKfKjKtKwKtK|K†K…K„K„K„K„K„K„K‡K†K‡K…KƒKƒK„K…K…K„K„K…K…K…K…K…K‡KˆKˆK†K„K†KˆKˆK‡K„K†KˆK‡K‡K…K…KˆKˆKˆK‡K‡KˆKˆKˆKˆKˆKˆKˆKˆKˆe]r +(K2K;KPKˆKàKáKÑKÈKÏKËK¼K±K˜KK]KpKjK•KµKwK+K1K0K2K1K^KtKpKtKrKpKxK»KóKíKíKíKíKîKìKõKšK[KÑKãK’KpKfK'KFKÈKíKzKIKžK²KŠK[KLKNKHKDKHKLKRKYKIKCKCKFK5KEKSKMKIKK>K?K?K?K?K?K?K>K=K=K=K=K=K=KKK?K?K?K?K?K=K=K=K>KK)K)K(K%K"K"K!KK#K(K+K.K1K6K:K;KCK@KAKEKDKDKCKEKGKHKIKJKKKKKMKNKLKJKQK^KLK8K=K.KK/KOKIKQK>KK,K4K/K"KK"K1K†KÍKõKäKäKßKËKÁKÄKÌKÓKØKÖKÖKÜKáKîKõKóK‹KtKËKËKÃKàK½KŠK„KK_KK +KKYKŠK‡K„KxKhK^KMKCKUK^KnKxK~K‡K‰K‡K‡K‡K„K…K…K„K„K„K…KˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆK‡K‡KˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆe]r (K¹KÖKÐKÍKìKåKÏKÒKÒKÐK×KÔKÐK¿KK3KlKêKíKmK$K/K5K7K3KMKsKqKsKtKÄKÙKÂK¾KÈKÑKÉK¨KÍKàKàKgK`K{KoKrKrKpKsKcK%K KVK`K:K.KGKPKMKLKHKFKKKEKCKIKIKEKCKEK4KLKRKMKJK:KMK^K[K]K^K[KOK2K(K$K$K'K%K#K$K!K-K5K5K,KK K KKKKKK K%K)K.K1K1K3K5K7K7K4K6K9K8K7K9K9K;KLKTKeKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKtKtKsKsKsKtKuKuKuKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKwKxKxKxKxKxKwKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK|K[KGKKKJKGKJK/KCK^K[KUKMKLKYK]KºKØKÑKÓKÓKÑKéKóKãK†K|K~K}K}K|K|K|K{KzKzKzKzKzKzKzKzK|K{KzK{K|K|K|K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KvKFKAKDKCKCK;K@KBKBKBKBKBKAKBK@K@K@KAKBK@K@K?K>K?K?K?K>K=K;KKKMKLKKKLK:K)K'K%K&K%K$K#K K K'K+K.K0K5K:KK?K?K?K?K?K>KKCK>K@K;K@KCKAKBKBKBKBKAKCKAK@KBKBK@KBKAK?K?K?K?K?K?K>K=K=K=K:K9K8K8K8K5K@KMKLKNKMK5K(K)K&K%K$K#K K!K$K'K.K1K5K:KK?K?K>K?K?K=K=K;K8K8K6K5K5K9KLKMKKKMK?K)K)K)K&K%K&K#KK!K'K+K/K3K8K:K=K>KDKGKCKBKBKDKGKGKGKDKFKMKKKMKMKMKQKKKIKSKiK˜KÄKûKÎK¥K´K¾KÎKåKóKöKòKüKéKÜKéKøKûKúKæK¯K KµK¾K¾KÂKÇKØKöKóKâKßKåKøKKKAK:K)K K K#K)K7KGKfKK”KkKIK%KKKKKKKKK6KKKVKeK€K‘K“KK”KŽKŠK†K„K„KˆK…KˆK‹K…KˆKŠK‰K‰K‡K‡K‡K‡KˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆe]r(KwK‡K¿KéKÚK¼KÅKËKÇKÂK°KdKK KKmKêKóKpK!K/K.K/K2K3K6KgKuKvKÑKðKíKïKëKíKíKìKìKéKóK†K[KÐKÀKWK9KBK/KUKsKoKpKqKlKIKBK'K-KCK0K$K3KIKDKGKAKDKCKCK?KDKNKLKGKBKOKXKZKZK[K\KbKXKRKaK^K]K^K`K_K_K_K_K^K^K[KKK/KKKKKK!K%K*K,K0K3K5K5K9K8K7K:K:K:K:K:K=K;KIKrKSKfKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKuKtKtKsKsKsKtKtKsKsKtKtKtKuKuKtKtKtKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKvKuKuKuKvKxKvKuKvKvKvKvKvKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKyKxKxKxKxK{KbKGKIKGKGKJK7K5KZK[KYKRKGKUKTK•KÚKÑKÒKÐKÎKßKóKöK«KyKK~K}K}K}K}K}K{K{KzKzKzK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K|K€KjKBKDKCKEK@K8KBKCKBKBKBKBKAKBKBKAKAKAKBKBKBKBK@K?K?K?K?K?K?K=K=KKDKHKDKBKBKDKFKFKGKGKJKLKKKLKMKOKIKGKaK‘KÔKÍKÑKüKëKšK¤K³K²K°K·KÍKåK÷KõKçKäKùKýKìKõKäK§K˜K­K½K½K¼KÆKÕKõKèKÖKáKïKK¢KK0K;K3K,K&K&K"KKK'KgK›K«K¥KƒK'KK KKK K K +KK"K,KKKcKzKK¤KœKK‡K‚KxKzK}KmKmK‰KKKK„KŠKŒK‹KˆK‡KˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆe]r(K¡KšK¹KÒK·KŸK¯K¶KÁK¤KUKKK KK‡KïKâKJKK*K-K0K2K6K9KbKsKKÝKóK¾KÖKñKêKëKëKëKëKðKtK[K…K^K>KK?K=KK0K#K1KGK>KBKDKCK>KEKNKJKFKDKPKXKZKWKEKPK`KQKVK_K]K^K^K^K_K`K`K`K`K_K^K^K\K]KaK`K\KOK@K1K+K,K0K4K6K9K:K;K;K=K=K=K=K=K>K=KJKqKTKhKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKtKtKtKtKuKuKtKtKtKuKuKtKtKuKuKuKuKuKuKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKwKuKuKuKvKwKwKvKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KzKyKyKyKyK{KvKOKHKHKIKJKJK+KMK\K[KWKKKMKWKgKÇKÕKÒKÐKÐKÑKìKöKàK†KKK}K}K}K}K}K}K}K|K|K|K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K€K[K@KDKDKDK=K=KCKCKBKDKCKBKCK@K9K>KBKAKBKBKBKBKBK@KAKBK?K?K>K=KKBKGKHKEKCKCKCKDKGKFKHKKKLKJKJKKK`KK–K”K‘K“K®KçKþKöK®KŒKžK®K±K´K²K¨K®KËKÚKåKïKýKïKÍK´KàKÉKœK§K±K¯K»KÃKßKòKÙKåKüK·K(K K KKK%K'K(K'K&K$KKKKBK†K«K KpKLK4KKKKKKKK K +K KK4K‹K¹K£K“KK‰KtKaK}K·K¸KKfKQKcKƒKyK€K‰K‰KˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆe]r(K KUK}KrK_KKKQKRKK KKKKK"K}K¡KxKKK"K#K*K-K0K2KYKpK“KâKÛK„KnKŠKÕKíKäKÞK×KªKIKRKHK\KpKHK2K2K0K7K*KJKtK^KAKCKkKcK!KK2KJK8K!K#K>KGKDKBK3KCKNKIKGK>KJKZKXKSKK*K8K=KXKdKaK]K\K\K_K`K`K`K`K`K`K^K\K\K[K\K]K_KaK[KQKDK;K6K5K8K:K=K=K=K=K=K=KKIKlKSKhKrKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKvKvKvKvKuKuKuKvKvKuKuKuKuKuKuKuKuKuKuKtKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKyKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzK{K{KzK{KzKxKXKHKHKJKLKNK0KBK]K[KYKOKNKXKYK®KØKÑKÐKÐKÎKãKóKñKšK{K€K}K~K}K}K}K}K}K~K~K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KKkKCKCKDKCKAKK?K?K=K;K9K:K:K9K9K4K?KNKOKNKMK6K)K+K)K&K&K&K"K!K%K)K,K2K6K8K=K@KEKHKFKCKDKDKDKGKFKHKKKLKKKQKŠKK€K’KœKšKšKšK¼KìKýKöKÏK¡K”KŸK£K­K²K¥K¢KÃKßKäKôKÿKèK±K¼KéKÍKKžK¦K«KÀKÀKêKëKãKüK¼K1KK KKKKKK"K$K"KKKKK2KbK¦K•KVKHKRKEK$K KKKKKK0K6K&KGK¨K·K­K°K©K–KoKcKK·K©KœK–K‡K¥K­K„K„K‡K‡KˆKˆKˆKˆK‡KˆKˆKˆKˆKˆKˆe]r(KKŒKÉK KOKEKLK'KKKKKKK3KmKlKBKK!KK K$K'K0K1KWKrK…K±K£KvKtKqK‚KµK¾K£KƒK\KBKOKFK_KuKlKFK2K'K(K5K%KMKZKAKHKkKvKaK$KK[KgKKKCKEKBKAK-KDKPKIKFK9KHKVKYKQKKFKHK@KCKIKSK[K^K_K^K_K_K`K`K_K]K]K]K_K_K_K^K\K\K]K^K_K\KVKIK>K;KK@KCKDKBKBKDKCKCKCK@KAKBKBK@KBKBKBKBKBKBK@K>K?K?K>K>KK>KHKhKSKiKvKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKuKuKuKsKsKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKyKxKxKyKxKuKwKyKxKxKuKvKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KyKxKzKzKzKyK{KlKFKHKIKHKJKAK0KXK\KYKRKKKUKUKuKÒKÓKÐKÐKÎK×KïKõKÒK~KK~K|K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K|K€K^KBKDKCKK?K?K?K>K=K;K:K6K5K9K7KFKNKNKMKKK5K)K)K(K%K$K$K!K K$K*K-K3K9K;K=KAKHKIKIKGKDKDKGKFKIKJKIKgK‚KxK|K‚K‡K•K—KK—KœKÖKõKóKðKôKîKŸKKƒK†K”K§K§K¤KÐKßKÜKûKÙK£K¸K¶KäKÃK€KœKµK¿KµKÞKæKKwK@K K K +K KKK KKKKKKKKK +KK^K›KEKK K KKK&K9KŠKÀKªKŠK'KKCKžK˜K‰KžKªK§K¢K­K±K®K¬K”KsK‘K–K{K‰K¥K—K…KˆKˆKˆKŠK‰KˆKˆKˆKˆKˆe]r(KrKÝKõK†KKKKKKKKKKK}KçKØKLKK%K$K!K#K%K'K,KHKqKOKBKaKvKsKsKsKsKeKHKGKAK@KJKFKgKvKpKrKoKHK0K)K/K.KJKvK‹KuKpKoKtKdK1K4K&K;KEKBKBK>K.KMKNKIKEK8KLKWK[KMKK+K@KRK\K\KXKRKHKAKCKKKVK\KaK]K\K\K]K]K]K`K`K_K_K_K_K_K_K^K\K]K]K^K\KUKOKFK>K:K;K=KHKfKSKjKuKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKuKuKsKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKxKuKvKxKwKuKxKxKxKxKuKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKzKzKzKzKzK{KuKMKHKHKIKIKHK.KPK\KZKWKNKOKWKcKÃKÕKÒKÒKÏKÐKëKöKçKK~K~K|K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K€KqKDKCKEKAK@KK>K?K?K>K=K;K9K;K:K8K6K=KNKNKMKOK?K)K+K*K(K%K%K$K"K$K'K,K0K8K;K=K@KDKHKIKIKEKEKGKFKIKHK[KwK}K{K{KƒK„KŒK“K—K˜K›K¿KóKõKîKíKåK«K†K…K~K|KŒK¤KªK§KÓKÚKÙKõK¸K®K¾KµKÞK·K~K›K³K¸K·KîKÀKKDK+KKK +KKKKK KKKKKKK K +KKlK}KK KK KKK K+KwK¬K³KfK +KK`K¢KKK¦K¦KKšK«K¨K§K©K‡KqK–KKrKlKœK˜K‡KˆKˆKŠKŠK‰K‰K‰K‰K‰e]r(K¶KâKðKfK KKKKKKKKK!K¥KôKÔK6KK$K#K%K&K&K)K*KDKkKIKGKhKtKrKsKsKrKuKfKJK:K@KHKIKnKuKrKpKtKmKEK-K+K0K„KßK¸KoKsKpKpKuKcKGK5KGKCKBKBKKEKcKSKjKuKsKsKsKsKsKsKsKsKsKsKsKsKtKtKsKsKtKtKsKsKsKuKuKtKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKvKxKxKvKvKyKwKuKwKxKxKxKvKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKyKyKyKzKzKzKzKzKzKzKzK|KVKGKJKMKOKTK4KBK\K[KXKOKNKYKVKªKÙKÑKÒKÐKÍKàKôKôK¦KzKK}K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K|KQKAKEKEKEK=K@KDKCKDKDKDKCKCKDKDKCKBKBKBKBKBKBKAKAKBK?K?K?K?K>K=KK@KBKDKHKIKIKHKFKGKEKSKzK‚KK{K{K„K‚KˆK‘K”KœKŸK£KÇKãKîKñKãK K•KK„K|K|KˆK£KªK¦KÊKÑKÝKîK¹K·KÂKºKÛK»K€KK¯K©KÎKëKŒKGK0KKK +KKKKKK K KKKKK KKKK^K7KK K K KKKKK^K¢K¤KMKKK}K KK˜K©K™K“K¤K¤K¥K¦K¡K‚K‰K›KK‰K¥K§K’K‡KˆKŠKŠKŠKŠKŠKŠKŠe]r(KÊKéKâKCKKKKKKKKKK/KÀKôK´K$K$K$K$K%K(K)K'K)K?KaKDKIKkKrKoKsKsKpKpKsKiK>K@KFKNKqKtKsKtKpKrKmKBK-K7K¶KK§K@KuKqKpKrK_KEKEKIKAKAK?K8K4KPKKKGKCK9KPKVKXKDK*K+K(K&K"K K&K5KJKXKXKZKXKQKFKCKDKNKYK^K_K]K]K_K`K`K`K_K`K`K`K^K\K_K`K_K_K`K^K^KZKUKUK`KUKkKwKtKsKsKsKsKsKsKsKsKsKsKsKuKvKtKsKvKuKsKsKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKyKxKxKyKyKyKwKuKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKzKzKzKzKzKzKzKzKzKzKzKzK|KbKJKRKSKQKXK=K5K[K[KVKRKNKXKTKŒKØKÒKÒKÐKÎKØKïKøKÂKzKK~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KKaKAKCKBKFKAKKAKBKJKLKKKGKEKFKPKvK}KK„K~K{KƒKƒK‡KK–K›KžKžK®KÅKÐKàKéK¹KžK K™KŒKƒKKˆK¦K¦K˜K²KÆKàKóKÅK¼KÃK¹KÏKÈK‡KˆK¡K³KïK™KHK7K"KK KKKKKKKK KKK KKKKKKK +K K KK-KWK7K!K5KvK‘K™KLKK2KŽK„KvKžK¡K“K˜K“K¡K¤K¥KK‰KKUKdK`KYK•K“KˆKŠKŠKŠKŠKŠKŠKŠe]r(KÍKíKÈK)KKKKKKKKKK@KÊKàK‚KK%K"K"K$K%K'K)K)K;KUKEKLKoKrKrKsKsKrKrKrKuKhKNKCKSKtKsKtKsKrKpKsKnKAK>KÍKþK–KKHKsKtKqK[K@KNKIK@KAK@K4K9KRKJKGKAK:KSKVKYKFK0K1K,K(K'K&K!KK!K.KIKRKYK^K]KZKRKHKAKEKQK\K`KbK`K^K`KaK`K`K`K_K^K_K`K`K`K`K`K^K]K]K]K^K[KeKoKrKtKtKsKtKtKsKsKsKsKsKsKuKuKtKsKtKtKtKtKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKwKwKwKwKwKwKxKxKwKwKxKxKvKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKzKzKzKzKzKzKzKzKzKzKzKzK}KmKOKTKTKSKUKHK-KVK[KXKSKMKTKWKtKÑKÔKÑKÐKÏKÓKíKôKÞK†KKK~K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K~K~K~K~K~K~K~K~KKrKEKCKDKCKCK;KDKDKCKDKCKCKDKCKCKDKDKCKDKCKCKCKBKBKBKBKBKBK?K>K?K=K=K;K9K7K8K7K:KJKNKMKOKHK/K)K)K'K'K&K%K"K!K%K,K1K6K:K>KAKCKHKKKJKGKFKFKoKƒKwK}K†K€K{KK…K‡KŒK‘K˜KšK›KŸK³KÀK¾KÌKéKÛK¶K¡K™K•K‹K…KK©KœK‰KœK¬KÖKøKÏK¿KÅK´KÊKÑK¢K¡KºKÛKvKEK>K&KK KKKKKKKKK +KKK K KK KKK K +KKKKJK•K†KYKvK–KKK‰KyK‰K¢K’K—K™K—KKŽKKK—KKwKvKSKKK0K;K„KŸK‹K‡K‰KŠKŠKŠKŠKŠe]r(KÔKñK¨K!KKKKKKKK KKNK±K›KEKK%K!K K"K%K%K)K*K6KNKEKSKqKrKtKsKsKtKsKsKsKqKQKJKfKvKsKsKsKsKtKsKuKnK^KÍKäKpK3K,KEKrKqKWK@KHKFKAK@KAK4K=KTKIKGK?K9KVKVKYKDK4K2K)K&K&K&K%K#K#K'KSKK@KDKDKBKAKDKCKBKBKBKBKBK@K=K?K>K=K;K9K:K:K8K8KCKNKMKOKMK8K+K+K*K)K&K&K$K"K$K*K-K5K9K;K@KDKEKJKIKIKIKSK‚K„K}KK†K|KwK}K€K†KŠKŽK’K•K˜KœK¢K¯K¶K¶KÆKéKôKÚK²K™KŒKŠK…K’K©K“KŠKŠK•KËKëKÐKÁKÂK·K¹KÁK´K¥KšKXKKTKTKUK@K5K4K!KKK$K%K%K#K)K[KAKK$K%K2KDKUK]K_KNKJKMKCK@KHKQK]KbKaK_K\K]K]K^K`K_K]K^K]K\K]K_K^K\K\K\K_K^K_KbKgKmKqKuKuKtKtKtKuKuKuKuKuKuKuKtKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKxKwKwKwKwKwKxKxKxKxKvKwKxKxKxKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKzKxKyKzKzKzKzKzKxKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K|K\KQKVKUKSKPKHKPKZK[KUKOKKKWKUK¥KÚKÐKÐKÐKÌKÞKðKôK²KyKKK~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KK~K}K}K}K}K~KKKKKK~KK€K~KKcKAKDKDKDKAKK@KCKDKBKBKCKCKBKBKBK@K?KAK@K?K>K>K=KKLKNKNKOKBK-K*K)K(K&K%K$K"K#K'K+K1K5K8K=KBKDKHKFKIKLKsKK‡K{KyKƒK{KsKyK|K~KƒK‡K‰KŽK”K—K˜K£K©K§KªKºKÚKóKêKÍK™K…KK‰K KKKK‰K”K©K©KÄK½K½K²K KK~KiKYK;K-KK KK K +KKKKKKKK +K K K KK +KK KK KK KK KKAK5KEKbKsK{K„K‘KK“KžK¢K§K¥K¢KK¡KªKªK·KÇKÅK±KœK¡K£KK”KšK“K‡K‰KŠKŠKŠKŠe]r(KßKæKwKKKKKKKKKK$KGKCKK3K3KKKKK K"K!K,KXKAK+K;K8K)KKK1KGKUKZK]KZKSKIKDKBKHKSK\K`K^K\K]K`K_K\K\K]K]K]K`K_K\K]K]K_K`K`K_K_K^KaKgKmKsKuKwKuKuKuKuKuKuKuKtKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKxKyKxKyKyKyKyKxKxKxKxKuKwKyKxKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKzK{KzKzKxKyK{KzKzK{KzKxKyK{KzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K|KbKQKVKTKSKPKNKLKWK[KXKQKHKRKSK‰KØKÑKÐKÐKÏK×KîKõKÌK€K€KK~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K€K~K}K}K}K}K~KKKKKK}K~K€K}KKtKGKCKDKCKEK=KBKDKDKDKCKDKCKCKGKEKDKDKBKBKCKCKBKBKBK@K>KAKAK?K?K?K>K=K:K9K7K7K9KHKOKNKMKKK3K)K)K)K&K%K$K"K#K#K(K0K5K8K=KAKDKGKFKEKaK‹KŠKKuKsKK€KtKsKyKyK~K‚K€K†KŒK‘K–K›K£K¢KKK¥KÊKÎKÎKÌK…K{K…K—K K’KKK•K°KŒK­KÂK´KµK¦K–KŽKsK\KBK(KK K K KKKKKKKKKK K K K K KKKK KK +KK KKKK"K8KAKGKPKZKqK€KK†K‰KK˜KšK›K K¢K§K¹KÀKšKrKwKwKoKgKhK€K‹KK‰K‰KŠKŠe]r(KÖKÉKSKKKKKKKKKK%KIKFK7KKKKKK!K#K%K'K&KK>K-KGKPKHKFK9K?KWKVKUK=K5K2KKKKKK$K+K8KWKBK+K2K8K-KKKKKMKIKFKVK^K_K[KPKFKBKAKIKSK_KbKaK`K\K]K]K\K]K]K]K\K^K`K`K`K`K`K`K`K_K\K\K^KdKkKsKvKvKuKuKuKvKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKxKwKuKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKzKzKxKxKxKzKzKzKzKxKxKxKzKzKyKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK}KjKPKTKSKSKRKNKNKVK[KZKTKIKOKVKlKÎKÔKÏKÐKÐKÑKèKñKãK‰K|K€K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KKKKKKKKKKK~K~KKKKKKKTKDKDKCKCK=K?KFKDKDKCKCKDKDKDKDKDKDKDKCKBKBKBKBKBKAKAKBKAK>K?K?K=KK>K=K,KIKOKHKFK8KCKVKUKPK9K4K1K0K(KKKK!K/KEKXKAK,K(K*K&KK KKKZK@KK!K7KLKXK`K]KYKNK1K7KBKLKXK`K`K^K]K]K]K]K]K]K^K_K_K_K_K_K`K`K`K]K\K[K[KZK^KfKmKqKuKwKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKvKwKxKxKxKxKwKvKuKuKuKuKuKuKuKuKuKuKuKvKyKwKvKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKzKzKxKxKxKzK{KzKzKyKyKyKzKzKyKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|KtKTKRKSKSKSKOKOKTKZK[KXKNKKKXKYK»K×KÏKÐKÐKÎKâKïKðK K{K€K~K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KKKKKKKKKKKK~K~KKKKKKKfKDKEKEK?K;K=KCKCKCKCKCKCKCKCKCKCKCKCKDKBKBKBKBKBKBKBKBKAK?K?K?K>K=KK?KK?K?K>K:K:K:K7K5KCKNKMKMKNK:K*K+K)K(K&K$K"K K$K)K-K4K7K=KBKEKEKFKWKKK{KsKqKtK}KKwKsKvK~KKK€K~K|KK‹K”K˜KK¢KK”K¤KçK¹KK‰KKK~K–K”KŽKƒK˜K·K„KŽKÇK§K‘KK‹KKkKTK6K"KK KKKKKKKKKKKKKK +K K KKKK K K K +K +KKKKKÿKÿKKK K KKRKrKpKtKtKrKjKaKpK…KXK#K(KPKxK“K¤K¸KÁKÅK®K¦K—K‰KŠe]r!(K?K#KKKKKKKKKKKK>K@KKFKEKCKDKDKCKDKEKEKEKDKCKDKDKDKCKBKCKDKBKBKBKAK@K@K>K>KK"KKKKK KKK"K"K$KAKDK=K'K'K!K!KKKK K$K!K3K¤KÚK²KpKuKsKsKsKsKsKsKtKnKZKNK\KuKsKsKsKsKsKsKsKuKhKFK@KaKtKsKtKuKNK$K)KDKCK=K?K?K8K4KSKKKDK@K6KKKSKTKMK2K0K-K'K&K&K&KK K!K=KWK2K#K?KTKXKWKOK?KCKZKEK/K'K)K+K1K8K8K0KAKSKKSK\K^K^KWKLKEK@KAKOK[K`K_K`K`K`K_K\K\K\K]K]K]K]K]K]K]K]K]K]K\KZKYKZK^KdKmKvKyKxKvKuKuKtKiKWKPKIKIKBK=K;K5K9K7KBKWKjKvKwKuKuKuKvKyKxKtKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKzK{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K~K~K}K~KjKPKRKQKRKOKOKLKTK[KXKVKKKOKUKiKËKÔKÒKÓKÐKÏKåKïKèK‘K{K€K€K€KK}K}K}K}K}KKK}K}K}K}K}KKK}K~K€KKKKKKKKKKKKKKKKKK‚KhKCKGKGKGKDK9KDKEKCKCKCKCKDKGKEKCKDKCKCKDKCKDKDKDKDKBKAKAKBKBKAK=K>K>K:K9K8K8K9KHKNKQKQKLK4K,K+K*K)K(K%K$K#K&K*K.K2K:K?KBKGKGKEKIKkKƒKuKtKsKwKzKKyKsK~K†KƒKƒK}KxKzK}K…KŽK•KšK KŸK–K›KæKÃKvKwK‚KƒKxKŽKK‰KxK¤K©KkK|K~KnKxKwKvKrK^KAK(KK +K K KKKKK +KKKKKKKK K K +KK +KKKK K K KK +KKAKdKyKˆK{KgKKKKK7KtKŠKŠK‡K‹KŠKˆKƒKxK•KuK.KKKK KK K#K2K|K‰e]r#(K8KKKKKKKKKKK&KDKDK3KKK%K'K&K&K$K"K"K KJKÔKïK¬KmKuKsKsKsKsKsKsKuKlKGKCKaKvKsKsKsKsKsKsKsKuKdKEKAKfKvKsKsKsKsKCK.KIKDK=K?K?K4K4KSKKKEK@K5KMKTKTKGK/K/K-K'K&K%K%K$K"KKAKYK0K%KBKUKWKXKYKZKXKZKDK5K:K.K,K.K1K7K9KIK_K+KK&K2KGKVK^K_K]KQK7K>K?KDKPK[K`K_K]K\K\K]K]K]K]K]K]K]K]K]K]K]K\K\K\K]K[KXKYK]KdKlKrKvKvKpK]KMKFK?K?K8K6K=K9K4K0K,K:KIKZKoKxKvKvKuKxKxKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K|K|K{K{K{K~KrKSKRKOKRKOKNKPKWKYKXKVKLKKKXK[K¶K×KÒKÓKÑKÎKßKíKðK«KyK€K€KKK}K~KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€KxKJKEKEKEKFK:KCKDKCKEKFKDKDKGKEKCKCKCKDKCKDKCKDKCKBKCKCKCKBKBKAK@K@K=KK6K6K9K2K6K9K4K-K0K/K7K9KGKPKhKwKtKuKxKvKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K~K|KzKzKzK|KyKXKQKOKRKOKNKPKQKYK\KXKOKHKWKSKšKÚKÒKÓKÑKÎKÙKêKðKÆK}K€K€KKK}K~K€KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€KYKBKDKCKGK@K=KGKCKFKGKDKDKGKFK@K=KGKCKCKDKCKDKBKAKCKDKDKCKAKBKBK@K=K=KKBKEKGKHKJKwKKoKqKtKwKyK|KwK{K‚K„K€KK{K{KzKyK}K…KŽK”KœK K—K”KÞKâK€KwK€KqKiK‚KˆK„KpK KŠK^KmK[K_KhKjKkK`KKK-KK K K K K K K KK KKKKKK K K K KK K K K K K K K K K K K KKK K'KRKˆK¢K„KDK8KbKzK€K†KŠK“KqK`KiK`KKŸK›K£K¯K®KwKtKKŠe]r%(K#KKKKKKKKKKK0KEKIK-KK KKKKKK#K(K"KyKåKÍK‚KrKtKsKsKsKsKtKsKvK`KBKEKkKuKsKsKsKsKsKsKsKuK[K?KGKoKuKsKsKtKnKPKCKEK@K>K?K>K0K;KQKHKCK>K9KPKRKTKCK3K4K.K&K&K&K$K"K$K!KGKUK*K(KEKQKUKXKYK[KXKXKBK-K1KFKVKRK5K+K)KGK\K=K5K?KAK?K:K2K/K1KFKSKYK^K\KVKOKFK=K?KEKSK^K]K\K[K[K]K]K]K]K\K[K[K[K[K[K[K[K[K[K[K[KZKYKZKZKSKHK@K;KK=K;K9K9K8K7KEKNKOKPKOK;K,K-K+K)K&K&K%K#K#K'K,K2K8K:K?KDKGKGKJKvKƒKpKpKrKuKvK{K{KwK}K…K„K|K{K{KyKyKzK}K‡KŽK–KœKžKŒK®K÷K¿KsK|KrKdKoK…KƒKuKuKqKOKgKeK^KaKfKaK\KNK1KK KK K +K +K K K KK +KKKKKK K K KK KKK K K K K K K +K K K K K +KKKKOK‰K¡K†KmKoKtKiKlKƒK–K¦K³K¼K¿KÂK½K²K«K°K£K—K„Kˆe]r&(K%KKKKKKKKKKK=KnK‡K=KKKK KKK +KKK"K€K¹KKuKuKsKsKsKsKsKsKsKtKZKCKJKpKtKsKsKsKsKsKsKsKtKTK?KLKrKtKtKsKuKkKNK@KFK?K>K>K>K.K@KOKGKDK=K>KTKQKTKBK4K8K0K&K&K&K%K"K$K"KIKTK*K+KIKTKWKWKYKZKXKWK>K(KKK'K4K0K+K7KPKYK>K0K6K=K>K=K?K@K9KDKTKK@KHKUK[K^K^K\K\K\K\KZK[K[K[K[K[K[K[K[K[K[K[K[K[K\K\KYKVKPKDK?K2K.K1K7K6K5K5K:K3K0K0K0K7K)K.KHKdKwK|KyKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKyKzKzKzKzKzKzKzKyKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K{KzKzKzKzKzKzK{K~K}K{K|K}K{K{K}K}K}K}K}K{K}KhKQKSKSKRKQKNK@KVK\KZKSKJKPKXKfKÆKÔKÒKÐKÐKÏKäKïKêK—K|K€KKKKKKKKKK}KKKKKKKKKKKKKKKKKKKKKKKKKKKK‚K|KMKEKGKFKFK=K@KEKEKGKGKGKGKFKDKDKDKDKDKDKDKDKDKDKDKCKBKBKBKBKBK?K>K=KKMKPKQKQKEK.K,K+K*K*K'K%K$K$K&K+K2K7K:K?KDKFKGKHK`KKrKpKrKsKsKwK}K{KzK„K…K|K{KzK{K|K{KzK€K‡KK”KK˜K”KÝKöK–KoKoKhKcK{KƒK|KlKWKJKXKmKiKaK^KWKUKPK3KK +K K K K +K K K K KK KKKKK K K KK KKK +K K +K +K +K +K +K +K +K +K +K K K KKKKOK†K“KƒKyKkK]KiK‚K¥K¸KºK®K²K¶K¸K¸K¹K½K­K‚K†e]r'(K$KKKKKKKKK KKkK½K¾KKKSKRKSK@K7K9K0K(K(K%K"K K$K$KOKRK)K+KJKUKWKXKWKWKXKXK=K+K0K%KKKKK0KSKXK=K9K7K,K2K:K=K=K8KLK^K/KK2K1KAKRKYK\K\KXKOK4K3KAKJKTK]K`K\KZKZK[K]K\KZK[K[K[K[K[K[K[K[K[K[KZK[KYKYK[KVKPKK>K5K1K;K9KGKQKPKPKNK6K+K*K*K(K&K&K$K#K%K)K.K2K:KKZKvKsKtKtKtKtKsKsKtKpKMK?KVKuKsKsKsKtKtKtKsKuKpKMK?KTKvKsKuKuKuKcKEK@KEK>K>KK;KKAKKKTK]K]K]K\KZKZK[K[K[K[K[K[K[K[KZKZKZK[KYKXKYKZKXKYKWKIK1KK KKKK +K +KK K K KKKKKKKxKzKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKxKyKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K|K}K}KzKzKzKzKzK{K|K}K}K|K|K|K}K}K}K}K}K}K}K}K~KwKUKRKRKQKPKOK.KDK\KZKUKOKIKVKSK”K×KÎKÐKÐKÏKÔKêKóKËK|K€K€KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK‚KmKFKHKFKBK@K;KDKGKFKFKFKFKFKGKFKEKEKEKGKEKCKDKDKDKDKDKDKDKBKAKCKBK?K>K=K9K8K:K7K?KQKQKPKRKBK.K,K,K)K&K%K$K$K#K'K*K/K6K:K@KBKEKGKMK|KwKpKpKqKsKuKxK|K{K}K†KKxK{KwK|K‚K|K{KKK‹K“K›K—K‘KÙKûK§KaKjKgKeKzK}KvKcKSKHKZKjKkKeK\KSKUK>KK K K K K K K +K K K K +K K KK K K K K K K K K +K K +K K +K +K K +K K K K K K K K K K K K K4KqK‚KwKqKkKmKsK{K†KK™K K K§K§K‡KOKwe]r)(KK K"K"K%K$KKKKK:KÌKòK­KK#K%KKKKKKKK$KGK@KaKvKsKvKuKvKtKsKsKuKmKJK?K\KwKsKsKsKtKvKtKsKvKmKIK@K[KvKsKvKuKtK_KEKAKEK>K>KK-K$K&K&K#KKK%KSKLK'K/KKKYKDK)KHKZKWKWK:K'K!K!K(K.K2K5K1KHKYK7K;KWKhKsKXK.K%K'KCK\KAKBKwK{KzKqK_KGK:K8KHKWKYKYKYKSKJKAKKAKHKFKGKFKFKFKGKDKCKFKGKGKEKCKDKCKDKDKDKDKDKBKAKBKAK?K>K=K;K:K8K6K8KLKQKPKQKLK3K-K-K+K)K$K%K%K!K&K*K0K6K:K=K@KEKFKHKuKyKpKpKpKsKuKuK{KK~K‚K‚KvKyKwKxK‚KƒKK~KK…KŒK”K›K˜KÈKòKìKsKOKjKYKoK{KoKfKXKJKRKbKgKiKbKZKUKBKK +K K K K K K KK +K K +K +K +K K K K +K +K +K +K +K +K +K +K +K +K K K KKKKKKKKKKKK K +KKK:KPK^KeKmKqKrKuKzK†K’K•K—KKjK?Kje]r*(K)K)K(K(K#KKKKKKQKÛKéK‚KK&K$K"KKKKKKKGKBKCKjKuKsKvKuKtKuKuKsKuKiKEKAKbKxKrKtKuKuKuKuKtKuKhKEK@K`KvKsKtKsKsK^KBKBKDKK:KKKMKFKAKCKMKPKSKOK?K>KK>KK-K,K+K*K&K&K$K#K%K)K.K4K8K=K@KDKGKGKqK}KqKqKoKsKtKvKxK~KK‚KKwKsKuKwKK†K„KK~KK…K‹K“K“K©KèKüK·KCK`KXKiKtKnKcKYKLKJKZKaKfKgK`KYKHKK K K K K +K K KKK K K +K +K +KKK K +K +K +K K K K K K K K K KKKKKKKKKKKK KK KK KK)K8KHKZKfKkKtK{K„KŽK‘K€K\K:KSe]r+(K)K*K*K#KKK KK KKaKÑK¿KPKK'K$K#K KK"KK"KjKVK>KHKpKtKtKvKtKsKuKuKsKuKbKAKBKhKuKsKtKvKuKuKuKuKvKeKDK?KeKvKsKsKtKtKZK@KCKCKK=K:K:K7K=KOKQKQKNKJK1K-K/K,K'K'K$K#K$K(K+K/K5KKCKCKKOKIKEKAKDKOKQKQKLK>K?K9K(K%K%K"K!K!KK-KZKCK%K4KOKUKXKYKXKXKYKUK7K)K%K*K.K0K4K3K5KRKXK6K8K?K9K4K4K0K,K,KIK[K;KOKqKUKKKFKAKK?K8K'K%K%K"K!K"KK1KZKAK&K6KPKUKWKWKXKWKXKTK7K)K%K*K.K0K4K6K7KRKXK5K8K>KKDKCKDKGKGKDKCKDKDKDKDKDKDKCKBKAK?K=K=K;K:K:K8K@KPKQKPKRKGK0K-K.K+K'K&K&K%K%K'K)K0K4K8K?KDKEK^KKtKoKmKoKtKvKyK|K{KK‡KzKtKsKpKpKsKxKKˆK‹K‹K‰KŠK‹K}KK×KíKõKtK>KBK K(K8KAKHKIKGKSK[KcKfKgKSKAKKK K K K K K K KKKKKK +K +K K +K K K +K K K K K K K K +KKKKKKKK K +KKKKKKKKKK KK K K KKKKK%K1K?KMKEe]r.(K0K+K(K$K K K!K"K#K,K@KCK5KK!K$K$K"K K"K"KVKxKeKCKAK]KyKuKuKuKuKuKuKuKtKrKOK?KPKvKvKuKuKuKuKuKuKuKuKRKK>K6K'K%K$K$K!K!KK4K\KAK'K:KSKUKVKXKXKWKVKRK8K(K%K)K/K1K4K6K9KQKWK2K7K@KK;K;KLKXKAK2K:KJKbKiKNK5KDKCK@K[KNKBKpK{KyKyK{KtKaKJKHKKKMKVKZKYKXKSKKKBK=K>KGKQKWKZKYKWKWKWKWKXKXKXKXKXKXKXKXKXKWKXKXKXKWKTKUKXKZKTKGK7K"K KPK‚KwKxKxKzKzKzKzKzKzKzKxKxKxKxKxKxKxKxKxKxKzK{KzKzK{KyKxKzK{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K€KbKPKSKPKPKTKBK/KWKXKYKRKHKKKTK^KÁK×KÒKÓKÔKÏKÞKêKîK«K}K„KƒKƒKƒK€KKKKKKKKKKKKKKKKKKKKKKƒKƒKƒK‚K‚KƒK€KK‚K‚K‚K‚K‚K„KoKGKGKGKGKEK?KCKGKGKGKGKFKFKGKEKBKGKGKGKGKFKDKCKCKDKDKDKDKDKCKBKBKBK@K>K=KKUKxKuKuKuKuKuKuKuKvKsKNKKAKQKPKQKHK=K=K4K&K%K%K#KK KK5K[K>K'K;KTKVKWKXKWKVKWKQK8K)K&K*K/K1K3K6K9KSKVK4K7K>KK7K@K1K6K@KDK?KGKbKcKYKPK;K8KJKdKuK|K{KzKzK^KQK)K#K6KIKWKYKYKUKPKIK?K8K:KFKRKWKZKYKXKVKWKWKWKWKWKWKWKWKXKWKWKXKWKUKUKUKTKUKVKXKVKFKTKpKwKzKzK{KyKyKyKzKzKzKyKyKxKyKyKxKyKyKyKyKzKzKzKzKzKzKyKzKzKzKzKzKzKzKzKzK{K{KzKzKzKzKzK{K|K|K|K|K|K|K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KKiKPKSKQKPKRKLK,KSKYKYKTKKKGKWKRK¨K×KÐKÒKÓKÑKÙKéKðKÄK~K‚KƒK‚KK€KKKKKKKKKKKKKKKKK€KK€KK‚K‚KKK‚K‚K‚KKK‚K‚K‚K‚K‚K‚KKSKEKHKIKIK@KBKGKFKGKGKFKFKFKGKGKFKGKFKFKFKEKEKDKDKDKDKDKDKCKBKAKBK@K>K=K;K8K9K8KEKQKPKQKSKCK.K-K,K*K(K'K&K&K%K(K*K0K6K9K=KAKTKKyKrKoKnKqKwKzK}K}K~K…KƒKxKsKnKoKqKnKsKyK~K†K‹KŒK‹K„KyK®KÙKïK¦KKK KKK(K4K6KCKOKYK[KaKdKQKLKKK +KKK K +K K +K +K K +K K K K K K K K +K K K +K K K K K K KKKK K K K KKKKKKKKKKKKKKKKK +K K KKK#K-K/KAe]r0(K,K,K(K KKKKK!K3K?K@K)KK"KK K#K KK(KkKzKXK>KBKlKvKuKuKuKuKuKuKuKwKjKCKK?K>KKRKHKCK;K6KOKPKRKHKK?K>KLKZK9KEKuKfKTK=K2K1K1KKGKTKYKXKVKUKWKWKUKUKUKWKXKXKXKXKWKUKVKVKVKUKUKTKQKWKVKSK[KbKnKvK{KzKyKxKzKzK{KzKxKzK{KxKyK{KzKzKzKzKzKzKzKzK{KzKzKzKzKzKzKzKzKzK}K}KzKzKzKzKzK}K~K~K~K~K~K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KKtKRKSKRKOKPKRK0KHK[KYKWKNKEKUKRKˆKÕKÎKÓKÓKÓKÕKèKíKÝKŠK€KƒKKKKKKKKKKKKKKKKKKKƒK‚KKKƒK‚K‚KK€K‚K‚K‚K‚KƒK‚K‚K‚K‚K‚K‚K…KcKDKIKHKDK;K?KGKFKFKFKGKFKGKIKHKFKGKFKFKFKGKFKCKCKCKCKDKDKCKAKCKAK>K?K>K;K2K4K:KK&K!K$K%KKKKK*KnKvKOK>KGKrKuKuKuKuKuKuKuKuKxKdK@KAKbKxKuKuKuKuKuKuKuKvKmKGK=KYKxKuKuKuKwKcKDK=KCKK=K;K:K8K8KIKQKQKQKQK>K.K-K+K*K)K&K&K%K&K&K-K2K6K=KAKLK}K{KtKpKpKnKmKxK}K~KK‚KƒKKxKtKpKpKnKnKtKwKxK|KK‡K†K|K…KÈK»KhKSKKKKKKKKKKKKK/K5K/K +KKK K +K +K +K +K +K +K +K +K +K +K +K +K K K KK K K K K K K KK K +K K +K +KKKKKKKKKK K K KKKKKKKKKKKK KKKKe]r2(KK#K%KKKKKKKKMKuKvKuKuKuKuKuKuKuKyK]K@KCKjKxKuKuKuKuKuKuKuKwKgKCK>K]KxKuKuKuKwK`K@K>KDK;KKRKPKRKCKKHKSKVKVKVKUKUKUKUKUKUKVKVKUKUKUKUKUKVKTKRKRKSKSKRKQKQKRKXKbKlKvKzKzKyKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|K~K{KzK}K}KzKzKzK|K~K}K}KzKzKzK|K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K`KPKQKQKPKSKAK0KVKWKXKTKKKKKTK\K¾KÔKÏKÏKÐKÏKÝKìKñK¶K}K„KƒKƒKƒK‚K€KKKKKKKKKKKK‚KƒKK€KƒK‚K‚K‚K‚KƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚KKUKGKHKGKHK?K=KGKFKFKGKGKFKFKFKGKGKFKFKFKGKGKGKGKGKEKCKDKDKDKCKBK@K>K?K?K=K=K;K9KAKQKQKPKQKIK0K-K+K+K)K&K%K&K%K%K+K0K4KKAK2KKKKK K#K!KKBKxKkKBK@KUKxKuKuKuKuKuKuKuKuKwKVK=KEKpKwKuKuKuKuKuKuKuKxKbK>K?KeKxKuKuKuKwK\K>K?KCKKHKUKWKWKWKUKUKVKUKUKVKUKVKVKVKVKTKRKSKSKSKRKSKSKRKQKPKQKVKbKmKuK|K}KyKxKzKzKzKzKzKzKzKzKzKzKzKzKzK{K}K|KzK|K}K}K}K}K|KzK|K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KKiKTKQKOKQKQKKK,KPKWKXKVKLKHKVKQK KÕKÎKÐKÐKÏK×KêKñKÒKƒKƒKƒK‚KƒK‚K‚KKKKKK‚KK€K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K„KdKFKJKHKHKDK;KEKGKGKGKGKFKHKHKFKGKGKFKGKGKGKFKFKGKEKCKDKDKDKDKCKBKAK?K?K=K:K:K9K:KLKRKRKRKOK8K.K-K-K+K(K(K'K%K(K+K+K3K9K=KAKpKKuKrKpKoKmKrKxK{K~KK‚K‚KK{KvKoKnKnKnKpKqKtKvKyK€KK€K‘KkKaK[K9KKKKKKKKKKKKKKKKKK +K +KKKK K KKK K K KKKKKKK K K K K K K +KKKKKKKKK K +K K K K K K K K +K +K +K +KK KKKKKKK K K K e]r4(K%KKKKKKKK)K@K@K,KK K"K!KK!K(K"KVK|KcKBK@K^KxKuKuKuKuKuKuKuKuKuKPKKAK?KJKSKTKDK@K9K/K:KRKjKtK|KzK4KHKWK$KK!K7KJKSKTKTKSKQKIK?K4K5K>KHKTKWKWKUKUKUKUKUKUKUKUKUKTKRKSKRKRKSKSKRKSKSKSKSKQKPKQKWK_KlKvK{K}K{KzKzK{KzKzKzKzKzKzKzKzK{K}K|KzK|K~K}K}K~K|K{K}K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K~K}K}K}K~K~K}K~KKrKSKQKPKQKPKQK.KEKXKWKUKNKHKUKPKƒKÔKÎKÐKÐKÐKÑKçKîKäK‘K€KƒKƒKƒKƒKƒK‚K€K€KKK‚KK€KƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K„KuKJKIKIKHKFK=KAKGKGKGKGKFKHKHKFKGKFKGKFKFKGKGKFKGKEKCKDKDKDKDKDKBKBK?K?K>K:K:K9K9KEKQKRKRKQKDK/K.K.K+K)K)K'K%K%K'K+K2K5K:K>KoK€KvKsKqKpKmKrKyK{K~KK€K}KK|KzKrKnKnKnKpKpKpKqKuKyKzKsKfKaK^KUKGK KKKKK KKKKKKKKKKKK +K +KKKKKKKKKKKKKKKKKKKKKK +K KK K KKKKKK K +KKK +K KKKK K +K K +K K K K K KKKK K +K K +e]r5(K!KKKKKK!KK+KBK=K)KKKK#KKKK&K_K{K[K=K@KdKxKuKuKuKuKuKuKuKvKqKKK>KPKwKuKuKuKuKuKuKuKuKxKYKKJKwKyKxKxKxKxKxKzKnKYKOKDKyKzKpK]KGK2K.K3KIKVKBKRKsK]KEK-K/KAK]KIK KJKWK7KK +KKK-K=KMKSKUKSKPK:K>K@K8K7K?KIKTKWKWKVKUKUKSKRKRKRKRKRKRKRKRKSKRKRKSKRKSKRKQKQKPKOKQKTK_KmKwK|K~K|KzKzKzKzKzKzKzKzKzKzKzKzK|K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KKK}K}K}KKK}K}K~KzKUKQKRKQKOKQK4K;KVKVKWKPKGKNKSKjKÊKÑKÏKÐKÐKÎKàKêKìK¥K~KƒKƒKƒKƒK‚K‚KƒKKKKKK€K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚KƒK‚KUKGKIKGKGK@K=KGKGKIKGKGKFKFKFKHKHKGKFKFKGKGKFKGKEKCKDKDKDKDKDKBKAK?K?K@KKTKyKvKwKuKvKwKvKuKuKvKSKKQKYK@KLKwKyKxKxKxKxKxKzKpK[KOKCKtKwKzK}K{KlKRK=KHKVKBKEKdKnKqKVK3K+K+K%K$KMKWKBKKK +K +K KK#K4KAKMKQKMKQKQKPKIK=K6K:KCKMKTKWKVKSKRKRKRKRKRKRKRKSKRKSKRKRKRKRKQKQKQKRKSKQKOKNKPKTK^KkKuK{K}K{K{K{KzKzK{K|K{K|K{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KKK~K~K~KKK~K~K~K€K]KPKSKQKPKTKBK0KUKXKYKRKHKJKVKYK¶KÔKÏKÐKÐKÎKÙKêKïK½KK…KƒKƒKƒK‚K‚KƒKKK€KK€KK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K…KfKGKIKHKHKEK;KGKGKIKGKFKGKGKGKFK@KAKHKGKFKGKFKGKEKCKDKDKDKDKDKBKBK@K@K?K=K;K:K:K8KGKSKPKQKRK?K-K/K,K+K(K&K%K%K&K'K+K1K6K8KfKKxKvKsKrKnKrKwKxK}KK€K}K~K|K{KtKrKoKoKkKkKjKpKuKzKxKoKeK]KSKMKFK0K@K1K2KIKLKIKKKDK9K0K(KKKKKK K +K +K +K +K +K K K K K K K K KKKKK K K K KKKKK K KKKKKKKKKKKKKKKKKKKKKKKKKKK K +K Ke]r7(KKKKK%KKKK8KAK:K KKKK#K$K%K K&KkKvKNK>KIKrKvKuKuKuKuKwKyKvKwKhKCK?K\KyKxKyKuKvKyKwKuKuKuKNK>KMKuKuKuKuKyKnKIK;KDK?KKXKQK=K:K:K=K=K=K;K=K>KOKZKCKMKwKyKxKxKxKxKxKzKrK^KPKCKuKyKxKwKxKzK{KxK_KQKCK1K8KFKVK]KMK=KGKMKAKQKVKDK#K KKKKKK KK%K>KIKLKRKTKQKNKMKEK?K8KKBKHKIKGKFKHKHKFKFKCKCKGKGKFKFKGKGKEKCKCKCKDKDKDKBKAKBKAK?K>K=K;K9K8K@KQKQKPKQKKK2K.K/K*K)K'K%K&K%K'K*K/K6K7KaKKxKvKsKqKpKsKwKwK{KKK|K}K~KzKtKpKoKqKoKnKkKkKoKvKvKlKbK[KQKIKBK1K?K&K:KJKPKRKKKDK@K@KBK9K,K6KKKKK K K +K +K +K +K +K +K K K KKKKK K K K K K K +K KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKe]r8(K#KK%K$KKKK#K>K=K4KKKKK#K%K%K!K.KrKtKFK=KOKwKxKwKwKwKwKxKxKuKxKaKAKAKcKzKvKwKwKxKxKxKwKwKsKIKKK.K6KQKFKBK>K4KJKPKRKJK:K;K6K)K%K#K"K KKK&KRKOK8K6K7K3KKKKK2KYKGK4K#K&K(K+K0K4K3K>KXKOK>K:K:K:K;K=K=K;K=KOKZKCKMKwKyKxKxKxKxKxKzKrK]KPKDKtKyKxKxKxKxKwKyKfKTKCK?KFK6K5K?KGKCKGK]KfK[KTKFK5K)KKK KKKKKK0KQK?K,K?KPKUKTKQKQKNKEK;K5K6KBKMKSKUKTKRKRKRKRKSKRKRKRKQKQKRKQKQKQKPKPKPKQKPKOKPKOKLKMKPKZKhKsKzKK~K|K|K}K|K{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KKKKKKK~K}K~KKKKKKKKKKKKKKKKKrKQKSKQKPKPKRK-KFKWKWKUKNKFKTKPK~KÓKÏKÏKÐKÐKÎKãKíKçK–KKƒKƒKƒK‚K‚K‚K‚KKK€K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K„KƒK‚KXKFKIKIKKKDK>KHKGKGKFKHKHKFKGKIKHKHKGKFKGKGKGKFKEKFKEKDKDKDKCKCKBKAK?K>K>K=KK/KKKKK#K&K'K$K5KtKnKAK=KXKyKxKyKyKyKyKxKxKuKxK[K@KBKhKyKuKvKxKyKxKxKxKyKmKEK=KVKxKuKuKtKzKeKBK:KDK=KK,K9KOKFKCKK:K:K9K;K=KKOKZKCKLKwKyKxKxKxKxKxKzKrK\KQKDKtKyKxKxKxKxKxKzKhKUKBKOK}KnKXKBK4K1K8KAKOKWKUKDKFKJK6K-K%KKK KKK'KXKEKKK#K6KGKQKSKRKPKOKIKAK7K.K:KEKLKSKUKSKRKRKRKRKRKQKQKSKRKPKPKQKPKPKQKOKMKMKMKNKNKMKLKNKQKYKfKrKzK€KK{KzK|K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KKKKKK€KK}K~K€KKKKKKKKKKKKKKK€K{KVKRKQKPKPKTK6K8KWKWKVKNKFKOKSKdKÆKÐKÏKÐKÐKÌKÝKìKðK®K~K„KƒKƒK‚K‚K‚K‚KƒK€KK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K„K„K…KhKGKIKIKIK@K>KGKJKGKFKHKHKFKGKIKIKIKGKFKGKGKGKGKGKGKFKDKDKDKDKDKBKAK?K?K?K>K6K9K9KCKRKSKTKTKDK.K.K.K+K)K)K&K%K%K%K,K1K1KXK…KyK{KwKrKpKsKwKwK{K€KK|KzKzKzKtKpKoKqKrKpKpKqKrKrKqKhK`KVKJK@K:K?K=K4KKK[KUKNKJK;K3K4K;KBKAK9K:K'K KKK K K +K +K +K +K +K +K +K K K K +K +K +K KKKKKKKK +K K K K K K K +KK K K KKKKKKKKKKKKKKKK KK KKe]r:(KCK=KKKKKK-KCK>K*KK!KKK"K$K%K#KK^KyKuKvKuKvKyKwKuKvKvKRK=KCKmKwKwKxKxKxKxKxKxKyKjKAK=K[K{KwKxKwKyKcK?K:KCK=KK-K>KNKEKCKKWKNKKQKVKCKMKlK`KMK5K*K'K KK K"KSKJK*KK +KKK+KK/KUKVKUKRKFKHKUKUK±KÓKÏKÐKÐKÍKÓKéKîKÇKK…KƒK‚K‚K‚K‚K‚K‚KK~K~KK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚KƒK„KƒK‚K‚K‚K‚K‚K‚K‚K‚K„K„K„KƒK„KyKKKIKIKGKEKCKEKKKGKFKGKGKHKHKIKGKGKGKFKFKGKGKFKFKGKFKCKCKDKDKDKCKCKAK@K?K=K1K7K;K=KPKQKRKTKNK6K-K-K*K*K'K(K(K&K%K(K/K/KUK„K{KzKyKtKsKsKtKvK{K€KƒK‚K~KxKvKrKqKpKoKrKrKmKlKpKtKqKfK`KUKIK9K9KDK;KGKYKTKNKTKAK:K=K>K@K?KKcKzKxKxKxKxK]K>K=KCK=K=KK*KAKNKEKCK;K5KKKMKOKEK;K:K3K'K%K!K!K KKK/KUKHK:K8K7K0KKKKK8KYKDK/K#K&K(K/K1K4K2K?KXKMK;K9K:K=KKOKxKxKxKxKxKxKxKxKxKyK\K>K@KjK{KxKxKxKwKYK>K>KCK>K?K=KK7K4K-K"KK KKKKKK K K KKKKKKKKKK KKKKKKKKKKKKKKKKK +K K K KKKKKKKKKKKKKKe]r=(KHKEKBKEK?K&K!K:KBK8K!KKKKKK#K%K!KSK{KJK>KHKtKyKxKxKxKxKxKxKxKzKkKAK>KVKyKxKxKxKxKxKxKxKxKyKWK=KCKnKyKxKxKyKvKSK=K?KAK=K>K=K:K)KHKKKDKBK6K:KLKMKNKBK(KIKIKCK@KCK9K,K:KAK4K KKKKKK K"K"KZKvKDK=KRKyKxKxKxKxKxKxKxKxKzKeK@K>K\K{KxKxKxKxKxKxKxKyKzKQK>KGKqKxKxKxKyKrKOK;KAK>K;KKSKDK8K8K8K1K(K)K.K/KJKSK?K7K6K7K6K6K5K5K.K;K[KKK:K9K:K9K9K:K9K:K=KPKWKCKSKyKyKxKyKzKzKzK|KqK[KQKKKvK{KzKzKzKzKzK}KkKUKMKOK{KzKzKzKzKyK~KTKK/KYKJK*KK KK,K9K=K>KBKHKWKUKNK;KEK?K2K-K$KKK +KK.KGKMKQK2KK)K+K;KJKNKPKPKPKMKEK=K3K/K:KFKNKPKOKQKPKQKNKMKMKMKMKMKNKMKMKMKNKSKSKSKPKPKPKQKQKRKQKPKRKVK`KoK{K~KK~KK€KK€KK€K€KKKKKKKKKKKKKKKKKKKKKKKKKKKK€KKZKOKQKPKPKTK?K0KTKUKVKQKIKJKUKUK°KÕKÐKÏKÑKÍKÖKìKíKÎK…K…K…KƒK‚KƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K„K…K„K„K„K„K„K„K„K‚KƒK„K„K…K…K…K„K„K„K„KƒKcKOKQKPKSKHK=KIKHKIKHKFKGKIKIKIKGKGKFKFKFKFKFKGKGKGKGKGKEKCKDKDKDKCKBK@K>K=KK=K>K,KKKKKKK K$K#K`KnK?KKKMKLKLK>K:K8K1K*K)K)K'K&K&K"KK4K4K?KLKQKOKNKLK9K3K9K5K5K;KGKNKQKQKNKMKMKNKPKOKMKOKOKNKQKRKSKSKNKMKPKQKPKQKSKSKNKOKNKOKWKaKqKzKK€KK~KK~K~KKKKKKKKKKKKKKKKKKKKKKKKKKKKKƒKeKPKQKQKPKOKGK,KQKVKUKRKLKGKUKOK”K×KÎKÐKÓKÏKÑKçKíKãK‘K‚K…K„KƒKƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K„KƒK‚KƒK„K„K„K„K„K„K„K„K„K„K„K„K„K„K…K…K…K„K„K„K„K†KqKPKQKPKQKOKK=KK?KAK=K%KKKKKKKK!K&KgKcK;K=K_K|KxKxKxKxKxKxKxKxK{KZK>KAKjKzKxKxKxKxKxKxKxKzKsKGK;KOKzKxKxKxKzKoKLK8K@K=K=KKSKYKEKSKyKyKxKyKzKzKzK|KsKYKTKKKuK{KzKzKzKzKzK|KlKTKMKMKwK{KzKzKzKyKKLKÿK*KYKLK/KKKKKKKKK K1KLKRK=K?KWKcKaKFK1K4K3K/K)K(KDKVKEKCKeKgKjKnK\KCK7K6KAKJKOKIKIKLKIKAK;K5K6KKHKIKIKIKIKGKGKGKGKGKHKEKCKDKDKCKBKAK>KK[K{KyKxKxKzKhKCK8KCK=K=KK/K2KMKGKEK?K2KDKMKKKIK;K9K6K#KKKKK K K K?KUKK>KMK[K\KQKQKLK:K8KJK[KgKtKrKuK{KzKpKXKIKEK=K@KMKPKNKKKKKHKAK9K4K5K;KIKNKSKWKUKTKVKUKSKTKTKSKSKRKRKSKSKSKRKSKRKRKSKSKSKRKQKQKPKOKTKaKlKzKK‚KKK~KKKKKKKKKKKKKKKKKKKKKK‚KKYKOKNKMKMKOK>K;KWKUKUKPKGKIKUKTK±KÚKÎKÎKÏKÏKÒKèKîK×K‡K„K…K„K…K„KƒKƒKƒK„K„KƒKƒKƒK„K…K„K„K„K„K…K…K…K…K…K…K„K„K„K„K…K…K…K…K…K…K…K…K…K…K…K„KˆKrKOKQKQKPKMKAKDKJKIKHKIKIKIKIKIKIKHKIKHKHKHKIKHKGKGKGKGKGKGKFKDKDKDKCKBK@K=KKAK3K K K!K!K!K!KK7KtKFKKK=KEKVKYKQKMK=K5K-K1K?KVKkKvKzKvK|K|KRKNK,KK*K0KCKLKOKLKJKHKEK?K8K-K2KAKQKXKWKVKVKUKRKSKRKRKOKQKSKRKRKRKRKRKRKRKRKRKQKPKQKQKQKPKNKMKUK`KmKxKK‚KKKKKKKKKKKKKKKKKKKKKKK„K_KMKNKMKNKMKNKSKTKVKVKRKHKEKTKPK’KÝK×KÕKÒKÐKÒKäKêKçK”K}KƒK…K…K…K„K„K„K„K„K„K„K„K„K„K„K„K„K„K…K…K…K…K…K…K„K„K„K„K…K…K…K…K…K…K…K…K…K„K…K„K†K€KXKPKQKPKDKAKCKLKKKHKIKIKIKIKIKHKIKHKHKHKHKIKHKGKGKGKGKGKGKGKGKFKCKDK@K?K>K;K5K9K;KEKTKRKRKTKIK2K/K+K+K)K&K&K$K#K.KK‹K„K„K„K„KKzKzK{K~KK€K~KuKrKwKvKuKqKqKnKjKjKkKlKfK\KSKCKDKXKLKNK\K`KdKeKeKcKaK`K_K`K_K\K\K[KZKVKTKTKVKYKYKSKOKKKTKOK@K?K@KDKBK>K;K:K8K5K6K8K3K-K&K"KKKKKKK1K2K)K"KKKKKKKKKKKK!K%K'K*K,K1K>KGKAK`KÙe]rD(KHKIKHKGKGKHKHKHKDKAK@K7K!KK K K KK7KkKBKKhK|KxKxKxKyK_K?KK4K5K:K;KOKSKRKTKSK9K-K,K*K)K&K&K#K K,KK‹K„K…K‡K‡KƒK~K|K{K|K}KK|KrKmKqKuKvKuKuKsKoKnKlKiKeKZKOKAKIKSKIKXKaKdKdKeKeKcKaKaK`K`K_K^K\KZKYKWKWKXK[K[KXKQKOKRKVKLKDKFKEKHKGKDKAK>K>K>K?KAK7K3K.K.K-K,K+K,K'K#K,K?KK@KDKKKSK{K´Kée]rE(KIKHKFKFKFKFKGKIKIKDK@K@K6K KKKK!K)KK;K]K|KyK{KzKzK{KzKxKwK|KXKK;K@K;K;K=KKIKNKMK?KMKUKRKCK5K*K&K,K9KKKiKYKOK?KTK‚K‚KzKgKNK:K3K;KFKMKIKEKJKHKCK=K6K3K;KDKNKWKXKVKRKRKRKRKSKSKRKRKSKRKRKRKSKRKPKPKPKQKPKNKRKQKQKPKMKMKSK]KjKwKKƒKK€KKKK€KKKK€K‚KƒKƒKƒKƒK‚K„KvKRKQKOKMKMKNKRKUKUKTKRKOKGKKKRKPKQK[KbKuK–K»KÙKçKäKäKàKÎK»K¨K—K‡K‚KK‚K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K„K…KˆK†K„K…K†KsKRKQKOKRKOKAKFKKKHKIKHKIKHKHKIKHKIKIKIKIKIKHKFKFKGKGKGKGKGKGKFKCKBKAK@K=K=K:K:K:K8KGKSKRKSKUKFK.K,K)K)K&K&K%K"K(K|K‹KƒK‡K‰KˆK‡KƒKK~K}K|K}K{KrKkKiKnKqKtKvKvKuKpKlKiKcKZKNK@KPKLKQK_KdKeKdKeKeKcKaKbKaK_K`K`K\KYKWKXKZK[K]K[KWKRKTKZKUKMKLKKKKKKKIKHKCKBKCKFKFKCK?KKAK:K#KK!K)K:KEK=KhK}KwKxKyKzKxKxKxKyKzKWK=K?KiK{KyKzKzKzKzKzKxKxKxKJK7KHKxK{KyKxKzKvKUK;K>K@KK:K:KKEKJKHKJKAK;K=K5K#K!KKKKKK!KOKJK9K8K8K1KKKKK"KTKLK9K%K#K&K*K.K/K0K0KHKVKGK8K7K8K7K7K7K8K:K>KSKWKDKSKzK{KzKzKzKzKzK}KuKWKQKHKsK{KzKzK|K~K|KuKbKUKRKIK>K8K8K8K?KNKjKSKKKRKQKEKKKKK KK-K5K$KK:KTKMK@K KK)K-K-K1K5K4K3KKIKMKPKJKBKDKIKKKJKGKGKGKHKNKOKbK¯KÕKäKïKòKêKíKñKìe]rH(KGKHKIKIKIKHKEKFKEKDKDKGKDK@KAK7K"K K-K8K>K;KJKrK|K~K~K|KzKyKyKyKzKPK=KEKqK|KzKzKzKzKzKzKzK{KuKFK9KJKxK{KzKzK}KtKOK8K?K?KKFKHKHKJK?K9K:K3K%K#K KKKKK$KQKJK8K7K8K1KKKKK$KVKLK8K&K"K%K*K.K/K1K2KJKWKDK:K6K8K6K9K7K8K:K;KRKWKDKVKzK{KzK{K}K|KzK}KtKWKRKIKsK~K}K|KrKbKTKDKAKSKSKIK@K9K;K=K=K:KKBKNKPK=KBKOKJKIKGKBK@K;K@KKKQKQKNKJK8K/K7KIKcKxK€K~KK}K„KfKIKEKK#K.K@KGKOKLKJKJKJKAK7K1K3K=KKKPKSKPKQKQKRKSKRKRKRKRKRKQKPKPKPKPKQKQKRKRKQKPKQKPKQKQKPKMKOKPKYKiKsKK„KK€K€K‚K‚KƒKƒK‚KƒKiKPKQKQKOKLKOKMKSKSKSKPKLKEKNKQKRKNKXKIKVKOKOKPKOKOKMKMKOK^KxK™K¼KÔKÝKáKàKÝKÒK¿K«KšK‹KƒK‚KƒK…K†KˆKˆK‡K†K„K…K…K‡K‡K‡K†K„K†K‡K…K„K…K„K‡K†K„K‡KuKQKQKPKPKRKCKEKIKIKIKHKIKIKIKHKIKIKHKIKIKHKGKGKIKGKFKGKGKFKEKCKCKDKCK@K?K>K=K;K:K8KDKSKSKUKTKNK4K,K)K&K&K"K!K$K{KŽK‡K‡KˆK†KˆK‰K…K‚KƒK‚K‚K}KuKkKiKjKhKfKiKqKwKwKqKjKdKZK?KBKOK[KdKhKiKfKgKeKdKdKdKfKgKeKaKaK`K\K^KcKaK]KZKYKXKXK\K]K\KXKTKRKOKNKSKPKPKSKTKNKFKGKKKLKKKIKIKIKHKFKEKBKEKNKNKRKRKJKHKKKOKOKKKKKJKKKSKPKšKöKñKïKéKëKîKìKîKîe]rI(KGKGKIKHKIKHKEKGKFKCKAKCKGKDK?K?K9K%K-K8K;KKKEKHKHKJK@K9K:K2K&K$K!KKKKK%KRKEK5K6K8K2KKKKK&KUKKK8K&K"K%K*K.K.K2K3KKKWKCK:K5K8K6K9K7K7K:K;KRKWKDKWK{K{KzK{K}K|KzK|KuKXKRKIKpKoK^KMK?K;K:K=KCKSKSKJK>K7K=KKK-K)K'K&K"KK(KKK‡KˆK‰K†KˆKŠK†KƒK‚K‚K‚K€KzKqKhKjKiKfKfKlKrKwKrKjKdKWK;KDKSKaKhKlKmKjKgKdKdKeKeKfKgKfKbKbKcK`K_KbKaK\KZK[K[K\K`K]K[KXKSKRKRKSKTKRKSKVKSKIKHKKKNKLKLKMKMKMKKKIKHKFKIKQKRKSKSKRKLKKKOKTKPKOKQKPKTK]KÃKìKêKïKìKëKëKîKîKîe]rJ(KGKGKGKGKGKGKGKGKEKCKDKCKFKGKDK>KK:KXK}KzK{KzK{KmKHK7K@K=KKRKnKmKKKKK@KsK„K~KmKQK;K2K7KBKMKLKHKGK8K;KAK8K3K5K=KJKRKRKQKSKRKSKQKPKPKPKPKPKPKPKPKPKPKPKPKPKPKQKRKNKMKPKRKQKOKNKOKWKdKrK}K„K„K…K„K{KOKNKMKNKMKLKPKSK[KWKQKNKIKIKMKQKUKQKJKQKTKMKNKNKNKNKPKPKNKOKOKOKMKKKQK^KwK—K·KÐKßKáKÝKØKÓKÆKµK¥K“K‰K…K†K…K†KˆKˆKˆKˆKˆKˆKˆKˆKˆKˆK†KƒK‚KKƒKˆKcKLKQKPKQKNKAKIKIKHKHKHKHKHKIKHK?KEKIKHKIKIKIKIKIKIKGKGKGKGKGKEKCKDKCK?K=K;K9K:K7K6KFKUKRKSKTKIK1K-K(KK K0KIK‚KŒKˆKŠKŠK†K‰KŠK„K„KKKKK|KvKkKiKjKfKbKgKmKsKuKlKaKRK9KIK\KeKjKoKqKqKeKaKcKfKfKfKfKdKdKdKeKcKaKbKaK\K[K[K[K^K`K\KXKVKPKQKUKUKTKWKWKWKPKJKNKPKOKMKNKOKQKOKJKJKJKJKNKUKTKUKVKSKOKOKQKWKXKUKVKWKRK‚KãKçKãKëKóKìKìKîKîKîe]rK(KGKGKGKGKGKGKGKGKFKCKDKEKGKFKHKCK?K?KK=K;KJKsKyK}K~K|KzKzKyKyK}KeK;KKKKEKCK?KBKJKJKHKIK>K:K:K1K%K$K!KKKKK-KPKCK7K6K6K/KKKKK0KYKGK7K$K#K%K*K.K/K1K2KLKWKBK7K4K5K7K7K8K6K0K7KUKWKCKVK{K{K{K}K}K}KvKhKWKWKRKDK=K=K?K@K=KK>K:K:K:K6K;KSKSKRKSKSK8K0K/K)K3KKKSK‚KKˆKŠKŠK†KˆKŠK…K…KƒK‚KKK|KyKnKiKgKgKcKaKhKqKvKkKaKNK:KRKcKjKlKmKpKqKfKbKeKgKhKhKgKfKeKeKfKfKbKaK`K^K_K_K_K`K`K\KXKUKTKVKWKVKTKXKZKUKNKMKPKRKSKOKQKSKRKOKNKNKMKNKTKYKUKVKWKVKRKSKSKVKXKTKVKeKyKÆKíKéKäKãKìKòKíKíKíKíe]rL(KGKGKGKGKGKGKGKGKFKBKFKGKGKGKFKGKDK?K?K=KKdK~KzK{KzK|KbK>K8KAKKTKWKCKWK€K~KzKqKcKRKEK;K@KXKSKBK=K=KK?K@KRKTKJK-K+K8K9K8K:K9K0KK KHKQKMK$KKKKKK#K*K +KKKPKNKEK-K#K%K)K(K)K/K2K6K8KKK?KAK8K5K6K5K6K7K7K7K7K8K8K7K:KKKKK>KKVKTKUKVKQK5K0K7KDKHKCK}K‘KŒK‹KŠKˆKˆKŠKˆK†K‡K…K€KKzKvKtKlKkKfK`KcKcKfKqKpKaK=KBKaKeKjKkKkKpKpKhKdKfKjKkKjKhKgKfKfKfKfKdK`K_K`KaK`K_KbK`K[KYKYKYKWKXKYK[K^KWKRKQKTKUKTKRKRKSKSKQKPKPKQKTKWK[KWKXKYKVKUK[KYKeK“KÍKñKñKêKìKæKÞKåKêKßKÚKèKïKìKìKíe]rN(KGKGKGKGKGKGKGKGKDKCKCKGKGKGKIKIKIKIKDK6K8K?K3K0K9K;K:K9K8K7K7K7K6K8K:K6K7K9K8K7K7K6K4K2K4K9K;K:KK=K4K*K#KK"K/KPKOKJK:K5K3K%K(K)K-K6KKKEKVKOK*KKKKKKKKKKKLKQKKK9K/K2K3K9K=K=K?K>KKHKOKNKHKIKPKPKRKVKZK\K_KbKeKiKUKNKCKYK€KtKhK]KUKMKAK;K?KIKLKLKHK;K3K(K*K;KQKiK|K‚K€K~KK}KMKNK2KK&K)K8KEKJKNKIKEKFKBK;K2K1K7K@KKKQKTKQKPKPKPKQKQKPKQKNKNKKKJKPKRKQKQKPKMKNKLKPKQKQKDKK+K:KKKDKAK:K2KFKHKIKEK9K;K9K-K%K"KKKKKK9KRK>K6K4K6K)KKKKK9KWKDK2K#K$K&K)K,K.K.K2KQKTK?K7K4K5K5K5K5K4K5K:KRKSKCK;K5K5K;K:KKEK;K8K/K*K.K>KVKnKK„KKSKKK;KQKyKWK=K-K/K;KFKJKJKGKGKFK?K8K/K+K2KAKLKRKRKOKMKMKOKMKMKNKPKOKPKQKQKOKNKMKNKKKKKOKPKQKNKRKFK>KPKOKMKMKPKEK*KPKRKRKMKHKFKNKQKRKNKPKFKRKOKQKPKPKPKPKNKNKMKNKMKNKNKNKNKNKNKNKNKNKNKNKMKPKQKOKPKNKJKKKTKmK‰K°KÐKäKêKéKèKæKäKÙKÉK´KŸKK‰K…K†K€K[KTKTKSKRKKKCKLKKKLKKKKKLKJKHKJKKKKKKKKKJKHKIKIKHKHKHKHKGKFKFKDKCKBKAK?KK:K6K8K4K.K1K0K1K.K:KK(K>KGKCKAK:K0KFKGKIKEK:KKRK>K6K4K5K(KKKKK;KTKCK2K#K$K&K)K+K-K.K2KQKSK?K7K4K4K4K4K5K3K4K:KRKSKCKKFKJKHKDKGK>K/K4K/K1K9KCKLKNKPKQKMKKKPKRKOKKKNKQKNKMKNKNKKKJKNKPKQKPKQKLKKK?KCKEKFK=K8K6K:K7K/K+K5KGKKKFKFKKK~KK…KƒKqKXK=K-K2K=KFKIKBK=KDKFKAK:K3K2K6KBKJKPKPKPKNKIKFKNKQKNKNKPKPKNKKKNKNKMKAKIKQK>KLKOKNKMKMKSK-K@KWKQKOKLKBKFKOKSKUKWKKKQKSKQKQKQKQKQKQKQKQKNKMKNKNKNKNKMKMKMKMKMKNKNKMKNKNKMKNKNKNKNKNKNKOKNKKKJKHKRKkKK²KÍKÙKâKæKæKåKäKÙKÍK¬K€KhKZKOKPKHKIKPKMKNKMKKKLKKKKKLKLKKKHKJKLKJKHKIKIKIKGKGKGKGKDKDKBK?K=K7K7K9KBKMKOKOKSKUKUKUKTKCK.K.K+K"KnKšKKŽKŽKŒKŠKŠKˆK…K‡KŠK‡KK~KzKvKpKhKeKeKcK^K`KgKmK[KCKTK^KaKbKfKiKoKmKkKlKkKkKkKkKkKlKkKjKhKcKcKgKgKfKgKeKaK]K\KbKaK`K`KbKbK]K[KXKWKYK[KYKVKWKWKVKUKTKTKXKZK`KKÀKÅKÅKÑKÕKÎKØKãKÛKàKèKÖKÕKÞKäKíKÝKäKæKâKßKáKèKåKëKëKëe]rR(KDKDKAKDKEKFKFKGKFKCKCKDKCKEKGKGKGKGKGKGKGKGKCK?K=K:K8KAKEKFKFK=K7K;K/KKKKK#K*K/K4K8K8K8K:KKGKGKIKAK;K>K6K'K$K!K KKKKK?KOK=K6K4K4K$KKKKK?KSKAK0K"K$K%K*K+K-K-K1KPKRKAK5K2K3K4K4K4K3K3K;KTKRKCK;K4K0K1K&KKK%K.KAKUKPKEKLKEK9K,K KKKK,KQKQKIKQKHK/K*K;KKKJKEK,KKKK=KBKNKSKRKUKNKK´K;KýK K +KK KKK5KVKNK;KKKKKKK)K$K K$K0KLKNKMKAK;K?KAKFKPKLKOKVKYK[KXKPKNKGKmK…K€K€KKKKKK€K€KVKLKEKZK†K‚K~KsKjKcKVKIKDKAKFKIKKKIK?K-K+K*K+K;KSKpKK†KƒKK~K†K€KQKIK6KK"K2KAKIKKKFKDKEKBK=K8K2K1K8KDKJKLKOKPKMKLKLKMKOKPKFKMKLK>KNKMKMKMKMKIK%KHKSKQKMKIKBKHKMKLK(K+KJKLKJKJKHKGKIKNKOKOKOKOKNKMKNKNKMKNKNKNKNKNKNKNKMKLKNKMKMKLKKKLKLKLKLKLKLKLKMKNKMKLKNKOKLKNKLKIKMK^K~K¥KÆKßKìKëKéKæKåKäKÞKÈK¦K„KhKSKKKKKJKFKMKNKLKLKJKHKJKJKJKHKEKCKAK?KAKIKRKSKUKTKFK)KKKK5KTKSKRKUKJK/K/K&K\K™K“K‘KŽKŒK‰KŠKŒK‰K…KK„K†K€KxKsKtKoKfKeKiKaK`K^KcKTK>KMKTKVKYKaKnKpKmKlKkKkKmKoKlKkKlKkKiKiKiKiKiKiKiKeKdKaK\KaKbKeKcKdKdKaK^K\K[K\K[KZKYK[KZKYKWKYKYK[K‰KšKžK²K²KÄKÒKÒKÓKÖKØKØKßKÙKÛKåKÜKÒK×KàKçKäKßKáKÞKÜKÝKåKéKêKíe]rU(K4K@KBKAKBKBKBKDKDKCKDKDKGKGKGKGKGKGKFKFKGKGKGKGKGKDK>K=K=KIKAK4K=KK7K5K:KK4K,KIKDKAK?K5KK8KK4K2K3K3K3K1K.K2K:KSKSKBKBKEK>K6K-K$KKKK)KUKQKGKfK}KK€KK‚KHK*KdKaKPKHK`K‚KzK-K,KpK€KjKK@KKKNKLKBK=KAKCKIKNKMKMKSKUKTKSKNKNKFKcK…K‚KKKKKKKKK]KLKGKSK‚K‚KƒK„K‚KzKsKeKTKKKGKDKIKKKFK'K*K2K3K+K(K-K=K[KtK‚K„KƒK‚KUKGKK\K9K*K)K6KDKGKEKDKEKFKBK>K5K-K2K9KCKOKPKNKJKLKOKLK:KHKOK=KKKNKMKNKKKHK*K>KSKRKMKIKCKFKOKNK3K'K?KOKLKKKPKOKJKCKDKJKLKMKNKNKMKNKNKMKNKNKNKNKNKNKLKKKMKMKKKKKKKKKKKKKKKKKKKKKMKNKNKNKNKMKKKMKNKNKNKKKHKKKTKlKK¸KÕKçKìKéKæKæKçKèKÝKÁK›K{K^KMKIKLKQKRKOKKKNKOKOKMKGKBKAKGKPKTKSKVKMK3KKKKKK$KQKUKRKSKTK;K/K&KWK˜K”K‘KŽK‹K‰KŠK‹KˆK‰K‚K‚K†K€KsKoKuKpKcK_KeKgKbK^K`KOK?KJKQKTKYKcKnKnKnKlKlKkKmKoKlKkKlKkKiKiKiKiKiKiKiKcKcKeKbKdKdKdKeKfKdK`K_K]K]K]K\KZK[KZK[KZKWKXKZKtK™K–K•K¸KÁKÂKÍKÐKÏKÕKÚKÒKÙKÚKÓKßKäKÆKÌKÜKäKãKÜKÜKÞKÙKÜKßKßKåKíe]rV(K(K6KAK@K?KAKBKBKDKDKDKDKDKEKGKGKGKGKGKGKGKGKFKDKEKDKAK?K@KSKvKHK9K:K(K%KKKKK!K'K-K3K6K7K:K:K6K5K-K'KKK +KK7K=KKHKFKFKKK0K-K4K9K9K7K2K,K,KRKRKEK KKKKAKfKwK€K…KyKWKRKIKrK€K}K~K|KƒKGK"K^KcKMKIK_KK}K:K/KjKKƒK^KK7KTKMKGK#K7KK KKKK +KK K&KSKMKDKKKKK K KKK K KKBKPKKKHKFKEKNKSKSKQKTKRKSKUKSKNKNKGKUK}KƒKKƒK‚K‚K‚K‚KK‚KkKKKIKIK{K„K‚K‚K‚K‚K‚K‚KƒK‚KKwK[KHKHK-K%K1K;K@KDKDKBK;K0K)K*K5KLKTKHKCKAKxK‚K„K‡K…KtKYK>K1K0K:KGKKKGK;KCKEKBKK@KDKDKDKDKDKDKDKEKGKGKGKGKGKGKGKGKEKDKDKDKAK?K>K=K=K2KNK…K€KKK|KtKiKHKK!K5KK;K9K;K9K;KK*K3KJKDK@KK0K#K"KKKKKK$KMKGK9K1K2K0K'K"K"K"K+KMKNKAK2K*K+K,K.K.K0K/K6KQKMK>K5K1K2K/K&KKKK KQKRKDK>K`KAK0KhK…K~K|K}KtKWKRKHKsK‚KKK}KƒKIK"K^KeKOKKK_K€K~K?K.KfK€K‚K`KK2KTKPKIK+KKUK;KüKK KK +KK!KSKMKFKKKKKKKKKKKKAKPKNKAK,K.K2KBKKKMKSK[K_K^K]KSKNKHKOKuK‚K€KƒK‚K‚KK€K‚K„KrKKKKKIKvK„K‚K‚K‚K‚K‚K‚K‚K‚KƒK‡KnKIKKK2K$K0K;K@KCKDKHKGKCKAK;K3K)K3KGKGK@KnKŠK†KKK„K‰K…KrKUK>K1K5K@KFKJKGKCKCKDKCK:K3K.K,K0K:KGKGK>KNKNKMKKKKKLK*KIKPKRKMKHKBKGKNKMK;K/K]KÉKÍKÏK×KÕK¦KhKPKSKRKOKMKHKHKFKEKJKMKOKNKNKNKMKNKNKMKMKMKNKLKKKLKLKLKKKKKMKNKNKMKKKLKLKLKLKKKKKLKKKLKKKKKMKNKNKOKOKNKJKHKNKaKK¢KÅKàKêKêKåKäKêKëKèKÛKÁKŸKyKdKXKRKTKLK3K K#K*K,K-K,K&K'K&K&K&K,KNKTKRKSKSKBK+KEKK•K”K’K’KK‰K‡K‰K‡K‰K†K‚K~KoKiKjKlKlKjK`KWKVK]K^KLK4K?KCKLK[KnKoKnKoKoKoKnKnKnKoKnKlKkKkKkKlKjKiKkKkKjKhKfKgKdKdKdKhKeKdKbKaKcK`K`K^K\K]K\K[K[K[KXK[K]KgKƒK|KƒKˆK‹K®KÄKÁKÂK»KÐKÏKÄKÎKÃKßKáKÊK¿KÐKåK×KÎKÈKÏKÕKÕKÆK¨K°e]rY(KKK(K+K4K?K?KAKCKDKDKDKDKDKDKDKFKFKGKGKGKEKFKGKEKCKDKEKEKAK=K?K@K-KWK‚KzKzK{K|K~K…K]KK@K?K9K@KAK0K"KKKKK*K9K;K:KK(KKKKKKKK%KRKRKCKUK…KGK-KbK€K}K~KKvKWKRKHKsK‚KKK}KƒKMK%K^KeKPKKK^K€K€KDK/KfKK‚KhKK3KTKPKJK5K%KKK-KK K KKKK&KRKNKGK"KKKKK KK KK+K/KDKOKLKHK;K5K0K0K0K6K?KNK[KcKdKVKLKIKMKfKKKƒK‚K‚K€KK‚KƒKwKNKLKIKoK…K‚K‚K‚K‚K‚K‚K‚K‚K‚K…KwKKKKK7K%K1K:K?KCKDKFKEKFKFKFKDK@K;KFKIKAK;KUKrK‚K‡K„KK‚K†K‰K…KpKRKBKKBKFKIKFKDKAKAK@K:K4K-K*K$K5KPKMKMKLKKKPK-K=KQKRKQKJKCKEKMKOK@K:K¡KÐKÉKÉKÍKèKøK­KCKFKNKJKLKPKPKDKKDKEKFKHK?K7K2K9KLK\KTKLKIKJKcKwKƒK‚K‚K‚KƒKƒK‚K„K|KSKLKIKjK†K‚K‚K‚K‚K‚K‚K‚K‚K‚K„K{KNKKK>K$K.K7K>KBKEKGKGKGKFKFKDKDKBKGKJKDK/K$K-K>K[KuKƒKˆK†KƒK„K†KŠKqKEKDK0KK+K=KIKGKDKDKEKEK>K7KK&KRKMKNKNKLKPK4K0KRKRKQKLKDKBKNKSK@KeKÌKÊKÊKÊKÊKÜKëKÎKUK*K,KiKeKIKNKGKBKLKIKEKDKDKDKJKNKNKNKNKMKMKNKNKLKKKKKMKNKNKNKKKKKLKLKLKKKKKKKKKKKLKKKKKKKKKKKKKKKKKKKKKMKNKNKOKOKNKKKHKNK`K€K¨KËKáKëKéKåKâKåKéKêKÝKÁKKtKTK=K6K7K7K8K8K5K5K1K1K8KPKTKRKSKUK;K3K~K–K“K’K’KK‹K…K„KˆK‡KˆKK}KzKmKfKdKdKfKgK\KVKRKRKMK2K3K@KLKaKkKoKoKnKkKlKoKnKoKnKoKoKoKoKmKkKlKlKlKkKiKiKjKgKfKgKfKdKdKeKbKaKbKaK_K`K_K`K^K\K\K]K[KZK[K[KoK~KeKK“K…KŽK§K¶K¡K³KÇK¶K¯K½KÃKÚKØKÃKÉKÍKÜKÎKÈKÎKÓKÑKÍK·K‡e]r[(K$KKKK(K'K5KBKBKDKBKCKDKDKDKDKDKDKEKEKEKHKGKGKEKCKFKGKEKFKFK@K6K>KMKsK‚KK}K}K}KKBKKGK;K:KYKK~KKK„KlK5K)K9KK9K1KEKFKGKCK;K=K;KKKKKKKKK.KQKCK2KKKKKKKK"KNKJKK+K&K%K"K"KKKK&KPKRKDKTKƒKAK$KcKƒKKKKxKXKRKHKsK‚KKK~K„KXK-KXKeKOKKKWK~K‚KPK+K[K‚KK€KWK1KPKQKLK(KjKYKK!K!KKK&K'K-KLKNKKK4K'K)K&K(K&K&K'K'K#KK/KNKNKHK$KKKK#K,K9KEK?KPKNKHKKKKKFK[KeKtK„K…K‚KK‚KƒKKK]KJKIK\K…KK‚K‚K‚K‚K‚K‚K‚K‚KƒK„K\KHKFK(K*K3KK6K1KEKFKGK@K:K=K8K'K!KKKKKKK1KPKCK3K KK KKKKK'KQKIK;K$K K"K%K&K&K)K&K6KTKIKK:KHKpKK~KuK,K2KHK8K;KnK€KKKK€KXK-K+K;K;K=K;K:K5K'KEKGKAK?K6K6KFKFKFK@K9K=K8K'K!KKKKKKK2KOKCK1KKKKKKKK(KRKHK:K#K K K"K%K&K$K"K6KTKHK=K%KKKKKKKK'KRKRKDKWK„KBK$KcKƒKKK‚KxKTKPKJKrK‚KKK~K…KYK*KXKiKQKMKUKK…KXK*KWK‚KKKKyKSKOKKK.KKK K"K%K'K&K&K&K+KJKNKJK7K'K)K+K+K*K'K K$K+K+K3KLKMKKK2K%K%K%K'K$K#KKKKK2KLKKKFKLKPK`KNK(KBK_KzK‡K…K†KiKJKKKOK}K‚K‚KƒKƒKƒKƒK‚K‚KƒK‚K†KkKEKJK1K$K2K;K>KDKGKEKFKGKFKFKFKDKBKFKJK?KKK K"K%K1KK4K6KFKGKBKXKyK†KŠK†K‚KƒK†KŠK…KuK|KwKGKFKGKEKCKGK8K'KPKQKOKJKFKBKNKLKxKÐKÍKËKËKÌKÈKÀKéKìK|K“KÏKÊK¸K‰K…K‹KnKHK-KKÖKœKqKaKPKJKKKLKLKLKLKHKDKDKEKGKJKNKLKLKKKKKLKLKKKKKKKKKKKKKLKLKKKKKLKKKLKLKKKKKKKLKJKHKHKHKKKLKLKJKHKIKIKKKLKKKLKLKLKMKMKLKKKHKNKZKuK›KÁKÜKêKëKéKäKäKèKêKëKáKÆK©K†KjKEKKBK8KDKxK€KKK~K}KNK,K1K:K:KK2K8KEKCKDK>K:K>K5K!KKKKKKKKK8KIK~K€KKK€K|KKK-K2K:K9K9K;K?K2K-KEKDKBK>K2K8KDKCKDKK/K K"KKKKKK/KTKIK9KKKKK!K K!KK7KUKHK;K!K K!K K K K!K#K0KSKNKAKXK„KIK-KeKƒKKK‚KxKSKRKJKrK‚KKK~K„KbK*KTKkKOKLKQKzK†KcK+KNK€K~K…KTK'KMKRKMK5K K&K&K$K#K"K"K$K(K*KEKOKKK>K!KKK+K0K2K.K/K/K.K2KIKNKJKKEKDKDKDKBKDKDKCKDKCKCKHKCKFKrKK€KuKgKZKPKGK>K;K;K=KAKGKGKFK7K(K#K&K3KJKgK~K‰K‰K„KƒK†K\KCKGKFKGKDKFK&K@KPKOKMKIKCKIKQKQK°KÔKÍKÍKÔKˆKLKÎKòKÁKbK½KÑK—K[K„K–K—KUKKÌKÇK½KŠK‡K‘K‰KTK>K3KDKGKJKLKKKMKKK9K>KEKCKEKJKJKKKLKKKKKLKLKKKKKLKKKKKLKKKKKKKLKKKKKKKLKLKLKLKLKKKHKHKIKHKIKHKHKHKJKLKLKLKLKLKKKKKLKLKLKOKMKGKGKNK_K|K£KÅKàKíKìKæKáKáKåKêKîKåK×KÃK®KŸK“KŠK†K‚K‚K…KƒKsKsKyKmK`KeK_K]KVKPKOK2KK?KZKbKfKjKlKnKoKqKqKqKpKnKoKnKlKkKlKkKkKkKkKnKnKiKhKjKgKfKgKeKgKhKcKbKfKdKhKcKdKfKaK`K_K_K`K^KXK_K^K\KbK[KWK^K\KYKbKcKnK{KKxK|K‚KƒKƒK‘KºK¹KÈK¬K·K©K¿K¾KÁKÊKÂK~e]rb(K)K*K+K*K(K%KKK K)K1K5K4K:K>KAKCKBKBKBKBKCKCKEKEKEKFKGKDKDKFKEKEKDKDKDKCKDKCK>K;K7K,KKKKBKDKCKFK1K3KBKCKCKCKCKIKIKDKzK…K„K‡K…K€KrKcKYKNKGKAK=KDKFKFK7K;K3K.K'K"K+K8KQKmKƒK‰KŒKiKDKGKFKGKCKGK-K4KQKOKMKJKDKCKPKLK“KÕKÊKÎK¼KWKAK¬KñKÜKhK¨KÏKWK5KUK\KsKXKvKÊKÆKËKšK†KˆK‡KcKDK%K"KxKƒKVKLKJKJK7KBKKKGKBKBKDKGKJKLKLKKKKKKKKKLKKKKKLKKKKKLKKKLKKKKKKKKKKKKKLKKKJKJKHKIKHKJKJKHKIKJKJKJKJKJKLKKKJKIKHKIKJKKKMKLKKKHKJKSKkKŽK¶K×KçKìKèKâKàKâKçKéKèKáKÎKºK¦KKKyK‚KzKqKxKtKaKdK_KZKVKPKQK/KKKK[KcKfKiKlKnKoKoKoKoKoKnKoKnKkKkKlKlKlKlKnKoKmKkKiKhKfKeKgKhKgKgKdK`KcKhKgKdKbKcK_K]KaK_K[K[KXK`KaK\KbK]KVK^K]KWKWKVK_KqKtKrKjKiKqK|KgK›K²K¶K¶K¤K©K­KÇK¸KÁKÉKƒe]rc(K+K+K+K)K$KKK K&KKK3K7K7K8KBKDKBKAKAKBKCKCKCKCKCKFKGKDKEKHKEKCKDKDKCKDKCKDKAK=K>K>KIK9K7KVK‚KKKK‚KpKAK.K6K>K=K=K;K;K*K3KGKAK?K=K1K=KFKDKCK;K;K?K/KKKKKKKKKAKKK;K.K(K)KKKKKK1KQKGK8KKKKK K!K!KK9KRKIK;K"K#K$K$K$K&K&K%K1KQKNKAKXK…KHK-KdKƒKKK‚KxKTKQKIKrK‚KKKK‡KfK+KOKmKRKMKPK{K„KhK*KHK|KƒKQK$K%KHKRKKK;K$K&K&K&K'K)K)K(K)K&K=KQKLKBK1K2K0K0K0K0K0K3K2K1K3KEKNKKK@K1K2K-K!K!K)K$K$K!KKK2KNKJK=KK'KK'K,K&K*K*K*K-K/KFKMKLKBK3K:KOKkKK†K‡K…K„K„K„K…KaKEKHK+K)K5K=K@KDKCK3KKK9KBKCKCKBKHKIKBKnK†K‚K„K„K†KˆK…K}KpK`KVKNKFKDKDK9K;K=K6K3K3K1K*K&K*K:KSKsKsKHKFKGKGKDKFK5K*KQKPKMKJKGKBKNKKKuKÍKÉKÑK†KAKBK†KìKîKKK¤K4K2KLKTKPKNK]K¼KÉKÌK«KˆK‹KŒKtKNK1KBKÀK»K{KnKcKQKDKIKLKLKKKGKGKEKDKGKFKFKLKLKKKKKKKKKKKLKLKKKLKKKKKKKKKKKKKKKKKKKLKJKHKHKHKKKKKHKHKHKHKHKHKIKLKJKHKHKIKHKIKLKLKLKKKKKNKLKHKEKMK_KK¥KËKãKìKêKåKáKáKäKçKèKåKÙKÅK¨K’K†KmKmKzKdKcKbKXKVKOKPK,K(KPK]KcKfKiKlKoKoKnKnKnKnKnKoKnKlKlKlKlKkKlKpKpKkKhKhKfKgKgKhKjKfKfKeK`KbKfKgKeKaKbK^K\KcK_KZK[KZK^KeK^KaKbKYK]K^KXKYKWK[KhKyKpKkKjKhKhKYKsK¢K©K´K™K®K®KÆK¹K£KÁK–e]rd(K*K,K*K&K!KKK#K!KKKK/K8K8K;KAKCKAKBKAKCKEKDKEKGKEKDKFKFKDKDKDKDKDKCKCKCKDKDKBK=K>K:K6K7K]KƒK~KKK„KkK>K.K6K;K:K=KK*K8KGKAK?KK(K;KGKAK?K;K0K@KDKDKBK;K=K>K+KKKKKKKKKFKHK;K.K(K'KKK KKK6KRKFK2KKKKKKK K K=KRKHK;K&K&K%K%K(K)K)K'K4KTKPKDK[K†KHK-KeKƒK€KƒKƒKwKTKQKIKsK…K‚K‚K‚K†KkK*KIKmKQKOKNKzK‡KqK-KCKvKAK$K(K$KEKRKMKKAKBKEKBK>K@KAKDKDKBKGKJKBKYK‰K„K…K„K„K„K…K…K„K…K‡K‰KKOKFKCK?KIK>K8K5K6K=KCKBKAK=K/K(K?KEKCKDKCKCKDK&K@KPKQKNKJKAKGKQKPK¨KÖK„KK*KKKKKKKKKGKGK9K-K(K'KKK KKK9KRKCK0KKKKK!K K"K"K@KSKIK:K'K&K%K'K)K(K*K)K3KOKMKDK[K†KHK.KdK…K‚K‚KƒKwKTKQKIKsK…K‚K‚K‚K†KmK+KIKpKSKOKMKzK‡KrK/KAKMK(K(K$K$KCKPKKK=K(K&K$KKKKK$K+K,K;KOKLKEK1K1K3K2K5K4K3K3K4K5K5KCKMKLKBK"K&K'K"K"K KKKKKK*KOKIKIKKKKKKKK&K&K'K'K9KJKGKEK6K1K4K5K8K8K9K8K:KEKZKvK{KJKIKK:K;K;KBKJKLKCKCKGKGKGKDKCKGK-K6KQKMKMKIKDKEKQKJK“KÃKOK?KCKEK=KŸKðKâKrK9K2K.K1KFKLKMKLKgKÅKËKÉKºKŽK‹KKoKVKºKÈKÏK¥K;KCKbKmK\KKK5K&K8KUKQKKKKKMKLKJK7K=KBKAKBKFKLKLKLKLKKKLKLKKKKKKKKKKKKKKKLKLKLKKKLKKKIKIKHKIKHKHKHKHKHKIKHKHKHKHKIKIKIKIKHKIKIKIKIKIKHKHKIKIKJKKKLKIKHKJKYKxKžKÃKßKêKìKèKâKáKåKæKèKêKåKÓKµK’KjK6K4KKKYKaKhKjKjKjKfKgKkKmKqKmKmKoKmKjKiKjKkKpKqKmKiKfKgKeKiKjKiKjKfK`KaKfKkKgKfKgK]KZKaK^K]KaK[KVK[K]K`KdKeKeKaK\K\KXK\KYK]K[KUKUKVKWKPKPKWK\KZK}K˜KK‘KKÆKËK®K½KÙe]rg(K-K&K!KKK&K KKKKKKK K&K6K5K6K:KCKDKCK@KBKDKDKDKDKCKCKCKDKEKDKDKCKCKDKCKCKBKAKAKAK1K,KDKnKƒK~K€KƒK\K5K+K6K:K;K=K;K:K*K?KDKBK?K;K:KCKDKDKAK8K>K=K*KKKKKKKKKHKGK9K-K(K'KKKKKK:KQKBK/KKKKK K!K#K#K@KRKHK:K'K&K'K(K)K)K)K)K3KOKNKCK[K†KHK-KdK†K‚K‚KƒKwKTKQKIKsK…K‚K‚K‚K†KoK,KHKpKRKNKMKyK†KrK3K6K-K(K(K%K%KBKPKKK>K#KKKK K(K+K,K,K*K9KOKLKFK6K1K3K4K6K7K7K7K7K5K5KBKLKLKEKKKKKKKKKKKK!KJKIKIK%KKK +KKKKKK$K&K4KIKHKEK8K2K4K5K6K7K9K:K;K9K6KK6K8KDKmK„K€K~KVK4K+K6K;K>K=K;K9K7K@KFKBK?K=K?KCKDKDKAK;K>K;K&KKKKKKKKKIKGK:K-K(K%KKKKKK=KPK@K/KKKKKK!K%K%KAKQKEK9K'K&K*K)K(K)K'K'K4KPKOKAK[K‡KHK*KcK†K‚K‚KƒKwKTKQKIKsK…K‚K‚K‚K†KqK,KEKpKQKPKJKvK†KwK6K/K)K(K&K&K!K>KQKLK?KKK"K)K,K+K*K*K+K'K5KNKLKFK8K4K7K7K8K8K8K8K7K9K6KKMKIK1KKKKKK"K%K'K&K K!KEKJKHK;K&K.K2K2K1K4K5K6K6K6K9K8K>KGKGK-K&K0K:K@KCKBKEKGKGKGKGKGKCKAKDKIKAK]K‰K‡K‡KˆKˆKˆKˆKˆKˆKˆK‡K‰K†KSKDKAKZKŠK‡K‡K‡K‡K‰KˆK…KKtKhK^KJKEKGKDKCKCKFK*K6KPKMKMKHKBKAKKKLKEK?K>K?KBKCK@K¨KðKåK{K;K1K/K0KBKHKKKLKaK¾KËKÇK¿K„K…K’KKOK¥KÎKÈK¾K{KiK[KkKwKMKeKÃKÅKÉK£KoKdKZKYKaKQKDKFKHKKKJKJKJKJKGKGKDKBKAKBKFKLKMKLKLKLKLKKKLKKKHKHKHKHKHKIKHKHKHKIKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKIKIKIKHKIKIKIKIKIKHKHKIKIKLKLKIKFKFKLK`K‚KªKËKãKîKëKåKâKàKáKäKéKìKêKÝKÇK«KKwKnKiKiKjKjKmKrKrKkKcKfKjKjKlKlKgKbK^K^KcKhKlKkKjKbK[K`K]KZKbK`KcKaK[KWKVK_KbKeKfK`KXK]KdK_K[KUK[K`K_KTKQKMKLKYK\K_K]K`K_K}KzKpKºKÁKƒKe]rk(KKK#K%KKKKKKK +K%K8K5K4K0K/KKK!K)K(K1KAKCKBKBKBKDKCKAKBKBKBKBKBKBKBKBKBKBKAKBKAKBK@K?K=K8K7K?K^KGK-K-K9K=K=K>K=K:K7KBKBKAK=K;K?KCKDKFKKBKCKDKDKDKDKDKDKDKAKEKIKCKUKˆK‡K‡KˆKˆKˆKˆKˆKˆKˆKˆKˆKŠK]KCKCKLK„K‡KˆK‰K‰K‰KˆK‰K‰K‹K†K~KaKEKGKFKFKCKFK4K.KOKLKMKIKFK@KHKMKHK?K?K?KAKAKSKÂKçKìKŸKBK5K1K-K=KFKHKMKQK§KÌKÌK‰KbKzKrK^KKK…KÏKÇKÇK KKK€KrKWKbK¿KÇKÆK¹K…KxKtKlKfK]KLK=K'K8KCKEKIKLKIKHKGKGKCK9KAK@KCKHKIKKKJKLKLKKKKKKKKKKKKKIKIKKKJKHKIKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKIKIKIKHKGKHKIKIKHKGKGKIKIKIKGKGKHKHKHKJKLKKKHKDKFKVKrKšK¿KÝKêKíKèKåKãKáKãKåKéKêKáKÐKºKœKKlKiKkKqKrKjKfKgKiKkKlKlKgK[K`KcKfKlKnKjKgKaKZK\KaKZK_KdKdK`K[K[KVK^KbKcKhKbK[KZKaKbK]KVK[K^KdKXKSKRKOKZKaKcKbKbK_KtKƒKhK¦KÙK†Kne]rl(KKK%KKKKKKK KK7K4K4K3K1K'KKKKK%K*K3KAKBKAKBKCKCKAKBKBKBKAKAKAKAKBKBKAKAKBKAKBK@K?K?KKAKDKCKCKCKCKCKCKDKCKDKFKEKMKKˆK‡KˆKˆKˆKˆKˆKˆKˆKˆK‡K‹KjKBKDKAK|KŠK‡KŠKŠKŠKŠKŠKˆK‡K‡KK~KIKFKGKFKDKDK=K&KJKMKMKJKGK>KDKNKJK?K>K>KBK?K†KÐKßKíKÁKOK8K2K-K6KFKHKNKLK‰KÐK¼KRK=KHK;K>KLKhKÇKÈKÉK¬K‰KKŽK‘KqKKK£KÌKÄKÅK†KbKdK`KaKfKQKGK&KK?K”KdKGKHKHKJKJKAK1K@KDK@K@K@KCKHKLKMKKKLKKKLKLKLKIKIKLKKKIKIKIKIKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKFKHKHKHKHKFKGKHKHKHKGKFKHKHKIKHKGKGKHKHKIKHKDKDKMKbK…K­KÏKåKêKéKåKâKàKáKãKäKèKçKßKÇK®K”K~KnKaKbKgKkKlKlKjKcKZK_KeKgKlKmKkKfKaK[KXKbK[K]KeKdK`K[K[KUKZKaKcKiKbK\KZKbKeK`KZK]K^KhK]KZKZKQKWKdKfKeKaK_KbKKiKvKÄK«Kle]rm(KK$K$KKKKKKKK5K:K7K1K0K&K,KKKKKK'K/K7KAKDKCKDKCKAKBKBK@K>KBKAKAKBKBKCKDKBK@KBKAKBK?K?K=K:K7K8K0K,K7K:K:KK=K:K9K5KKKK%K"K'KFKMKJKKVKKKJKHKzK‰K†KGK0K(KKKKKK3KLKHKGK-K%K&K"KKKK(K1K5K7K5K9KGKJK>K+K/K7K>KBKDKCKDKDKCKCKCKDKCKCKGKFKFKyK‰KˆK‡KˆKˆKˆKˆKˆKˆK‡K‡K‹KwKEKHKAKpK‹K‡KŠKŠKŠKŠKŠKŠK‰K‰K‰K…KRKCKDKDKCKDKCK#KDKOKNKLKHK@KCKOKLKBK>K?K?KSK»KÊKÛKêKÝKfK9K3K.K1KFKKKLKLKkKÍKK5K;KDKSKxKqKRK³KÌKÇK¼KŽKKŒKK‚KKKKÎKÄKÊKªK…KƒKrKhKFKCKNK:K#KuKÔK—KVKVKQKJKGKGK6KBKJKIKGKEKAK?KAKEKGKJKKKLKKKKKKKKKLKKKLKJKHKIKIKHKHKHKHKHKHKHKHKHKHKHKIKGKFKFKGKIKGKFKHKHKGKGKGKGKGKGKFKGKGKGKGKGKFKFKFKGKGKIKJKIKFKEKGKWKuKKÁKÝKëKìKæKâKáKáKâKäKèKéKåK×K¿KŸK€KmKhKhKkKhKaK\K]KcKgKnKmKjKfKbK^KWKaK`KZKeKbK_K^K]KXKYK`KdKlKgK_K^KfKhKfK_KbK`KjKcK[K\KTKUKaKhKfKaK_KbKpKdK^KvK¢Kte]rn(K"K"KKKKKKK K,K>K;K:K2K(K'K>KKK%K&K$K K(K.K9KBKDKCKCKBKBK@K?K>KAKAKAKBKBKCKCKBK@KBKBKBK@K?K;K?K9K3K3K,K6K9K;K=KK;K:K6KKK%K&K$K$K,KFKMKKKAK/K0K/K/K0K4K8K2K1K8KKwKHKKKFKvK‡KˆKEK$KSK\K4KKKK(KLKIKFK2K,K-K*K&K$KKKK#K.K3K7KEKJKCK8K8K8K=KAKDKDKBKCKDKDKDKDKBKDKGKGKCKoKŠK‡K‡KˆK‡KˆKˆKˆKˆKˆK‡K‰K‚KJKFK>KdKK‡KŠKŠKŠKŠKŠKŠKŠKŠK‰KŠK[KAKDKCKCKCKDK9KCKMKMKLKIKCKAKJKKKDK=KAK?K†KÐKÇKÕKçKëKˆK=K6K0K-K@KIKHKJKUK®K]K2K:KvKKKƒKPK’KÍKÄKÅK™K‹KKŽKŽKZK`KÃKÇKÈK¸KKKŠKKwKIKLKDK7K©KËK´KcKVK[K^K[KOKFKHKHKGKGKHKFKDKBK@K@KCKHKJKLKMKLKKKKKKKLKJKIKIKHKIKIKHKHKHKHKHKHKHKHKHKIKGKGKFKGKHKGKFKHKHKGKFKGKFKFKFKGKGKFKGKFKDKFKGKGKGKFKGKHKGKGKIKHKFKCKBKNKdK‰K³KÐKçKìKéKäKãKáKãKäKæKêKéKâKÍK±K”KzKdKWKZK^KfKkKqKnKkKfKbK_KWK`KeKZKaKfK`K^K^K\K]KaKdKnKnKcK`KfKlKkKdKbK`KkKeK^K^KUKUK\KeKfK`K\K`K]KaKzKŒK˜Kˆe]ro(K%KKKKKKK K K7K9K=K;K1K!KK>K>K@KBKBKBKBKBKBKBKBKBKAKBKBK:K>K=K9K1K%K4K9KK:K7K>KCKDKDK2K.K?KGK@K1KKKKKKK2KNK?K1K)K)KKKKKKKGKJK>K'KKKK K#K$K!K%KIKOKCK4K'K)K)K(K)K)K)K'K3KOKMKCK^KŠKJK,KbK…K‚K‚K†KyKQKPKGKqK…KK‚K„K†K|K2K9KoKVKKKJKBK.K+K(K$K$K$K'K)K'K8KQKMKHKeKeKQKDK?KBK@K:K5K8K:KJKNKJKGK>K:K9K#KK K$K#K%K)K,KEKMKJKCK1K0K0K0K3K6K8K5K3K?KuK{KJKJKEKqK‡KˆKQKKUK‹K€KhKGK%K'KJKIKIK2K)K.K+K,K+K&K%K"KKK K-KCKJKFK:K8K7K9K=K?KBKAKCKDKGKFKCKCKDKFKHKCKdKŒK‡K‡K‡KˆKˆKˆK‡K‰KŠKˆK‡KˆKSKAKAKTKŒK‰K‰KŠKŠKŠKŠKŠKŠKŠKˆKŒKjKBKDKDKCKDKCKGKEKKKLKLKJKGK?KHKKKHK@K@KQK¸KÌKÉKÑKäKïK­KFK5K2K-K:KFK@K9KMKbK?K8K5KoKK‹KŒK[KhKÃKÅKÇK¨KŠKKŽK’KoKLKªKËKÄKÅKšK‡KˆKˆKˆK{KQKDKhKÈKÅKÈKƒK`K[KYKiKtKbKJKJKJKIKGKFKHKJKGKEKCKAK?KBKIKJKIKHKIKLKKKLKIKHKHKHKIKHKHKHKHKHKHKHKHKHKIKHKGKFKFKFKGKFKFKFKFKFKFKGKFKGKGKDKGKGKGKGKFKFKFKGKFKFKHKEKFKGKGKHKHKHKDKCKHKXKzK¢KÆKßKëKêKæKãKáKáKâKäKçKèKåK×K¿KK€KiKfKjKnKnKlKhKbK`K[K`KgK]K_KiKdKaK_KaKaKdKiKnKpKeKbKhKlKlKhKbK^KfKfK`K^KYKYK[K]KdK_K_K_K\K‰KžK¯K«KŒe]rp(K"KKKKKK KK9K9K;KK=K=K3K"K4K:K;K=K;K%K7KEKBK?K:K,KK(KKKK!K!K$K!K&KIKNKCK4K'K'K'K)K(K'K(K'K3KOKMKCK^KŠKJK,KbK…K‚KƒK†KzKRKOKHKrK…K‚KƒK„K†K}K3K6KnKXKNKKK9K,K+K)K'K(K*K+K,K.K=KOKMKIKNK:K KKKKKKK'K/KFKPKKKFKK5K4K5K7K9KK@KBKBKBKBKBKBKBKAKAK@K;K=K=K;K8K0K1K:K:K=K;K!K:KCKBKAK9K1KAKCKAKCKDK?K=KDKHKGKIKKK=K%KKK7KOK>K1K&K'KKKKKKKKKHK>K&KKKK!K K$K"K'KHKNKCK4K'K&K&K)K'K%K(K'K3KPKMKCK^KŠKKK,KbK…KƒK…K…KzKSKNKJKsK…KƒK…K„K†K~K6K5KnKYKPKLK:K)K+K+K,K)K"KKKK5KMKLKHKZK^KjKZK#K"KKKKKK?KQKLKEKK?KCKDKDKCKGKFKDKAKDKNKbKwK…KŒK‰K‡K‡K‡K‰K‰K‹KnKBKDKAKyKK‰KŠKŠKŠKŠKŠKŠKŠK‰K‹KƒKMKBKDKDKCKCKDKDKGKMKNKLKGK@KCKLKMKCKNK·KÎKÊKËKÉKÛKéKáKrK;K2K.K/K5K$K"K7KNKK:K0KCKBKAKBKFKFKCKDK>KBKHKIKKKHK7KK7KMKK@KBKFKIKIKIKHKIKHKHKIKHKHKHKHKHKIKHKHKHKGKGKFKHKHKGKGKGKGKFKGKGKGKFKFKFKFKFKFKFKFKFKGKGKGKFKGKGKFKGKGKEKDKDKEKGKEKDKFKHKHKFKBKCKDKTKqK–K½KÛKéKéKåKáKáKàKàKáKâKæKèKâKÔK·KK‚KkKjKiKgKnKkKdKaKfKkKhKdKmKlKeKhKgKeKdKgKgK_KhK_KbKcKfKYKXK_KfKcK_KYK\KgKoK€K§e]rs(KKKKK +KKK;K2K+K%KKKK&K(K/K?KBKAKAKBKAK?K?K?K>K?KAKBKBKBKBK@KK@K8K5KK9K1KBKAKBKBKDKCKFKDK;K?K?KGKHKJKMKBKCKIK;K/K%K'KKKKKK!KMKIK:K"KKKK!K#K$K K(KLKNKCK2K$K&K&K(K'K&K%K K4KOKLKFK^K‰KJK,KbK…KƒK„K‡KyKRKOKIKpKˆK„K„K„K…KK9K5KlK[KNKLKKAK4K>KpK¥KtKK@KCKBKAKAK?K>K>KAKBKBKBK@K>K>K=K;K;K=K4K5K:K:K?K5K&KBKAK?K?K6K1KAKCKCKCKEK9K>KCK?KHKFKCKDKHKKKKKKKIK?K/K%K'KKKKKK$KNKHK>K#KKKK!K"K$K#K*KLKMKCK2K$K&K%K%K'K%K(K'K5KNKLKDK^KŠKKK)K`K…KƒK„K‡KyKQKPKIKqKˆK„K„K„K…K€K;K3KkK^KLKKK9K%K(K+K,K,K.K'K%K!K%KMKPKKK[K~KK—K¦K¼KßKÜK¶KKVK;KPKNKHKKKKK$K*K'K'K*K,K4K^KOKKKOKŠKfKDK›KãKäKßKíK¯K*KTKŠK`KJKJKSKƒKˆKK6K.KqK‰K‡K‡K†K‰KjKFKJKAKEK‚KŒKK`K?K'KK"K*K2K9K;KEKJKEK8K1K0K+K&K K!K)K1K6K8K;K=KK8KFKFKFKGKDK@K?K?K@KDKGKIKGKHKHKHKHKIKHKHKIKHKFKFKFKIKHKFKFKFKFKGKFKFKFKFKFKFKFKFKFKFKFKGKEKCKFKFKCKDKGKEKCKDKDKDKDKDKDKDKDKDKDKDKDKDKCKFKHKIKHKCK?KDKYKzK¡KÆKÝKéKçKãKàKáKáKàKáKâKãKäKàKÏK¼KžKKoKeKeKgKiKnKpKlKcKeKhKjKgKcKgKbKhK^KaKaKgK`K_KgKeKcK_K[KXKMK?K0e]ru(KKK K K,K=KK=K>K5K6K;K;K>K1K(KCKAK?K>K6K2KBKCKCKCKEKDKFKAKAKJKNKQKJKBKEKIKCKFKMKDK3K&KKKKKK%KMKGK=K"KKKK!K"K$K"K+KLKMKCK2K%K&K%K%K&K%K'K'K6KNKLKEK_KŠKKK)K`K†KƒK„K‡KyKQKPKFKoKˆK„K„K„K…K„K>K1KkK_KLKLK=K+K/K0K0K.K*K&K"KK%KJKOKGK‰KÁK¶K³K¬K­K·KÆKÔKßKÒKˆKLKNKIKKKKK K-K0K=K5K-K4KOKQKKKLK­K·KKKHK´KéKåKíK€K!KMK‰KfKIKKKNK€KˆK‡K@K*KhKŠK‡K‡K‡K‰KqKJKMKEKAKyK‰KˆKK‡KqKKK.K!K&K*K3KDKHKFK>K7K3K2K1K-K$K#K!K%K0K6K;K:K>KEKEKCKAKAKCKDKDKDKDKFKGKDKDKKK[KsK]KCKCKEK‚K‹K‰KŠKŠKŠKŠKŠKŠKŠK‰KKƒKJKBKDKDKCKCKGK?KHKOKMKJKGKCKFKNKLK¥KÑKÊKËKËKËKÉKÚKéKèK|KK4K#KAKCK+K"K1K7K7K8K9K8K2K.K/K0K3K3K(K#K#KKK+K-K0K=KBKAKAKBKBKBKBKBKBKBKBKBK@K9K@KCKBKAK=K5K6KK5K4KDKCKCKCKDKJKJK@KAKKKOKQKRKPKIKBK7KDKNKLKKK?K KKKKK(KOKFK;K"KKKK!K"K$K!K,KMKLKEK2K%K&K&K&K%K%K'K&K8KPKLKFKaK‹KJK)K`KˆK„K„K‡KyKRKOKHKoKˆK„K„K„K„K„K?K.KjK`KLKOK?K.K/K/K.K(K$K"KK K,KIKMKIKsK£K¡K¡K¦K¬KµKºKÀKÄKÖK¸KOKNKMKKKKKK&K3K›KÉK\K,KFKNKNKIK¡K×K‰K6KkKÒKåKØKnK#KEK†KkKIKIKJK~K‰K‹KIK&K_KŠK‡KˆK‡KŠKyKKKJKFK=KrK‹K†K†K‡K‹K‰KxKXK3K'K$KKBKBKBKDKDKCKEKGKGKFKEKGKHKDKDK@KxKŽK‰KŒKKKŠK‰KKŒK‰K‹K‰KUKCKFKFKDKDKCKDKGKNKNKKKIKEKCKOKJK‹KÐKÉKËKËKËKÈKÒKæKðKŸKCK4K/K*K8KFKFKHKNK?K5K7K5KlK“KŽKKcKFKK@KBKBKBK?K;KBKAK8K8K:K7K9KKLK]KlK}KK˜K¦K³KÂK±KUKNKHK¦K¶KPK"K&K*K%K&KnKÛKlKEKMKOKHKˆKÆK¾KZK@KKÆK’KwK.K:K}KwKHKJKEKrKŠKŒK_K'KQK†KˆK‡K‡KˆK…KRKIKJK?KaK‹K‡KŠKŠKŠKŠKˆKŠKTK'KRKiKGKIKEK;KIKPKGK>K:K7K7K5K4K3K5K2K)K6KEKBK>K;K=K?K?KAKBKCKCKCKCKCKGKGKGKEKDKAK?KOKgK~K‹KŒKŽKŒK‹KŒKKŒK‘KqKBKDKCKCKDKCKHKDKLKOKNKKKFKCKIKMKVK»KÎKÊKËKËKËKÊKÞKèK×KeK8K1K-K,KAKGKIKMKLK:K7K=K™KžK‹KK€KNKBK8K6KAK‚KKŽKKKaKVKµKÆKXKFKŒK~KƒKŽK‹K‚KWKQK²KÉKÄKÇK¨KˆKWKLKNKNKNKMKNK§KÍKÃKÍK¢KFKOK\KjKiKbKYKVKKKIK6K&K8KFKCKDKIKIKIKGKGKFKCKAK@K?K?K@KDKIKIKIKIKHKHKIKHKFKFKFKHKIKFKFKGKFKFKFKFKFKFKFKFKFKFKFKFKGKFKGKGKDKCKDKCKCKCKDKCKDKEKBKCKDKCKCKCKCKDKDKDKDKCKDKDKBKCKEKGKGKHKFKDKCKBKNKdK‰K®KÏKáKçKæKâKàKáKáKáKáKâKåKæKãKØKÄKŸKaK.KKKKK K +KKKKKKKKKKKe]ry(K K)K=K;K9KK>K(K)K6K8K:K;KKBKBK@K?K>K@KBKBKCK?K:KBK@KK1K:KEKBKBKCKDK;KFK@KDKPKQKPKPKQKRKRKSKRKQKIKFKGKHKKKNKMK?K:KLKEK9KKKKK!K"K$K!K-KMKKK@K,K$K&K%K%K%K%K&K#K6KPKMKDKbKŠKKK)K`KˆK„K„K†KzKQKOKGKmK‹K…K„K„K…KˆKDK.KfKbKLKMKFK1K/K1K1K0K0K0K1K2K3KIKMKMKDK4K4K3K2K6KIKhK~K™KÀK§KVKNKMKmKªKÆKK@K,K2K)K,KšK¬KNKLKPKHK|K½K¯KYKK@KBKAKBKCKDKDKDKDKDKDK>KCKDKIKZKnKƒKŽKŽKKŒK‹KKKEKCKDKCKDKCKFKDKKKOKLKKKHKBKGKNKKK£KÒKÉKËKËKÉKÈKÓKÙKØKzK;K2K/K*K?KGKGKJKMK@K5KaKÃK£K‹KŠK‹KYKCK7K9K6KlK”KŽKŽK“KuKHK¡KªK:K:KxKŽK{K„K–KŒKhKGK‘KÊKÃKÇK±K”KgKLKNKLKLKMKFKKÌKÆKÂK¬KYKDKDKJKWKfKlKeKOKHKAK KK"KgKnKIKEKFKIKHKGKFKFKEKEK>K8K=K=K@KDKHKIKHKIKHKHKGKFKGKGKHKHKFKGKFKFKFKFKGKFKFKFKFKFKFKFKGKEKDKDKCKCKCKCKCKCKCKDKDKCKCKCKCKDKDKDKCKBKBKBKBKBKDKDKDKCKDKDKDKCKEKGKGKGKCKAKHKZKwKKÁKÚKçKåKàKÞKÞKàKàKàKàKâKæKçKâKÎK§KsK?KKKKK K +KKKKKKKKe]rz(K"K9K:K9K;K2K K;KAK*K$K3K5K9K9K:K9K1K%KKKKK!K8K8K5K/K)K)K$K K K%K1K3K3K5K>KBK?K?K>K?KBK@K@K>K;KDK=KK°K—KPKNKGKyKÓK³KUK@K“KžK‡K…K7K-KrK„KNKLKDKdKŠK‹KsK(K@K€K‰K‰KŠK‡K‹K_KEKKKBKRKˆK‹KŠKŠKŠKŠKˆKŽKqK*K?K}KTKEKDKXKkKDK.K7KLKSKMKFKBK;K8K7K8K>KGKFKCK4K'K'K.K9KKAKBK@K@KCKCKCKCKDKDK?KEKHKHKGKGKPKcKxK‰K‘KŽKK‡KNKAKDKDKCKCKEK@KFKPKKKKKHKDKCKNKJK‡KÏKÉKËKÊKÈKÈKËKÑKÁK}KFK4K/K)K6KDKGKIKMKFK9K—KÍK­KŒKŽKKnKHK;K:K5KUK‘KŽKŽKK†KMKvKpK3K6KeKKK‘K—K’K|KIKoKÅKÄKÈK¸K‹KyKMKMKLKLKLKJK_K¿KÇKÁKÈK‚KAKHKHKGKEKNKbK]KEKFK1K K,K®KÂKnK]KRKFKFKGKGKGKEKDKK;K=KBKGKIKIKHKGKFKFKGKHKHKFKGKFKFKFKGKFKGKFKFKFKFKFKFKGKEKCKDKDKDKDKDKDKDKDKDKCKDKCKCKDKCKCKDKCKAKAKAKAKBKCKDKDKBKCKCKCKDKCKBKCKEKFKFKDKEKBKBKNKjKK³KÔKäKæKáKÝKÜKàKáKáKßKßKäKéKêKÛK¼K’K_K0KKKKK +K +K KKKe]r{(K6KK>K>K?KBKAK>KKBKAKAKDKGKFKJK=KGKPKPKQKPKQKSKRKRKSKRKPKRKSKMKIKEKHKJKKKKKIK@K$KKKK K"K$K#K0KMKIK@K-K#K&K%K%K%K&K$KK7KPKKKBKbK‹KJK)K`KˆK„K„K†KzKRKOKHKjKˆK…K„K‡K‡K‰KIK)KeKgKOKLKWK‡KUK-K2K2K3K3K2K0K0KCKMKKKDK*K7KaKK¦K­K²K¯K­K¿KÂKaKLKHK‘KçKÇK‘K¯K·KRK8K3K(KYKËKtKIKGKyKáK¸KXKEKK“KˆKŒKCK)KiK‰KSKKKEKaKŠKŠK{K0KK:K7KKK‡K“KKK’K‹KVKUKµKÈKÅKÈKhKsK`KIKMKLKLKLKJK KÊKÂKÆKŸKJKHKGKGKGKEKCKHKIKIK=K!KZKÅKÆK‹KdKyKkKSKHKEKFKFKGK=K,KK=KKBKDKGKGKHKHKGKGKFKFKFKFKGKGKEKGKFKFKFKFKFKFKGKFKFKFKFKDKCKCKCKCKCKCKCKCKCKCKDKBKAKCKCKAKAKAKCKDKCKDKDKCKDKDKDKDKDK@KBKDKCKCKEKFKIKHKFKBK@KIK]KƒKªKËKàKæKæKàKÝKÞKáKàKßKßKáKäKêKæKÕK¬KzKIKKKKKK +K e]r|(K9K=K:K;K%K)K?K6K$K.K4K6K:K9K9K7K*K!KKKKK2K>K7K4K-K(K'K"K"K#K4K9K)K&K.K2K3K8K=K?K?K@KAK@K>KKCKAKAKEKFKDKJK=KHKQKQKQKPKQKSKRKRKRKRKQKRKRKSKQKNKJKEKBK;KJKMKGK3K!KK!K#K$K#K1KMKHK?K,K#K&K%K&K%K%K$K!K7KPKJKBKbKŒKKK)K`K‡K„K…K‡KzKQKPKIKjK‰K…K…K‡K‡K‰KIK)KeKhKPKLKVK…K‚KKK,K2K2K2K4K5K3KCKMKKKEK1KK2KsKfKCKFKLK…K‹KŒKKdK2K1K3K@KOKQKIKCKAKDKEKDK@K8K8K8K5K.K*K)K1K:K?K@K?KCKDKCKGKCKAKGKFKGKHKIKIKHKGKEKLK]KyKeK@KDKCKEKCKDK2K+KMKLKNKKKEK@KIKLKVK¸KÍKÈKÉKÉKÇKÌK¬KqKeKUKK8K7K;KK•K‹K‚KŠK”KhKGK”KËKÂKÐK}K>KdKHKIKIKKKLKFKxKÉKÃKÃK»KbKCKHKFKGKGKGKGKIKIKGK,KˆKËKÄK­K^K_KoKxKpK^KMKFKGKEK:KCKFKEKDKCKBKAK>KK;K'K'K1K3K7K9K:K7K/K"KKKKK-K@K:K6K.K)K'K#K!K K,K9K+K&K(K$K)K2K6K:K>KBKAK>K@K?K9K=KDK6K.K=K9K7K;K=K=K8K#KK8K.KAKDKBKBKFKGKHKIK=KIKPKSKRKPKQKSKSKSKPKQKSKRKSKSKSKSKSKOKDKK1KnK‹KˆKŠK‰KŒKxKHKIKFKCKxKK‰KŠKŠKŠK‰KŠKŠKGK/KkKpKGKIKEK|KŒK‡KŽKrK1K>K[KFK1K=KLKRKNKGKEKDKBK8K6K7K8K:K9K2K+K(K*K5K=K>KBKEKEKAK?KFKGKGKFKFKGKHKIKJKHKEKFKIKCKDKDKCKDKCK>K KFKLKLKKKFKBKFKNKMK£KÐKÈKÈKÉKÈKÍK°KfKaKVKBK0K0K,K=KIKIKLKLKœKËKÄKÆK©KK‘KKgKFK:K;K:K^K‘K‘K‘K”K€KNKDK5K7K4KiK–KK†KŒK–K}KJKsKÅKÃKÊKwKK@KMKHKIKHKJKLKZK¹KÆKÅKÌK‡KBKHKFKGKFKGKFKFKIKGKJK°KÆKÃKÄK~KZKYKbKoKwKmK\KMKEKGKGKFKGKEKCKDKDKDKCK=KK>K>K8K?KBK;K:KK8K0KBKDKCKBKEKIKKKHK=KFKMKRKQKPKQKRKQKQKQKRKRKRKRKRKRKRKRKUKPKIKFKFKJKLKNKKKAK0K"K K1KOKIK>K+K$K%K&K%K&K$K%K$K6KQKNKDKaKŽKMK)K`K‰K†K‡K‰KyKPKQKEKfK‹K‡K‡KˆK†KŒKPK(KaKkKNKNKVK…KŠK|K5K/K/K0K3K5K4KBKLKLKJK9K7K7K7K7K5K5K5K0K+K-KEKQKIKcK¶KÆKÐKÕKÙKàKàK¨KgK?K,KFKPKJK\KºKŸKkKnKKˆKˆKŽK[K#KPK‹KcKHKKKOK„KŠK‹KJK,KgKK‰K‰K‰KŒKKLKHKHKAKpKK‰KŠKŠKŠKŠK‰KKTK-K]KyKFKHKBKsKŽKŠKK|K5K8K|KKuKVK?K8KDKNKGKEKCK@K;K8K6K8K9K9K:K5K,K(K)K0K9KBKDKBK=KDKEKEKFKFKEKIKHKGKIKKKHKFKDKCKDKCKDKBKBK!K=KNKLKKKGKCKEKLKHK†KÏKÉKÊKÉKÉKÊKÀKnK`KWKJK5K1K.K6KEKJKMKJK~KÊKÄKÆK·K“KK’KxKMK?KK;K;K?KCKFKHKGKFKFKFKFKGKFKFKFKFKFKFKFKFKGKFKEKEKGKFKEKCKBKCKDKCKCKCKCKCKDKCKCKBKAKCKDKCKCKBKCKDKBKAKBKCKBKBKBKCKDKCKCKDKDKDKCKCKDKCKCKDKDKEKFKDKAK>KDKPK[KiKqKzK„K‰KK—K K¨K¯K¶K¹KÀKÉKÕKÜKØe]r(K8K5KK0KBK0K!K.K0K5K;K=K9K6K)KKKKK$K9K:K7K2K*K*K%K!K K'K:K2K*K)K$KKKKK#K3K:K:K=K?K=K=K9K?KAK;K=KK4K%K>KAKAK>K8K2KCKDKDKCKFK>K?KHK=KFKMKQKPKQKPKPKPKPKRKSKSKSKRKRKRKRKRKRKSKQKOKJKGKHKJKMKNKLK>K)K2KMKIKAK+K$K&K&K%K'K&K%K#K7KPKMKCKaKŽKMK*K`KŠK‡K‡K‰KyKPKQKIKfK‹KˆK‡KˆK†KŒKOK'K_KkKOKNKTK…KŠK~K2K3K7K.K4K6K4K@KLKLKKK8K3K4K4K4K0K,K(K6KeKyK`KMKLK\K›K³KÎKÐKÐKÐKÄKÂKÊK•K:K>KPKKKQKžK K|K}KK‰K‰KŽKeK%KJK‹KkKHKKKMK€K‹KKTK,K_KKŠK‰K‰K‹K…KRKGKGKCKgKŽK‰KŠK‰K‰K‰KˆKKaK/KTK}KIKFKBKhKKŒKŒK‡K@K2KmKKKŽKKcKAK=KHKGKAKFKGK@K=K9K8K9K9K8K9K9K-K'K&K8KEKDK=K?KAK@KCKGKGKFKFKFKGKHKGKGKDKBKDKDKDKAKEK)K2KOKLKLKIKDKCKKKKKkKÈKÊKËKÉKÉKÈKÉK„K[K\KPK:K2K.KPKaKHKJKMKbKÀKÇKÄKÀK™KKK‡KUKDK>K:K’K¨KŒK’KKKkKIK?K5K6K=KuK‹K‹K“K–K•KgKDK’KÏK‘K4KEKGKAKJKIKHKJKMKEKrKÇKÄKÄKÄKfKBKHKGKGK>K;KDKFKIKOK¬KÊKÃKÆK¸KZKVKgKcKaK_K]KcKeK^KGKAKCKFKJKFKCKCKDKDKDKDKBKBK@K=K=KK1K&K>KBK@K>K8K3KBKBKCKDKCKBKFKFK=KGKMKOKQKQKPKQKQKQKRKRKQKRKSKRKRKRKRKRKSKRKSKRKMKHKGKIKKKKKOKHK?KDKEK>K,K$K%K&K&K%K$K%K#K7KPKKKDKdKKMK'K_KŠK‡K‡KŠK{KPKQKIKfK‰K†KˆK‡K‡KKRK&K]KmKOKMKQK€KŠK€K2K4KfKTK0K3K5KCKNKJKKK8K4K1K-K+K*K*K1KCKcKžKwKIKMKUKK–K KµKÁKÈKÉKÏKãKóK”K:KRKOKTK‡KbK[K~KK‰K‰KKoK(KBK‡KsKEKIKJKyKŠKK\K)KUKŠKŠK‰K‰KŠK‰KVKDKEKBK_KK‰KŠKŒKŒKŒK‹K‘KlK2KLK€KOKFKBK`KKŒK‹KŒKMK3KbKK‹KŠKŽK‘KŒKnKIKFKDK@KGKKKLKGKBK;K;K7K6K8K7K7K3K7KDKDK=K=KAK@KAKDKDKCKDKFKDKDKFKFKEKBKBKCKDKAKEK2K&KLKKKLKIKDKDKIKKKUKºKÎKÊKÉKÉKÇKÎK™KYK]KTK>K1K/K„K™KwKZKLKQK«KÊKÄKÆK¦KŒK‘K’KbKGK;KSK½K·K˜K“KK”KyKMKDK6K8K8KFKKKAKLKlKjKWKGKoKÈKbK1KKEKHKIKIKJKJKVK´KÈKÁKËKŽKBKHKEKDKCKCKCKEKJKFK‚KËKÂKÂKÉKwK6KBKVKjKlKeK_K[K]KOKCKCK5K-K=KGKGKCKEKDKCKDKDKCKCKBK@KKKK2K7KCK?KK,K'K3K2K9K>KK-K,KCKCK@K?K5K2KDKCKCKDKFKFKGKDK:KIKHKIKNKOKPKQKPKQKQKQKSKRKRKRKRKRKRKRKSKSKSKRKRKSKTKSKMKGKEKIKJKHKKKHK5K%K$K&K&K&K&K&K$K7KPKKKAKdK‘KLK&K^KˆKˆK‡KŠK|KPKQKGKcKŒK‡K‡K‡K‡KŒKVK&KZKlKKKMKPK€KŠK„K9K4KpK‹KŠKvKCK;KMKKKJK9K6K:K9K9K9K8K6K3K3K3K=KKKIKHK8KEKvKK¡K±KÂKÀKÀKÑKÝK°KRKNKGKŠKgKRK‰KŠK‰K‰KŒK}K2K8KzKKHKIKDKmKŒKKpK.KFK…KŒK‰K‰K‰KKeKEKJKBKNKˆKKŒKKKKŒKŽKK>K=K{KdKCKEKMK‡KK‹K‘KhK4KNK‰KKŒKKŒKŒKK`KBKFKBK@KEK:K?KLKOKLKLKDK>K;K:K7K6KBKDKBK8K/K*K,K3KK9K9K;K:K@KGKIKGKGKFKFKGKGKFKCKEKGKGKGKGKFKCKDKCKCKCKCKCKCKDKDKEKCKCKCKCKBKAKBKBKBKAKBKBKAKBKBKAKAKBKBKBKBKBKBKBKAKAKBKAKBKBKBKBKBKBKBKBKBKAKAKAKAKAKAKBKAK>K>K?K@KDKBKCe]rƒ(K1KCK2K&K0K/K6K>K?KK)K/KBKBK?K>K5K7KEKCKCKCKFKFKGKBKK1KmK‹K†KŠK‚K]KJKLKLK5K/K3K5K6K6K7K8K7K5K4K>KKKIKHK9K;KEKZK|K‘KjKBK‚KÒKíKàK]KKKKKoKoKfKKŠKŠK‰K‹KƒK8K4KtK„KMKHKDKgKŒKŠK{K2K>K€KŒK‰KŠKŠKKlKHKKKCKGKKKŒKKKKŒKK‡KEK6KtKnKBKGKEK€KK‹K‘KuK8KFKKKŒKKKŒKKkKAKFK@KKK†KsKSK?K=KIKSKQKMKJK@K7K9K@KDKAK:K;K;K4K-K)K-K9K>KBKBKBKAKCKDKDKCKAKAKAKFK(K1KOKKKKKHKDKEKLKJKhKÈKÉKÈKÉKÈKÆK¿KxKUKZKNKSK©KbK\K”KK•KyKXK·KÉKÅKÃK£K’KKuKQKhKÄKÄKÉKŸKKŒKqKKKFKKK?K6K9K9KAKJKJKIKGKHKIKLKBK3K2K4K8KGK?KEKGKGKHKHKIKSK²KÉKÃKÊK—KDKEKDKCKBKBKBKDKIKDKtKÉKÄKÅKÉK˜KeKeKWKDK6K0K.K6KIKJKEKHK=K$K!K{KÌKµK|KsK[KKKEKDKCKDKDKCKDKBK?K-K7K@K;K:K=K@KDKFKGKGKEKFKEKCKEKFKFKFKFKEKCKDKCKCKCKDKDKCKCKCKDKCKCKDKDKCKBKBKAKBKAKAKAKAKAKBKBKBKAKAKAKAKAKAKBKBKBKAKBKAKAKAKAKAKAKAKAKAKBKBKBKBKAKAK@KAK?K?K?K>K@K?K?e]r„(K?K5K$K0K2K3KKK;K7K3K8K;K9KK?K>K>K>K?K>K?K>e]r…(K:K&K*K4K8K=KBK>K?K6K#KKKK!K=K9K4K8K/K*K&K!K"K*K;K2K+K+K&K KKKKKK(K'K#KKK K"K%K'K,K0K3K3K,K1K9K4K4K9K:K:K:K$K5KBKAK?K=K/K:KDKCKBKDKEK>KEK@K:KGKKKPKQKPKPKPKPKPKPKQKPKQKSKRKRKRKRKSKRKQKSKRKRKSKRKSKRKRKSKRKSKNKEKFKIKHKMKOKJK>K+K#K"K5KNKKK@KeK‘KLK&K^K‰KˆKˆK‹K|KPKNKFKbK‹KˆKŠKŠKˆKŒK^K%KWKqKPKOKNK}K‹K‹KFK-KhKŒKˆK‰KŒKyKLKJKMK=K3K6K0K-K+K+K-K/K1K1K9KLKIKIK:K2KCK5K(K,K]K~K›K´KÅK¬KUKHKJKPKdKaKlK‡K‰K‹KŠKKJK,KeK‹KTKHKFKZKŒK‹K‡K?K5KsKŽKŠKŒKŒKK}KIKHKGKBKqKKŒKKKKŒKŒKKZK0K\K~KFKIK?KlK‘K‹KKˆKJK:KnKKŒKŽKKKK„KIKEKCK?KuK’KŒKK‘K…KlKLK>KEKVK^KVKKKCKCKBK9K8K8K7K;K8K1K2K,K*K-K7K>KCKDKBKAKAKAKCKK?K>K>K?K>K>K?K>K>e]r†(K)K#K1K5KK=K7K)KKKKK6KAK8K9K3K+K%K#K"K'K=K7K.K,K(K!KKKKKK'K&K#KKKK#K%K(K)K*K-K2K4K8K+K.K3K5K:K9K;K7K#K8KCK@K>KK:K9K9KK>K?K>K?K>K>K>K>K>K>K>e]r‡(K%K/K4K8K=K;K:K7K*K KKKK1KAK:K;K3K,K&K"K"K'K;K7K.K-K)K"KKKKKK(K)K&KKKK!K#K%K(K*K+K-K/K0K3K8KK K5K:K9K:K8K"K;KCK@K>KK_K’KKŽKKKKŽK‘K•KaK6K8K=KBKDKCK>KNKJKDK@K:K8K5K6K=KK;K=K>KK?K>K>K?K>K>K>K>K>K>K>e]rˆ(K.K5K9K:K=K=K7K.K"KKKK,KAKK/K+K)K%KKKKKK(K'K$KKKK K"K&K)K+K*K-K2K0K(K*K&KK&K6K9K9K:K6K#K=KBK@K>K=K0K@KDKCKFK&K KK+K:K@KJKLKMKNKQKPKPKPKPKPKPKQKPKPKRKSKRKRKRKRKSKRKSKSKSKSKSKRKRKRKSKSKSKRKOKNKPKNKFKBKFKLKLKMKMKJKHK>KfK‘KLK%K[KˆK‰K‰K‹K|KMKNKFK^KK‰KŠKŠK‰KKeK%KPKtKPKQKJKwKŒKŒKPK)K^KŒK‰K‰K‹KKMKKKKKNK„K‹KiKDK7K1K,K,K)K'K.KHKHKKK?K(K KKK#K6KIK^KZKuKK^KGKMKGK9KHKMKaKfKvK—K‘KfK+KNK‹KiKGKIKJKKKK\K.KZKKKŒKŒKKŒKYKEKFKAKWKŒKKŒKKKKKK}K=KBKK_KDKFKMKˆKKŽK“KlK:KPK‡KŽKŽKKKŽK’KgKAKEKAKTKŒKŽKKKŽKKKK“KqK3KCKgKOKBKDK@KTKVKOKJKFKAK9K3K4K6K8K;K9K?KCK@K@KBKAKEK1K(KNKLKKKJKFKDKKKMKUKµKÌKÈKÈKÉKÄK¤KjKSKVKSKGK;K;KFKoKhK[KTKKKKÊKÆK¯K[KKKOKKKMKQK§KËKÅK¾K`KDKIKIKKKKKJK9KKËK¿K^KCKIKHKFKCKGKKK=K3K6K9K'KK5KGKCKDKCKHKGK^KÇK‡K0K3K?KNKRKYKaK_KOKCK;KHKFKuKÉKÃKÃKÈK|K8K>K>K;KK>K>K?K=K>K?K>K>K>K?K?K>K>e]r‰(K6K9KK:K0KAKCKCKDK$KK KKK8KNKMKMKNKQKPKPKPKPKPKPKPKQKPKRKSKQKQKQKQKSKRKRKSKSKSKSKRKRKRKSKSKSKQKNKOKOKSKSKLKEKCKGKLKOKMKMKEKdK’KNK%K\K‹KŠK‰KŒK|KJKNKFK^KK‰K‰K‰K‰KKhK%KNKvKQKOKGKvKŒKKTK(KZK‹KŠK‰KK„KOKIKJKNK~KŒKKˆKyKeKOK>K5K1K0KFKHKIKAK$KKKKKLKiKfKuK…K…K_KGKMKIK;K;KFKQK\K]KƒK“KnK.KHK‰KpKGKIKHK{KŽKKfK,KSK‹KKŒKŒKŒKKaKCKHKCKQKˆKŽKŒKŽKKŽKŽKŽK„KAK=KyKjKCKGKGKK‘KŽK“KyK>KGKK‘KŽKKKŽK’KqKCKHKDKKK…KKŽKKKKŽKŽKK}K;KKDK?K>KLKYKZKSKMKJKDK;K6K4K5K9K?KCK@KAKBKAKCK9K"KHKLKKKJKFKBKIKNKKK›KÏKÇKÉKÉKÄK­K|KVKTKSKIK:K=KK>K:K;KIKLK K]K-K2K@K\KYKVKMK>K2K-K3KCKGKXK¶KÇKÂKÈK§KDK;K=K=K:K:K:K9K7K:KGKIKNK¨KÆKÃKÂKÃKnK@KNKPKUKVK]K]K\KZKWKXKJK>K?K@KBKEKFKCKCKDKCKDKCKBKBKBK?KK>K>K?K>K=K>K?K>K>K?K>K>K>K>e]rŠ(K/K9KK5K0K,K%KKKK KK%K*K&KK KK%K"K#K'K*K+K+K/K2K.K"K K"K'K7K8K8K:K9KK9K2KAKCKDKCK$KKK K +KK1KOKPKNKPKPKPKPKPKPKPKPKQKPKRKRKQKPKPKQKSKRKRKSKSKSKSKRKRKRKSKSKSKRKRKRKRKRKRKRKRKJKDKGKGK;KIKQKOKhKHK&KZKŠKŠK‰KŒK|KHKKKEK]KKŠKŠKŠK‰KKjK%KLKuKQKOKGKuKŒKŽKWK'KXKŠK‹K‰KŠK…KRKIKJKLK}KŽKˆK‹KKKKfK/K=KAKGKIKKK@KKKKK.KK5K=KIK/KlK–KuK/KDK…KwKGKJKEKuKKKrK0KIK†KŽKKKŒK‘KkKDKHKFKKKƒKŽKŒKŽKKKŽKKŒKKK7KpKuKCKHKDKwK’KKKƒKDKCKzK’KŽKKKŽK‘K|KGKGKDKEK|K’KŽKKKKKŽKK‰KHK7KoKKBKCK=KJKKK@KIKYK\KWKQKKKDK?K8K6K=KDK@KAKBKAKAK?KK@KMKKKJKHKCKCKKKHK€KÏKÈKÈKÉKÄK³KŒK\KSKQKMK=K:KKDKIKHKXK>K1K2K7KIKBK8K1K*K-K3K>KBKIKGK•KËKÁKÄKÄKdK5K=K=K:K9K9K9K7K8KBKJKCK‚KÇKÂKÀKÆKKHKHKHKJKIKGKSK]K\KXKWKQKDKDKCK0K'K8KBKGKDKDKEKCKBKBKBKAKAK?K?K=K9K9KK?K@K?K>K?K?K>K?K?K?K>e]r‹(K5KK5K3K.K'K!KKKKK#K(K#KKKK&K&K$K%K)K,K/K/K3K.K$K!K K"K,K>K;K9K:K9KKZKKŠKˆKŒK{KLKJKDKZKKŒKKŠK‰KŽKmK%KHKsKQKQKJKrKŒKKZK'KWKŠK‹K‰KŠK‡KTKHKKKKKzKKŒKŒKŒK‹K‘KqK(K@KxKXKGKHKMKSKK +KKKKKDKoK‚KrKQKHKIKIKKnK’KŽKKKŽK‘K…KLKDKDKAKsK“KKKKKKŽKK‘KUK7KbK‹KJKCK=K\K’KuKSKCKGKXKXKXKTKOKJKCK?KBKAKBKAKAKAKDK$K4KOKKKMKHKDK?KIKHKeKÆKÊKÈKÈKÇK¹K•K^KQKQKOKEK7K:K@KJKLKLKOKMKKÉK·K{KJKLKJKHKMKVK°KÉKÇK¹KWKHKEK?K=KGK[K¸KÇKÆK»KQK:KAK@KBKAKFKKK=K5K8K7KK@K=KKAKBKBKBKBK@K>K>K>K>K>K>K?K>K?K?K?K>e]rŒ(K9K=K=K9K+K KKKK4KAK7K7K0K*K&K#K!K*KAK9K1K/K*K"KKK KK!K+K'KKKK"K%K%K'K*K*K-K1K1K+K"K"K#K"K#K0K@K;K9K:K9K;K9K:K@KBK@K=K9K@KCKCKEK@K#KKKKKKKK)KK‚KaKEKIKJKbK=K4KK%KOKfKxK‡KjKJKJKIKHKIK;KGK9K/K5K2KhKŽK…K;K7KxK„KIKIKDKfKKŽKK7KKAK?K?K=KBKLKCK6K8K9K?KVKWKRKOKNKLKJKIKHK8K1K3K3K0K/K7KK@K@K@K@K@K@K@K@K@K?K>K?K>K?K>K=K>K>e]r(K:K8K8K-K!KKKK.K@K6K7K3K,K'KK!K(KK:K?KDKCKEK>K#KKK KKKK-K:K;K>KHKOKOKMKPKQKPKPKPKPKPKPKPKQKPKPKPKPKRKSKSKSKRKRKRKRKSKSKSKRKRKRKSKSKSKSKSKQKSKTKTKKKDKBKGKLKLKNKKKYKtK‹K€KKKKKAKYKK‹KKK‹KKrK$KEKuKOKMKDKpKKKcK$KNKŠKKŒKK‰KYKIKKKKKuKKŒKŒKKŒKKzK,K:K}KdKEKHKCK#KQK_K!K3K:K]KƒKoKQKZKSKIKHKKK7K0K$K0K,KK=KK>K>K>K>K>K@KBKBKBK?K>K?K>K>K?K?K?K?e]rŽ(K8K7K0K$KKKK'K?K6K8K3K,K'K!K K$K9K:K3K/K)K$KKK K KK'K%KKKK$K#K$K(K)K*K+K,K1K-K%K#K$K"K&KK K1KDK9K9K9K:K;K6K9KAKBK?K;K:K@KDKCKEKKFK>KvK•KKKŠKFK6K7K3K3K=KKK^KUKAKBKAKBKAKBK?K!KCKMKKKKKGKAKCKOKGK~KÎKÇKÈKÈKÄK²K’K`KQKQKMK?K7K7K?KIKHKIKJKQK¯K¿KKDK=K8K2K.KDK]K·KÅKÇK±KLKBKBKAKBKGKaK½KÄKÅK¹KYKUKfKjKjKfKPKIK>K:K5KzK¡K6K0K0K-K/K,K;KIKDK6K1K2K3K7K:K:K9K9K:K:K9K;KHKGKbKÀKÄKÃK½KYK9K?K?K?KKBKCKBKAKAKBK=K+K5K>K:K7K6K;KAKCKDKCKCKCKCKCKCKCKDKCKCKBKBKAKBKCKBKAKAKAKAKAKAKAKAKBKAKAKAKAKAK@K>K?K?K?K?K>K?K?K>K>K>K>K=K=e]r(K8K0K#KKKK%K>K;K6K6K/K*K"KK K5K=K3K1K+K#KKKK KK)K$KKKKK#K$K(K+K,K-K/K2K/K#K#K$K#K#KK KK;KBK9K9K9K:K;K6K=KCKAK?K:K=KDKDKCKEK;K$KKKKK K-K=KIKIKBK6K$KK4KKKRKOKPKPKPKPKPKPKPKPKPKPKQKRKRKRKRKRKRKRKSKRKQKRKSKRKRKRKRKRKRKRKTKRKRKRKSKRKSKQKJKBKDKIKKKMKJKKKHKGK@KXKŒKŒKŒKKŒKKvK(KAKuKQKMKHKlKKKkK%KHK…KKŒK‹KK^KJKLKGKmKKŒKKKŒKŽKƒK5K0KxKoKEKHKGK"KKIKJKeK~KyK^KfKgKcKKKGKIKJK>K1KK;K|KKKŽKKOK,KaKKYKJKFKSKŒKŒKKSK2KeKKŽKŽKŽKKŽKSKDKEK?KYKKKŽKKKKŽK‘KƒKCK@KKgKBKFKGK…K‘KK’K{KAKHKƒK‘K‘K‘KKŽK“KtKBKEKBKHKƒK”K‘K’K’K’K’K‘K“KŒKPK?KrKƒKDKEKKK>K=K=K=K;K9K:KDKJKDK€KÇKÀK¿KÆK KLK0KKKKKKKKKKK?KDKEK;K!K}KÇK½KÀK}KbKzKxKkK[KLKAKK>K>K=K@K?K>K?K>K>K=K=e]r(K1K%KKKKK8K>K8K7K/K(K"K K K2KK=K8K:K9K9K9K6K>KBKAKAK=KKHKFKYK¼KÃK¿KÀK¿KYKKKKKKKKKKKK1KEKDKAK4KœKÆK¾KÃKžKWKXKeKnKqKhKUKHKEKFKBKDKBKAK9K0K%K?KBKAK@K=K=K9K8K7K:KKAKAKAK@K>K?K?K>K>K?K>K?K=KK6K6K-K)K$KK K2K>K4K0K-K%KKKKKK,K*K KKK"K"K!K(K,K,K.K.K2K/K$K%K$K%K"K"K)K-K(K'K>K>K8K:K9K9K9K5K>KBKAK@KKWKKYK@KAKHKŽK’KK—KyKK;K9K7K:K=K?KAKDKBKAKAKAKBKBKAKAKAKAKAKAKAKAKAKAKAKAKBK@K?KAKAKBKAK?K?K>K?K?K>K>K?K>K=K=K=e]r’(K"KKKK/K=K1K4K.K(K$K KK,K=K3K0K.K)KKKKKK)K)K%KKKK$K%K(K)K,K/K0K4K.K#K$K'K#K$K*K-K-K,K'K)KEK@K9K:K9K:K9K5K?KAKBK?K:K=KAKCKCKEK7K#K"KKK K K K K KKKKKKKKKKK9KOKQKLKNKQKPKQKPKPKPKPKPKQKSKQKPKRKSKSKSKRKSKSKQKQKSKSKSKOKQKSKRKRKRKRKRKRKRKRKTKSKNKDKAK5K?KKKMKKKXKsKŠKKKK+K6KtKSKJKGKcKK‘KxK(K>K€KŽKŒKŒK‘KeKGKIKFKeKK‹KŒKKKŽKKBK+KiK{KIKIKFKbK5KPK\KEK;KK^KK‘K’K’K’K‘K‘K‘K”KuKDKPKKhK>KCK?KK•KK”K‡KIK?K=K:K9K8K9KdKTK?KBKAKAKAKBKK>K>KKAKAK>K>K>K?K?K?K>e]r“(KKKK)K=K1K,K0K+K$KKK'K;K2K*K*K'K!KK K KK(K)K"KKKK"K$K&K,K+K+K/K5K2K%K#K%K%K%K!KK"K!K KK.KHK=K9K:K9K:K8K6K?KAKAK?K:KK0KDKJKBK-K,KJKLKHKiKÓKêKîK¿KKKK’KvK4KDK‡KvKDKIKEKwK‘KKxK4KFKƒK‘KŽKKŽK“KuKEKHKFKDKvK’KKKKK’KK•KiK8KVK‡KNKFKCKZK’K‘K‘K”KeK;KYKK’K‘K’K‘K‘K“K`K@KEK>KRKK’K‘K’K’K“K’K‘K“KKKKHKKvK=KDK=KrK—KK’K’KUK@KCK@K=K:K@KgK`KAKAKAKBKAK@KAK$K8KKKHKIKHKDKAKIKIKaKÀKÈKÇKÆKÆKÄKÌK–KIKMKNKCK9K9KKBKEKzK‹KCKKGKAKrKK.K2K0K6K=K=K=KK-K@KQK^KcK]KVKWK[KYKVKPKKKGKAKCKAKBKBKAKAKAK@K@KAKAK?K?K=K8K7K5K9K=K@KCKDKBKAKAKAKBKAKAKAKAKAKAKAKBKAK@K@K@K@K@K@K?K>KAKAK>K>K>K>K>K?K>e]r”(KKK'KK;K2KAKDKDKEK5K%K"KKKKKK KKKKK +KKKKKKKKKK1KIKOKNKLKPKQKPKQKSKSKSKSKSKQKPKPKQKSKQKPKQKPKPKPKPKPKPKRKSKRKRKRKRKRKSKRKOKRKSKQKQKOKEK@KBKHKLKKKIKOKeKrK,K3KrKWKHKFK]KŽKK}K)K3KzK‘KŒKŒK‘KmKIKIKGK]KKKKKKŽK’KNK&K`K€KKKHKLK6K%K*K(K&K0K9K*K/K)K!KaK_KIKJK[K¾KÕKëKÊKŒKKŽK’K{K3K@K‚K|KFKJKDKqK‘K‘KK:K@KyK‘KŽKŽKŽK’KKGKFKGKCKnK”K‘K’K’K’K’K‘K—KvK:KLK†KWKDKEKQKK’K‘K–KoK?KQKˆK“K‘K’K’K‘K•KnK@KEK@KKK…K“K‘K’K’K”K“K‘K’KŒKQKBKsK„KDKDKKEKCK@K=K@KNKXKDKAKBKAKAK?KAK+K.KLKHKHKIKFK?KGKLKPK¬KÊKÄKÆKÆKÅKÈK±KPKIKOKJK:K9K;K@KCKKKRKLK_KŠKLK:KNK^K\KQKSKKKmKÆKÄKÈKKJK\KoK„KˆKOKiKÃKÄKÅK½K˜K•KK•KKKbKEK—KÉKÁKÊKK1KJK9K:K9K:K@KGKGK8K3K5K4K7KK@K?KK>K>K>K>K>K>K>KAKAK>K>K>K>K>K>K?e]r•(KK!K;K3K(K,K*K%KKK!K3K+KKKKKKKK K"K)K"KK KKK#K&K+K*K+K.K4K5K(K$K%K&K&KKK KKKKKK0KIK=K9K:K9K;K.K)KAKAKBK=K8K+K@KDKCKCK2K'K$K KKKKK K K +K K K K KKKKKKKKKKK;KNKPKMKNKNKNKPKRKQKQKQKQKQKRKRKSKQKPKPKQKRKRKRKRKRKRKSKRKRKRKRKRKRKSKRKQKQKQKQKQKSKNKEKAKEKGKKKLKIKNK>K:KtKYKGKFKZKŽKK€K.K1KvK’KKŒK‘KpKHKJKGK\KŽKKŽKKŽKŽK“KRK$K\K…KMKGKJK6KK&K(K&K!K%K/K,K"K!KPK[KJKLKTK´KÉKÛKÊKKKK’KK6K:K|K…KHKJKDKiK‘KK‰KBK9KsK‘KŽK‘KK‘K„KJKFKFKAKcK’K‘K‘K’K’K’K‘K•K€K?KEK‚KbKBKFKJK‰K“KK•K|K@KHKK”K‘K’K’K‘K•KyKCKGKCKEK|K”K‘K’K’K’K’K‘K’K“K^KAKhKŽKMKBK?KRK“K“K“K–KrK@KFKEKCK?K>K@KGKCKAKBKAKAKAKCK5K$KKKHKHKIKFK?KDKKKGK‘KÍKÄKÆKÅKÄKÅK®KVKEKLKLKKK>K>K=K=K>K;K?KHKGK9K.K0K0K/K9K>KKOK^K\KUKOKQKTKQKAK?K:K8K;KAKAKAKAKAKAKAK@K?K>K?K?K?KK@KAKAKAK>K>K>K>K>K>K>e]r–(KK6K6K%K&K'K&K KKK/K.KKKKKK K K +KK)K"KKKKK!K&K*K*K+K/K1K3K)K&K&K%K&K#KKKKKK KKK8KEK:K8K:K9KKXKKK’K’K’K’K‘K”KˆKFKCK|KoKBKHKEK}K•KK”K†KGKDKwK•K‘K’K’K‘K“K„KHKGKDK@KqK•K‘K’K’K’K’K’KK–KlKBK[K“KZK?KCKEKŠK•K“K”KKFKFKGKBK@K?K?KCKAKBKBKBKBKAKCKK>K=KKEKGKAK0K/K0K/K3K=K=K=K=K=K=K:K9K8K7KCKHKCK—KÇK¿K¿KÇK€KKKKKKKKKKKKKBKHKDKjKÀK¿K¾K¾KÀKaKK#KKKK!K)K9KLK[K_KYKOKGKBKCKAKK>K?K=K;K;K;K:K5K2K7K>K?KBKCKBK?KAKAKAKBKBKBKAK>K?K>K@KBKAKAK>K>K>K>K>K>K>e]r—(K0K9K K!K#K"KKKK.K0KKKKKK KK KK,K%KKKK!K#K$K'K*K+K.K0K4K)K$K'K%K&K"KKKKKKKKKK;KEK:K:K:K9KK6K/KBKDKCK?K/K)K&K%KKKKKK K K +K K K KK K KKKKKKKKKK%KK>KK>K>K?K;K;K=K9K@KIKCKmKÂK¿K½KÂK±K0KKKKKKKKKKKK7KIKFKJK¦KÄK½K½KÃK›K$K"K KKKKKK!K3KFKZKaKZKNK@KAKCK9KKKK(K;KAK>KBKBKBKAKAKAK=K?K>KK>K>K@KBK?K?K>K>K>K>K>K>K>e]r˜(K:K KKKKKKK(K2KKKKKK +K KKK,K(KKKK!K$K%K%K'K+K.K2K0K(K%K&K%K&K#KKKKKKKKKKKAKEK:K:K:K9KK>K6K0KCKDKCK?K/K)K'K$K"KKKKK K K +K +K +K K K K K K K K KKKK K%KKK K@KOKMKOKQKPKQKRKRKPKPKPKPKPKPKPKPKQKQKRKRKQKQKRKRKSKRKRKQKQKRKRKPKQKQKPKPKQKPKOKQKRKLKEK@KBKGKGKIKKKJKEKSK‰K’KŠK4K*KlK“KŽKŽK’KzKJKLKHKRK‰KKŽKKKŽK”KcK"KJKPK@KIKJK:KK!KK K#K(K)K"K%KžKåKzKHKMKJK¬K×KÙKÎKK‘K’KKKKK2KcK’KWKFKCKTKKŽK’KZK4K_KKK’K‘KŽK’K_KCKGKCKOK‡K“K‘K’K’K’K‘K‘K“KYK9KfK„KGKHK@KgK–KK‘K“KXK@KfK”K‘K’K’K‘K“K“KZKAKCK=KXKK’K“K”K”K”K”K’K•K„KHKIK‚K|K@KCK@KoK™K“K“K•KaKCKGKBKAKVK]KLKIKAKAKBKAKAKAKDK(K/KKKHKIKFKCK?KFKJKNK«KÊKÅK·KvKAK;K=KFKEKIKIKK>K=KK@K?K=K=K>K>K=K:K9K5K4K7K:K?KAKBKAK@KAK@K>K?K?KAKBK?K>K?K>K>K>K>K>K>e]r™(K'KKKKKKK!K-KKKKK K KKKK(K&KKKK"K#K&K)K)K)K-K/K/K+K%K&K&K&K#KKKKKKKKKKK"KBKCK8K:K9K9K;K%K2K@K?K>KK9K:K7KDKŠKœKyKIK}KcK8KQK’K‘K—KwKIKMKŸKÊKÂKÃK£K—K™K—KœKvKHK™KÉKÁKÆK®K˜K™K™K˜K˜KˆKMKYK´KÅKÁKÊKeK,KBK@KAKBK@KAKHKBK7KKBKDKCKBKBKBKBKEKGKEK2K-K-K0K5K>K@KBK@K>K>K?K=K:K:KBKEKDK‚KÄK¼K¾K½KPKKKKKKKKKKKKK;KHKCKTK¬KÁK¾K¼KÂK†K"K!KKKKKKKKKKK%K4K@KAKAKCKK?K>K?K=K;KK>K@KBKBKAK?K>K?K>K>K>K>K>K>e]rš(KKKKKKKK/KKKKK K KKKK&K'K!KKK"K!K%K'K)K)K+K1K2K(K%K'K%K'K"KKKKKKKKKKKKKEKCK8K:K;K:K;K#K4KAK@K>K;K1K4KEKCKDK@K-K(K%K#K$K KKKK K K K KK K K +K K K K KKKK K"KKKKKKKK;KPKRKQKQKPKRKQKPKPKPKPKPKPKQKRKQKPKQKRKRKRKSKQKPKQKQKPKQKQKQKQKSKTKQKQKRKQKPKQKRKRKQKLKDKAK7K7KGKJKHKNK`K;K'KgK’KKŽK’KKHKJKFKMK…K‘KŽKKKK”KqK&K=K)K;KMKFKCKKKK-K,K!K(K'K!K9KºKÐKRKHKIKHK›KâKÐK‘K’K’KŽK”KaK-KVKKdKEKGKJK„KK•KnK4KPK‰K“K‘K’K‘K–KuKDKFKCKDKxK–K‘K’K’K’K’K‘K—KoK:KSK‹KWKCKCKRK’K’K’K–KrK?KUKŒK”K’K’K’K’K–KqKAKEK>KDKƒK–K“K”K”K”K”K“K“K•K]K@KeK“KPKAK@KOK”K•K’K˜KKHKDKDKTK^KZKHKLKMK@KBKBKAK@K@K;K KDKIKHKGKDK@KAKIKEKjKKpKGKKK>K>K?K>K=K=K;K8K5K4K5K9KK?K@K@KAKAK?K>K>K>K>K>K>K>K>e]r›(KKKKKKK)KKKKK KKKKK#K%K KKKK!K#K'K)K*K*K0K1K'K#K'K&K&K K KK K K K KKKKKKK KHKCK8K:K9K:K:K"K6KBKBK>K=K1K6KEKCKCK=K*K&K#K$K$K#KKKK K K K K KKKKKKKKKKKK#KKKKKKKKKKKK‡KbKAKEKJKŠK”K“K—K}KCKNK…K•K“K”K”K“K—K}KCKFK@K@KwK•K’K”K”K”K”K“K“K—KmKCKXK’K^K>KBKBK‹K–K’K•KKSKHKGK\K^K]K\K^KPKAKBKBK@K>K>K@K"KKFKHKKKPKAK:K=KKzKÇKÁKÂKeKAKHKFKDKDKDKDKDKGKGK?K/K0K0K/K9KBKBKBKBKBKBK@K?K:K&K=KHKEK”KÁKÁK‰K.K"KKKKKKKKKKKKK>KFKBK_K¶K¼K¾K½KÅK|KKKKKKKKKKKKKKK.KAKAKCK:K"K)K—K¿K·K®KvKqKlKbKWKLKDKBKAKAK?K>K?K?K>K?K?K=KK?K?K>K>K>K>K>e]rœ(K K K KKK$KK K KK K KKK +KK!KKKKK K$K(K)K*K,K-K0K'K"K%K&K%K&KKKK!K"K!K"K%K%K&K(K(K%K.KIKBK9K9K9K8K7K!K9KBKAK>KKEKBK€K–K’K•K†KHKFK{K–K“K”K”K“K–K‰KIKDKAK?KlK–K“K“K”K”K”K”K’K–KzKEKNKKnK;KBK>K|K˜K’K•K”K^KGKCKLKYK^K_K_KNKAK@KBKAKAK>KAK&K0KLKHKHKFKBK>KBKHKGK=K;KK>K=K=K?K?K>K>K>K6K1K"K1K=K8K6K4K5K6K9K?KAK>K=K=K>K>K?K?K>e]r(K K K KK KKKK +KKKKKKKKKKK!K!K#K'K)K)K+K.K.K'K#K(K&K&K#K'K+K-K+K+K-K)K(K*K*K)K*K'K"K5KKKAK9K:K:K9K5KKK;K1K:KCKCKBK9K*K'K%K!K K KKKK K K K K +K +K +K K K K KKKKKK"K9KBKLKMKUKWKTKUKTKRKIKMKOKMKOKPKPKPKPKPKPKPKPKPKPKRKSKRKSKPKOKQKRKRKSKRKRKRKRKRKRKSKRKPKQKPKPKPKPKQKQKPKPKRKRKOKHKAKAKEKGKHKKKGKSKqKŒK†KMKHKHKHKzK’K‘K’K’K‘K•K‚K+K1KyKiKCKGKHK6K;K/K*K*K,K‘KÏKÚKâKªK€K^KJKKKRKSKNK±KœKK’K‘K–KzK4KBK…K{KEKJKAKqK–K’K†KAK>KuK•K‘K’K‘K“KŠKOKFKEK?K\K‘K’K“K”K”K“K‘K“KŠKKK>KvKxK@KEK@KuK–K’K“KKQKBKnK—K“K”K”K“K”K’KRKAKDKKIKVK\K8K=KCKAKBKBK?KAK0K&KLKIKIKFKBK=KAKGKHK@K;K=K=KK>K?K>K@K1K+K)K&KK?K>K>K>K>e]rž(K K KKKKKKKKKKKKKKKKKKK"K)K'K&K*K.K/K%K$K'K'K'K'K#K"K K K$K#K$K#K#K$K$K%K#K!KK5KLK>K9K:K:K;K3K!K>K?K@K?K;K.K=KEKCKDK9K+K*K&KKKK KKKKK K K +KKK K +K +K K K K K KKAKSKUKXKYKZK[K[KXK[KXKVKWKTKLKIKNKPKPKQKQKPKPKPKPKPKRKRKQKQKPKPKPKQKQKQKQKQKQKQKQKQKQKQKPKPKPKQKPKOKRKSKQKPKQKQKQKQKNKFKAKAKDKHKGKGKHKZKnKLKGKHKDKuK”KK’K’KKK†K0K.KxKtKFKIKCKtK„K6K)K/K/K‚KÃKÕKÝKÒK‘KXKJKGKdKªKZKKªKK’K‘K”KƒK8K?KK‚KFKKKAKjK–K‘KKGK:KnK“K“K“K“K”K‘KUKFKEK@KVKK•K”K“K”K“K“K’K‘KUK?KmKKDKEK?KlK˜K’K”K”K]K@KdK–K“K”K”K“K“K•K\KCKGKK=K:K/K>K@K>K@KBKAKCK;K!KEKIKJKHKDKAKEKHKHKCK:K:K:K:K:K8K7K=KBKAKIKAK8K:K9K;KqK˜K”KUKeKƒKHKK„K¢K1K-K-K&K(K2K-K KKKKKKKKK3KFKDKMKªKÄK¿K½KÃK£K&KKKKKKKKKKKKKKK@KCKEKK@K=K5K*K*K=K=KK?K?K>e]rŸ(KK KKK KKKKKKKKKKKK KKK K#K)K(K)K,K.K%K K&K%K%K!KKKKKKKKKKKKKKKKK5KIK:K9K9K9K;K2K#K>K>K?K>K;K-K=KEKCKDK8K+K*K&K KKKKKKKK K K +KKK +K K K K K KK KKIKXK[K\K[K]K_K_K_KcK_KVKMKKKKFKHKEK@KK=K=K=K;K9K;K:K9K8K3K2K1K5K:K>K?e]r (K KKKKKKKKKKKKKKK KKK!K%K&K(K)K,K0K'K!K'K&K'K KK K KKKKKKKKKKKKKKKK>KKDKCKEK8K,K*K&K!K!K KKKKK K K K K K +K +K K K K KKKKKKKYKZKZK\K`KbK`KVKGK6K&KKKKKK(KDKOKOKPKPKPKPKPKPKPKPKQKQKQKQKPKPKPKQKPKPKPKPKPKPKPKPKPKPKPKPKQKPKPKPKPKPKPKQKPKMKKKNKPKKKDK@KDKJKJKIKIKIKGKCKsK—KK‘K‘K‘K’KŽK7K)KnK~KEKJKDKpK—KQK+K1K2KDKžKÓKÞKÓKËK{KHKIKXKÓKÐK¤K¹K¤KK’K’K‹KAK5KpKKLKEKFKZK“K‘K“KYK2K_K“K”K“K”K“K—KdKCKEK@KIKK–K“K”K”K”K”K’K˜KjK;KXKŽKSKBKAKRK’K”K“KšKrK?KRKŒK•K“K“K“K’KšKvKAKHK?KAK{K˜K“K—K—K—K—K—K”K–KlKCKWK’K_K>KBKBK‡K™K–K—K”KVKDKIKHKHKGKFKEKBK?KBKAKBK?K>K@K"K2KKKHKHKEKAK9KCKIKFK=K7K:K:K:K9K7K:KAKCKEKIKKBK>K>K>K?K?K=K;K;K;K;K;K9K8K6K4K3K5K7e]r¡(KKK KKKKKKKK KKKKKKKK$K'K'K'K*K0K*K$K'K'K%K"KKKKKKKKKKKKKKKKKKKAKHK:K9K:K;KK>KKCKBKDK6K+K*K&KK KKK KKK K K K K K +K +K K K KKKKKKQK[K]K]KUKEK3K&KKKKKKKKKKKK2KLKSKQKQKQKPKPKPKPKPKOKNKPKPKQKQKPKQKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKQKQKMKOKQKRKRKJKAK?KEKHKEK?KGKGK\K†K“K’K‘K’K‘K’KKNKŠK\KAKCKIKŒK•K’K˜KKDKKK‚K–K“K•K•K”K™K‚KEKGKCK@KpK˜K”K–K–K–K–K—K•K˜KzKGKLKKqK=KCK:KyKœK•K–K˜KcKK@K7K8KIKHKHKEKBK>KBKHKFK?K8K9K9K:K9K7K:KAKEKCKHK=K6K7K;KEKK›KKNKsK‡KGK>K†KšKšKKPKGKxKÇKÂKÅK´K˜KšKšKšK“KTKaKÁKÄKÅK·KwK—KšK›K–KKrKGKyKÆKÁKÁK¾K>KKGKFKGKFKGKJKBKsKÆK¿K¾KÆKxKAKHKEKCKBKDKEKEKFKHKEK4K2K5K2KGKMKAKCK@KAK8K(K+K3K8K?KGKFK=K.K-K.K-K1KEKGKDKDKFK*KKKKKKK*KDKEKBK‰KÄK½K½K½K¹K@KKKKKKKKKKK KKKK3KDKBK?KkK»K¹K¹K¸K½K™KK +KK(K9KKKZK]KVKRKSKWK^K`K^K[KTKMKBK@KAK@K>K>K>K?K?K=K>K>KK>KKRKQKPKPKQKQKQKPKMKKKNKPKQKQKNKQKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKQKQKPKPKPKQKQKNKHK>K@K:K4KEKIKGKPKjK‰K•K“KK”KCK"KdK†KHKJKBKbK˜KwK3K5K2K6KƒK³KÙKÝKÙKƒKGKPKRKÀKòKÙKÉK¼K‘K•K“K—KSK0K_K‘KZKCKCKNK‹K’K–KlK2KOKK•K“K”K“K˜KxKBKHKFKBKrK˜K“K”K”K”K”K“K—K€KBKEKƒKgK?KDKCK„K–K’K–KŠKLKEKwK—K”K—K—K—K˜KKMKEKEK>KcK—K—K–K–K–K–K–K–K™K‡KKKIK€KK@KDK6KdKšK”K–KšKvKBKJKuKeKNKHKFKHKDKAKAKBK?K>K>KAK@KGKIKHKEKBK>K;KEKGKCK7K7K8K:K9K7K8K>KDKCKGKBK8K8K;KAKoKšK˜K\K_K‘KSK8KpK™K”K›KdKDK[K¸KÅKÄK½KK›K›K˜KœKfKLK©KÈKÂKÄK‡K‘K›KœK˜K˜K„KMKYK¸KÂK¾KÉKdKK=KHKFKFKGKIKFKSK³KÄK¿KÆKžKEKGKEKCKEKDKCKFKGKEKHK:K0K5K.K}K|K>KEKDKAKBKCK@K>K=KK=KK>K=K;K9K:K:K9K:e]r£(K KKKKKKKK KKKK KKKK!K#K%K'K)K.K'K#K'K%K&K"KKKKKKKKKKKKKKKKKKKKKGKEK8K9K:K:K;K$K.KAK>K>KK}KuKAKEK@KyK˜K’K”K’KSK@KkK—K•K–K–K—K•K“KUKEKEKK>K@K?K>K>K@K=KCKIKGKFKDK?K;KEKGKDK7K7K8K8K8K8K7K=KCKDKHKGK:K9K:K>K^K—KšKnKOKKfK9KZK–K‘KžKyKHKMKŸKÉKÂKÃK¥K™K›KœKKMKGK†KÈKÂKÆK«K•KœK™K˜K—KŒKXKJKœKÇK½KÈK˜KK/KJKFKFKGKIKJKGK‘KÈK¿KÁKºKZKCKGKEKFK=K8KDKGKEKHKAK3K4K7K¡K¤KBKEKGKCKAK@K=K;KK&KKKKKKK1KBKBKEK˜KÁK»K½KÀK°K2KKKKKK KKKKKKKKK8KDKCK?KrK¼K¸KºK·K¾K“KKK KKK +KK.K@KRKZK]KVKRKTKWK\KZKBK:K8K8K;K@K?K=K=K>K>K=KK>KKrKKBKEK?KlK™K’K“K–K]KAKaK•K•K–K—K—K“K—KcK@KFK=KNKˆK˜K–K—K—K—K–K–K–K–K`KAKcK–KSK>K?KHK’K—K–K™K“KSKBKnK™K—K™KKsKRK@K@K>K?K?K>K?K?KBKJKGKGKEKBK=KCKGKFKKOKKœK…KIKK„KIKFKK˜K›KŒKQKEKKÇKÂKÄK±KšKœKžKsK'KGKhK¿K¿KÂK¾KžK™KK›K—K“KiKFKyKÈK¿KÂK½K4KKGKGKFKGKIKJKFKlKÃKÀK¿KÆKKAKIKFKFKDK>KEKGKFKGKEK9K0KPK¹K½KbKBKGKBK@K>K@KKDKDK@K+K,K.K.K.K?KHKFKFKDK2KKKKKKKK?KEKAKnK¾K»K¾K¾KÅKkKKK KKKKKKKKKKKK!KCKBKAKKK¥K½K¹KºK¹K»KGKKKKKKKKK(K4KDKVK^KYKOKNKWKJK;K=K8K8K5K-K7K?KAK>KK>KK=KyK–K”K–K”K”KKNKBKDKAKVK‘K—K–K–K–K–K–K–K–KXK=KhK†KDKBK?K`K—K”K’K˜KhKAKVKK—K–K—K—K•K›KnK?KEK?KGKK™K–K—K—K—K–K—K•K™KnKAKXK•KaK=K@K>K†KšK•K–K™K^K@K_K—K•K–K˜KK…KCK?KBKAKAK?K?K>KBKIKGKGKGKCK>KAKIKFK?K7K8K8K7K8K8K7K?KCKBKGK?K7K8KKyK¿K¹K¹K¸K¾KK KKKKKKKK +KgKzKMKBKPK]KZKPKIK=K>K?K=K:K"KK$K0KK>K=K3K5KCKAKDK@K-K+K+K"KKKKKKKKKKK K K K K +K K K K K K K KKK KKKKKKKKKKKKKKKKKKKKKKKKK.KIKRKNKOKQKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKQKPKPKPKQKPKPKPKPKPKPKQKPKOKOKQKPKPKPKPKPKQKNKGK>K=KBKIKIKHKGKFK@KNKŒKYKFKEKRKK•K†K;K3K-K}KËKÊKßKèKÖKZKHKHK~KÙKßKìKÏKšK“K“K—KvK2KCK‹KyKAKHKBKqK˜K“KKEK8KpK˜K”K—K•K”K”KVKAKCKBKOKŠK™K–K—K—K—K–K–KšKcK:K]KKNKDK@KTK–K•K“K™KtKBKRK‹K—K–K—K—K–K›KyKBKEKAKAKtKšK–K—K—K—K–K—K•K›K}KFKMKKrK;KBK9KuK›K•K–K›KoKAKTK’K˜K–K–K˜K•KPK>KBKAKAK?K?K=K@KFKFKGKGKDK?K>KEKEK@K7K7K8K7K8K7K7K:K?KAKGKEK8K7K;KEKkK˜K›KiKYKªKˆKJKbKK˜KŸKpKFKPK©KÅKÀKÂKšKK KYKK6KKKŒKÆK¿KÃKµK™KœKœK›K›K˜K\KJKœKÆK¾KÇKšKwKsKBKGKGKGKDKGKGKKÈK¿KÃKÀKcKBKHKDKCKDKDKCKFKFKEKBK7K–KÃKÀK®KQKAKDKDKBK?K?K;K:K8K?KCKCK>K*K*K-K-K/KEKGKEKHK6KKKKKKK KKAKEK>K{KÁK¼K¼K¿KšKKKKKKKKKKKKKKKK&KCKCKBKRKªK¼K¹K¹K¹K¹K>KK KKKKK KgK¹K½K®K‰K]KDKIKZK\KJK=K?K=K=K6KKKKK.KAK=KK>K=e]r§(KKKKKKKKKK KKKKK$K(K,K0K+K%K&K&K&K KKK KKKKKKKKKKKK K K K KK"K K"KK5KMK>K>K;K9K:K8K"K8KAK?K=K>K1K6KCKAKDK?K/K,K*K"KKKKKKKKKK K K K K K K K K +K K K K K K K K K KKKKKKKKKKKKKKKKKKKKK KKKK:KPKSKPKPKQKQKQKPKPKPKPKPKPKPKPKPKPKPKPKPKQKOKQKOKQKPKPKPKPKPKPKPKPKPKPKPKPKPKPKQKQKOKMKOKNKGK@KCKFKHKHKFKIKIKbKPKEKDKMKŽK—K‹K?K4K0KMK^KPKKÈKÞKeKFKHKrKÔKÍKÒKÊK—K“K“K—K€K2K>K…K€KCKHKBKgK˜K“K“KLK3KiK—K•K–K—K–K˜KbK@KAK@KKK„K™K–K—K—K—K—K•KšKpK:KRKKXKBKBKJKK˜K–K™KKDKLK„K™K–K–K–K–K™K„KEKDKDK?KjKšK–K–K–K–K–K–K–K™KŠKLKHK€KƒK?KCK;KdKœK•K—KœK}KGKKK…KšK—K™K˜K›K`KK>K?K>K>KFKGKFKGKFKCKK=KKGKQKEK?K>K>K?K(KKKKKwKŠKSK>KAK?e]r¨(KKKKKKKKKKKKKK#K'K*K1K.K#K%K&K&K&K$K#K$K"KKKKKKKKKKKKKKKKKKKKK6KKKOKXKGK;K:K4K#KK4K5KK +KKKKKKŒKcK@KFKCK†K™K•K˜K‹KKKEK{K™K–K–K–K–K˜KKKKBKDK?K^K”K—K—K—K—K—K—K—K˜K’KXKFKpK’KIK@K?KVK—K—K—K›KŒKMKEKwKK˜K˜K˜KœKrK=KBK@K@K?K?K>K?KCKGKGKGKFKBKK@KGKKK=K@K@K?K7KKKK$K•K»K™KYKKKBe]r©(KKKKKKKKKKKKK K&K*K-K+K$K&K&K&K#KKK"K$K!K#K'K'K'K$K#KKK KKKKKKKK KK K +K9KNKmKsKSK;K:K3K$K>K@K>K=K:K/K8KAKBKBK=K-K*K,KK KKK KKKKKKKK K K KKK K K K +K +K +K K K K K KKKKKKK K K K K K K +K K K +K +KK KKKKK%KKKK0KKKQKMKNKQKQKQKPKPKQKQKQKQKPKPKPKQKOKMKOKQKPKPKPKQKQKQKPKPKPKPKPKPKPKPKPKPKQKQKQKQKQKNKNKQKMKCK=K@KGKFKGKHKGKEKGK€K˜KK>K2K2KKK +KK0K/KCKJKGKWKŸKÂKâK¼KeKŒK¢K“KŽK>K2KqKŽKKKDK@KZK•K’K›K`K4KZK”K—K–K—K–K›KtKBKEKDKEKuK™K–K—K—K—K—K–KšKƒKDKDKƒKpK?KFK?K{K›K•K˜K’KRKAKnK™K–K–K–K–K—K–KVK?KDK>KRKŽK˜K—K™K™K™K™K˜K–K™KbKCKbK•KUK=KAKHKK›K˜K™K”KYKBKkKœK˜K˜K˜KœKƒKBKBKBKAK?K>K?K?K@KHKIKGKFKBKKFKGK=K5K:K9K7K8K8K5K:K?K>KFKAK7K8K=KHKxK›KšK\KjK¿KŸKcKsK¡KšK›KfKDKVK³KÃKÀK¾K¡KŽK+KKK7KLK“KÇK¿KÅK©K‘KKœK˜K™KRKAKLK›KÈK¾KÇKšKTKeKFKEKGKEKFKKKDK†KÇK¿KÀK¾KiKCKHKGKHKDKDKDKCKDKFKVK´KÄK¿KÀK·KZK@KDKBKAK>K=KKCKDK?K-K-K-K,K1K?KDKCKCKEK5K"KKKK K KK>KCK@K\K¶K½K°KIK)KKKKKKKKKKKKKKKKK>K@KBK>K…K¾K¸K¹K·K½K}K +K K +K-KGKBKCK”K¿K¸KºKºK·K½KžKLKXKŒKQK?KAK>K?K+KKK5K§K³K±KKbKZe]rª(KKKKKKKKKKKKK%K)K-K,K$K&K%K&K$KKKKKKKKKK K!K"K!K#K'K(K&K&K KKK K +K +KK K=KTKŒKKaK=K;K1K"K>K@K?KKEKIKHKGKwK½K¶K¨KOKZK—K•K’KDK/KjK”KOKCKAKSK”K•KšKkK3KRKK—K–K—K–K™K}KCKDKBKAKkK™K–K—K—K—K—K–K˜KKJK>KzK}K@KFK>KnKšK•K–K˜K\K?KdK—K–K–K—K˜K—KšKdK@KFKAKJK†KšK—K˜K˜K™K™K˜K—KœKpKCKVK•KdKKBKAK?K>K>K@K>KDKHKGKEKDK=KK=KKKK>K?K9KAKHKGKDKEK?K:KEKGKAK6K7K7K8K8K5K7K9KK=KKCK>KhKÂK‚K)K*K,KKKKKKKKKKKKKKKKK>K?K?KAK‹K¾K¹K¹K·KÂKsKKKK!KFKDKDK•KÂK·KºKºK¸K¼K™KFK_K®KXK?KCK@K>K.KKVK¶K´K´K²K€Kie]r¬(KKKKKKKKKKKK&K)K)K&K%K%K'K#KK KKKKKKKKKKKKKKKKKKKKKK K K K KKCKfKÀK®KpK:K9K,K)K@K?K?K;K7K-K>KDKCKCK8K+K,K+KKKKK K KKKKKKK K K KKKKKKKKKKKKKKKKKKK +K K K +K K KK +K K +K K K KKKKKK#KKKKKKKKK3KLKNKPKQKPKOKMKNKQKQKPKQKPKNKQKPKQKQKQKQKPKPKPKPKPKPKQKQKQKPKPKPKPKPKQKOKMKPKQKQKPKPKPKPKOKNKGKKDKFKHKDKEK?KDKKKKK&K;KDKHKFKFKxKnKxK‰K–K•KK•K›KWK,KYK•K]KCKFKFK‰K˜K™K€K6KDK‚K™K–K—K–K˜KKLKDKCK?KUK•K—K–K—K—K–K–K–K™K]K:KdKKKKFKBKVK—K˜K–K›KvKBKSKK›K˜K˜K™K˜K›K|K@KEKDKBKmK›K™K˜K™K™K™K™K˜K›KŠKJKFK~K…K?KCK=K`KK—K˜KžK†KJKIK€KœK˜K˜K—KKlKK?K>K=KBKEKFKFKDK@K:K@KFKCK9K7K8K7K7K7K5K5K:KK7K7KK>K>K=KKKKKKK:KHKEKDKFKbKbKQKvKªK«K”KœK`K+KPK”KdKBKFKDK„K™K˜KŠK;KK?K?K>K?K>K>K>K?KFKFKFKDK@K;K?KEKEK?K7K8K7K7K7K5K5K8K;KK?K?K=K;K9K9K@KCKEK:K-K.K.K/K4KAKEKDKFK@K-K&KKKKK K K@KCK?KgKMK&K,K)K'KKKKKKKKKKKKKKKKK?KBKDKBK“K¾K¸KºK¶KÀKmKKKKKBKAKBK,KvK¶K°K³K³K°Kye]r®(KKKKKKKKKKK"K+K&K%K%K&K"KKKKKKKKKKKKKKKKKKKKKKKKK KKKK K!KHK‰KÛK±KbK7K9K&K.KDKAKK?KK=KDKDKBK6K5K8K7K6K8K7K6K;KK;KK-K*K+K)K*KK KKKKKKKKKKKKKKK5KDKBK=KhK¸K¸KºK¹K½K¨K!KKK%KEKDK@KdKºK»K¶K¸KºK¹K·KjKDKžKŽK=KBKBKAKKEKRKcK‰KžKtK*KBKKwK>KDK=KqK›K—K—KIK3KiK™K–K—K—K–KœKfK?KFKBKDK}KšK–K˜K™K™K˜K–KœK~K@KHKˆKnK>KEK@K}KžK—K™K”KSKDKpK›K˜K˜K™K˜K˜KœK\K@KDK?KMKŒKK˜K™K˜K™K™K˜K—KKrKAKUK—KiK=KDKK=K=KK‰KŸK›K˜KWKEKdK¾KÀKÀKÂKPK KKKK9KMKžKÆK¿KÆKŠKKK;K@KDKDKCKEKDK@K6K?KBKBK2KK3KFKPK…K¡K}K—K}K/K;K…KK?KEK=KiK›K”KšKQK0KaK˜K–K˜K™K˜KKoK>KGKGKBKuK›K˜K™K™K™K˜K˜K›KˆKEKCKKzK?KEKK>K*K;KHKFKGKEKAK;KAKCKDK9K6K8K7K7K8K7K7K9K9K=KDK?K8K7K;KJK‚KKœKZKZKlK@K8KqK¡KšKŸKjKHKSKªKÄK¾KÈKfK KKKK*KFK}KÂK¾KÃK²K5K KKKKK8KJKxKÃKÀK¿K¼K˜KuKDKEKGKGKGKHKHKZK·KÃK¿KÆK KHKDKCKDKCK9K9KBKBKHKDKxKÀK½K½KÃK›K@K@K>KKAK4KKK+KK`KšK”KœK[K.KYK•K˜K˜K™K—KKyKAKEKDK?KlKšK˜K˜K™K™K™K˜KšK“KMK>KvK‡KAKEK=KeKK˜K—KKkK?KYK’K™K˜K˜K˜K—KKwK@KEK@KBKsKKšK™K˜KšKšK™K˜K›K‹KLKGK{K‹KBKBKK?K=K?K&K.KHKGKGKDKAK;K>KEKHK=K3K6K7K8K6K5K5K7K:K:KAKCK9K7K9KBKpKžKžKpKGKJK=K8KYKŸKœK¢KKIKFKŽKÆK¾KÊK‚KKKKKKDKaK¹KÁKÀKÁKCKK)KKKKDKMKWK·KÃK½KÂKŸKZKCKGKEKEKGKGKIKHK˜KÄK½KÀK½K^KBKFKDKCK;K;KDKCKGKGKVK´KÀK½K¿KºK[K=KAK=K=K=KKAKMK•K™K›KœK˜KYK?KhKœK›K›K›KŸKŠKCKAK?K>K?K=K@K+KKGKHKGKCKAK;KKBK=K=K=KK[K—KœK›K›K›K›K›K›K›KKdKDK`KšK\KK@K>K?K=K>K5KKCKIKFKDKCK>K;KEKCKBK7K4K5K5K7K7K4K5K8K:K=KFK;K7K7KK;K}K¢KœKŸKcKEKWK±KÄKÁK½K;K KKKK.KHK‚KÇK½KÇK£KMKLK0K0K=KK9KFKyKÃK¾K¿K¼K§KKGKGKEKEK>KAKKKVK±KÁK½KÃK¦KGKDKDKBKDKCK?KAKBKHKDKkK½K¾K¾KÂK¨KHK>K>K>K=KKEKCKCK3K)K,K&KKKKK4KDK>K?K.K(K)K(K)K KKKKKKKKKKKKKKKK(KDKBK?KLK¦K¼K¹K¸K¶K¾KSKÿK KK+KFKAKJK KÀK¾K¸K¶KµK½K•KDKiK½K_K=KAKAKKJKK™KK~K1K@K…KœK˜K˜K˜K™K’KPKCKDK?KNKŽKšK˜K™K™K™K™K—KŸKnK;KTK“K^KAKBKBKŒK›K˜K›KKKKEKwKŸK›K™K™KœKœK—KRKAKDK>KRKKžK›KœKœKœKœKœK›K KqKCKQK•KlK:KCK;KzK¡K›K›K KxKDKOKŽKžK›K›K›KŸK_K:K@K>K?K=KKK:KKKFKEKDK?K:KBKFKEK9K4K5K4K7K7K4K5K7K7K9KFKAK6K7K:KBK|K¡KžKfKCK:KKEKDKDKCK@KAKBKGKGKMK§KÂK¾K¿KÀKjK9K@K>K=KKAK8K'K)K)K(K'KKKKKKKKKKKKKKKKK?KAKDK=KzK¾K¸K¸KµK¼K˜KKKKK=KEK=KsK¼K¿K»K¶K¶K·K³KeKEK£KšK?K>K=K?KGKšK·K²K°e]rµ(K—K–K–K•K•K•K–K–K—K˜K™KšKšK›KœK›K—KK‹K‚KyKqKcKVKKKAK8K0K+K'K"KKKKKKKKKKKKKKKKGKlKÑKÃK}K?K9K7K7KAKBKAK?K6K5K@KFKCKDK>K,K*K+KKKK K K +K K +KKKK KKKKK KKKKKKKKK K K K KKKKKKKKKKKKKKKKKKKKKKKK&K,KƒKŸK˜K—K–K–K–K•K–KšK›KˆKcK5K#K%K(K$KKKK$K;KLKNKJKIKMKKKKKNKNKMKMKMKMKNKMKMKNKNKLKNKMKNKMKMKMKMKNKMKMKNKMKMKMKNKLKNKNKMKNKMKMKMKNKMKIKKKMKIKBK4K4KBKDKEKBKCKBKLK%K=KVK‚KQK'KYK™KXKBKCKDKK›K›K‡K6K9K|KžK˜K˜K˜K™K™KWK?KEK>KIK‰K›K˜K˜K˜K˜K˜K—KKxK?KKKKiK=KCK?KKŸKšK™K–KTKAKmKŸK›K›K›KœKšK›K`K?KDK?KHK„KŸKšKœKœKœK›K›K›K K‚KDKHKŠK€K=KDK;KiK K›KšKŸK‡KHKHKKŸK›KœKšK¡KqK;K@K>K?K=KKkK K¡K|KEK=K;K:KNK•KžK KKLKEKxKÄK¾KÇK“KKKK KK=KOK©KÂK½KÉKoKK,K`K~KWKQKGKIK›KÃK¼KÄK®KyKaKDKEKCKDKDKFKDKmKÁK¾K½KÅKŠK@KDKDKCKBKBKBKBKCKGKBK„KÂK½K¼KÃK“K=K=K=K=KKkKµK³K°e]r¶(K—K—K—K—K—K—K—K–K–K–K–K–K–K–K—K—K–K—K™K™KšKKžKšK—K•KK‡K~KsKeK[KPKFK>K6K.K'K#KKKKKKKKHKtKØK¼KwK=KK)K*K)K&KKKK*K?KLKKKLKKKLKMKNKMKMKNKNKMKNKMKNKNKLKMKNKMKMKMKMKMKMKNKMKMKNKMKMKNKMKNKNKMKMKMKMKMKNKMKKKLKLKLKMKHK>K;K?KAKAKCKEKDKAK>K>KqK_K#KOK˜KbK?KGKBK‚K›KšKKKFK?KEK€KK™KšKšKšKšK™KžK…KBKCKˆKvK=KEK=KsK KšK™KœK`K@KaK›KœK›K›KœKšK KmK=KEK@KDKzK K›K›KœKœKœKœK›KžKKKKBK|KKCKBKK?K>K?K>K=KAK*KKGKFKFKDKDK>K=KBKDK@K3K3K5K4K4K4K4K6K8K9KAKDK8K5K7KK‡K KžKK[KEK[K¸KÂKÀK¶K2K KKKK0KEKˆKÄK½KÇKšK!KAKYKGKbKZK?KDKyKÃK½K¿K¹KuKdKHKDKCKDKCKEKHKRK«KÁK½KÂK¬KLKBKDKCKBKBKBKBKCKHKDK]K»K¿K½KÀK³KPKK=KKCKCKCKEK:K)K+K,KKKK K K K K +K K +KKKKKKK KKKKKKKK K K +K K KKKKKKKKKKKKKKKKKKKKKKK$K5K@K†K›K˜K™K™K™K™K™K™K™K™K˜K—K›KK”KqKIK0K-K,K(KKK K2KIKOKKKKKKKMKNKMKNKNKLKNKMKMKNKMKMKOKMKNKNKNKNKMKMKMKNKMKMKMKMKNKMKMKMKMKNKNKNKNKLKKKNKMKKKKKLKLKEK=K;K=KCKDKDKDKFK=KbK`K#KGK“KiK=KGK>K{KœK˜K˜KDK0KkKœK˜K˜K˜K˜KŸKhK=KDK@K@KxK K›KœKœKœKœKœKŸKŽKGKAK|K‚K?KFK>KeKŸK›K›K KnKAKVK–KK›KœK›K›K K{K@KDK@KBKlKžKœK›K›K›KœK›K›KœK–KWKBKjK˜KNK?K@KIK•KK›K›K›K]K?KcKKœK›K›KžK‘KGK=K?K>K?K>K@K3KKCKGKFKGKFK>K;KCKDKBK4K4K5K4K4K4K5K4K7K7K9KEK>K7K8K:KJK‹K¡K›K[K@K=K>K9KsKŸK™K¢KoKBKJK¡KÆK½KÅKcKKKKK$KCKhK¾K¿KÂKºKCKjKŽKTK:K4KEKIKZK¸KÀK½KÁK©KhKCKEKCKDKCKEKIKDKŠKÆK½K¾KÀKlK@KEKDKBKBKBKAK@KEKGKGKKÄK½K¾KÂKvK:K?K=KK?KKsKžK—K™KNK.KbK™K™K›KšKšKŸKuK>KBK?K=KmKžK™K›K›K›K›K›KœK˜KNK?KpKKDKDK>KWKK›KšK KyKAKLKK KœK›K›K›KŸKŠKCKBKAK?K^K™KœK›KKKœKœK›K›KžKeKAKYKK]K;KAK>KˆKŸK›KœK¡KoKAKVK—KKœKœK›KKVK;K?K?K>K?K?K:KK:KFKEKGKDK?K9KAKDKCK6K2K5K5K4K4K4K4K5K5K7KCK@K5K8K8K@KxK£K¢KpKAK;K:K8KXKK›K£K…KGKDKƒKÆK½KÃK¥K-KKKKKAKRK¬KÃK¾KÄK{KvKœKšKOK$KPKKKIKœKÄK¼KÀK¶KKiKAKDKDKCKDKHKFKgK¾K¿K½KÅK’KCKDKBKBKBKBKAK@KCKFKCKvKÂK½K½KÃKŸKDK>K=KKFK>KhKK—KœKYK,KVK—K›KœKœK›K KK@KAK>K:KcK›K›KœK›KœKœK›K›KžKYKK>K>K=KK/KGKDKGKDK@K:K>KDKEKKDK6K8K7K9KeKŸK¡K†KGK=K:K9KCK“K›KžK˜KSKBKfK¿KÀKÀKÀKYKKKKK6KHKKÅK½KÄK£K‰K¡K¥K†K5KEKHKEKxKÂK¾K¾K½K–KoKDKCKDKCKCKEKGKNK¡KÂK½KÀK°KQK?KBKBKBKBKBKBKBKEKEKUK±KÀK½K¿K»K_K;K>KK9K8K=KCKDKCKDK7K*K+K)KKKKKK K K K K K +K KKKKK KKKKKKKK +K K KKKKKKKKKKKKKKKKKKKKKKKKK(K:KBK…K›K˜K˜K˜K˜K˜K˜K™K™K™K™K™K™K˜K˜K˜K˜K—K—KœKœKŠKdK@K,K*K'KKK3KJKOKLKMKMKMKNKMKMKMKMKMKLKKKMKMKLKLKNKMKMKMKMKNKNKMKMKMKNKNKLKLKLKMKMKMKMKLKLKLKLKKKKKKKKKKKLKLKEKAK=K=KAKAKBKCKDKGKPK;KAK;K^KK™KŸKbK,KOK“KœK›K›K›K KˆKCKDKCK;KYK—KœK›K›KœK›K›KšK KgK:KXK–KWK?KAKDKKžKšKžK‘KKKCKtKŸKœKK›K›KœK›KVK?KBK?KKKˆK KKKKKKKœK¢KƒKDKFK‰KƒKK=KK:K=K=KeK‚KœK¢KgKEKQK¨KÁK½KÄKeKKKKK(KFKoKÃK¾KÂKºKKK¡K KzK\KVKEK\K·KÀK¼KÆK…KHKLKCKDKDKCKEKHKCK€KÃK½K¾KÃKtK>KCKBKBKBKAK?K?KBKHKEKKÄK½K¼KÂK…K:K@K>KK{K»K¼K¹K¶K¶K·K²KcKCK˜KŠKK@K>KEK•e]r»(K™K™K™K™K™K™K™K™K™K™K™K™K™K™K˜K™K™K™K™K™K™K™K™K™K™K™K™K™K™K™K™K™K˜K™K™K™K™K™K™K™K˜KšKKNK*K4KSK¯K×K¡KUK9KK@KBKBKAKBK?K9KSKKšKŸKoK+KFKKK›K›K›KžK’KJKCKDKK:KOK›KžKKŸKšKVK@KhKŸKKžKK¡KŽKCK=K?K=KK2KKCKGKFKEKCK;K:KCKCKDK8K4K5K4K4K4K5K3K5K6K8KCK>K6K6K6KDK…KžKœK_K>KK?KBKGKDKmK¿K¾K½K¿K«KHKK=K;K9K8K8K8K6KK6K'K'K*K*K+KK K K K +KKKK K KKKKKK +K6K@K@K>K]K³K¹K]K%K*K#KKKKKK>K?KPKªK¿K¹K¶K·KµK»KKDKbK¬KXK9K@K?K=Kce]r¼(K˜K˜K˜K˜K™K˜K˜K˜K˜K™K™K™K˜K˜K™K˜K˜K˜K˜K˜K˜K˜K˜K™K™K™K™K™K™K™K˜K˜K™K˜K˜K˜K˜K˜K™K™K˜K›K‹KKK*K:KWK¹KÓK›KOK9KKEKˆK›K˜K›KœKœK›KœKšK˜K˜K˜K˜K™KœK›KœKœK›K˜K˜K˜K˜K—KšKžK”KxKBKKKKK%K@KOKOKMKNKNKNKMKKKMKNKMKMKKKLKNKMKMKMKNKLKJKNKMKNKMKJKKKLKNKMKKKMKNKLKKKLKKKKKKKKKKKKKKKLKLKKKLKIKEK?KK‡KžK›K›K›KœK™KRK>KCK=KJKŒKžK›KœK›KKžKK¢KK=KEKŒKtK>K?K-KvK¡KšK›KK]KKhKžKPK=K?KBK“K KKœKŸKeK?KYK˜KžKKKK™KPK;K?K>KK=K;K:K8K7K8K7K8KBKFK@KK¿K¹K»K½K²KWKAKDKDKBK0K(K*K+K)K)K$K K:K@K?K=K-K(K)K*K*K"KK K K +K KKK K +KKKKKKK!K@K@KBKAK”KµKIK&K*K'KK +K K +KK"KCK>K€K¿K¹K¶K·K³K´K°KdKBK˜KKK@K@KAe]r½(KšKšKšK™K˜K™KšKšK™K˜K™K™K™KšK˜K™KšKšKšKšKšKšK™K˜K™K™K™K™K™K™KšK™K˜KšKšKšK™K˜K™K™K˜KœK‡KHK(K=K[KÁKÎK“KIK9K;K9K;K@K@K=K6K9K?KBKBKDKCK1K*K+K)KKKKKKK K K K K KKKKKK K +K KKKK +K +K +K K KKKKKKKKKKKKKKKKKKKKKKKKK,K>KEKŠKœK™K›KœKœK›KœKšKšKšKšKšKšKœK›K›KœK›KšKšKšKšKšK™K™K™K¤KyKKKKK KK.KJKPKMKMKNKMKLKMKNKMKMKLKMKNKMKMKMKNKMKKKNKMKMKMKJKKKLKMKLKKKMKLKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLKJKIKEK=K;K>KAK@K>KBKBKMKpK—KˆK/K8K}KŸK›K›K›K›KKYK?KCK@KDK„K¡K›KœKœKKžKK K‰KAKAKƒK€KAKCK.KgK¡K›KœKžKjK>KTK•KŸKKKKK¡K€K@KCK@K=KbKKžKKžKžKžKKžKK¡KbK?KZK K`KKKDKDKKBK5K5K7K8K\K™K£KKIKAKK?K3K'K*K+K)K*KK +K K K K K K K K KKKKKKK6KAKAK;KhK£K9K'K*K)K"K KK K +K K5KAKSK¬KºK¶K¶K´K³KºKKCKgK»K]K8K?K?K;e]r¾(KœKœKœKšK˜K›KœKœK›K˜K˜K˜K›K›K˜K™KœKœKœKœKœKœK›K˜K™K™K™K™K˜KšKœKšK˜K›KœKœK›K˜K˜K˜K—KœKKDK%KAKbKËKËKŒKCK8K:K4K:KAK?KKFK‹KžK›KœK›K›KœKœKœKœKœKœKœKœK›KœKœK›KœKœKœKœKœKœKœKœKšK KyKKKKKKKKK9KOKOKMKMKNKNKMKMKMKNKNKMKNKNKNKNKNKNKNKLKKKKKLKLKKKKKKKKKMKIKKKLKKKKKKKKKKKKKKKKKLKLKLKLKLKKKHKKKHKAK;K:K5K.K>KBK@K@KTKkK5K1KtKŸKšK›K›K›KŸKbK>KEKAK@KzK KšKKžKKKKžK’KHK=KtKŒKDKCK+KVKŸKKK KxKAKNKK KKKžKK¡KŽKGKBKCK=KUK—KŸKKžKžKžKKžKK¢KsK?KLK˜KtK9KBK7KpK¤KœKK¢K†KGKEK‚K¢KœKKœK£KyKKK;K9K:K:K8K6K7K:KDKDKDK“K¿KºK¹K½K¥KLKBKCKBK>K,K)K+K*K&K%K$K)K>K>KAK:K)K*K+K+K*K;KK K K +K K KKK K KKKK K K%K@K>K>KHKnK1K'K)K)K*KKKK KKK?K?K‚KºK¶KµK´K´KµK±KcKEK¢KœK>K>K>K?e]r¿(K›K›KœK›KšK›K›KœK›KšKšKšK›K›KšK›KœK›K›K›K›KœK›KšK™K˜K™K™K˜K™KšK™K˜K›KœK›K›KšKšKšK™KŸKxK?K'KDKjKÑKÆK„K>K:K5K$K:KAK@KKCK?KLKKŸKKKžKžKKžKœK¡KƒKCKCKˆK†K?KCK:K]K£KœKK K–KNKAKsK£KK KK¢K‹K@K>K>K>K=KK+KKEKGKCKBKBK=KK4K5K7KAK…K¢K“KhKAK>K;K5KUKŸK‰K’KpKFKCKxKÆK¿KÃK¨KUKKKKK:KIK™KÄK½K¿K´K K¢K¡KKŸK¦KlK@K{KÃK½K¾K¼KªKƒKGKBKDKCK?K@KHKFK›KÃK¼KÁK¼K]K>KBKBKBKAK?K?K@KDKFKGKŸKÁKºKºKÀK{K8K>K;K9K:K:K8K6K8K6K>KDK?KjK»K»K»KºK½KiK?KFKCKBK2K)K+K)K(K(K&K%K7K@K?K@K/K(K+K+K&K„KKKK K +K +K +K K +K K KKKK K KK:K>K?K?K;K*K&K'K&K'K!KKKKKK*K?KTK¯K¸K¶K¶K¶KµKºKŽKEKjK¾K`K:K@KAe]rÀ(KœKœK›KœKœKœKœK›KœKœKœKœKœKœKœKœK›KœKœKœKœK›KœKœKšK˜K™K™K™K˜K˜K˜K˜K›KœK›KœKœKœKœK›K KsK>K(KEKrKÖK¿K}K>K;K1K"KKEKKKNKMKMKMKMKMKMKNKLKKKKKKKMKMKKKKKKKKKKKKKKKKKKKLKKKLKLKIKLKKKKKKKKKJKJKLKJKHKHKHKHKIKLKKKHKFKGKIKEKKCK@K9K`KžKžKKKžKKKœKžK\K7K]K˜KSK>KBKGKKŸKœK K’KGKAKvK¢KKžKžKKžKŸK[K=KCKAKFK‚K KœKžKžKžKžKKK KKKKAKxK˜KHKAK?KMKœKžKKKŸK\K?KbK K K¡KžKŸK—KKKK=KDKDKCK:K4K4K4K4K4K5K5K5K5K3K>K@K4K5K6K9KjK•KœKKCK?K9K7KCKaKrK¢K‘KPKDK]K·K¿KÀK³KrK3KKKK.KFKyKÀK¼K¿KºK¤K¤K¡K K¢K¥KˆKEK[K¶KÀK½K¾K°K¢K[K@KDKDK?K7KEKAKsK¿K½K½KÃKƒKK?KCKHKAKwKÁKºKºKÁK¢KCKK>K@K:K*K+K*K1K K‰K K +K K +K +K K K K KKKK +K KK*K?K>K?K=K+K$K&K%K&K(KKKKK +KK5KAK…K¸K³K·K·K¶K·K°KbKDK KœK>K=K?e]rÁ(KœKœKœK›K›KœKœKœK›K›K›K›KœKœK›K›KœKœKœKœKœKœK›K›K›K›K›K›K›K›K›K›K›K›KœKœK›K›K›K›KœKKlK>K*KJK}KÚK»KtKK:K9K.K9KFKCKCK=K-K*K+K&KKKKKKK K K K K +KKKKKK K KKK +K K +K K KKKKKKKKKKKKKKKKKKKKKKKKKKK1K@KFK„KžK›K›K›KœK›K–K™KœKœKœK›KœKK›KœK›K›KœK›K›K›K›K›K›KšK¢KKK K,K5K1K=KHKUKUKWKNK?K?KGKHKLKMKMKLKLKNKMKMKLKKKLKLKKKKKKKKKKKKKKKLKJKIKKKLKLKKKKKKKKKLKKKHKIKLKKKKKIKHKGKHKIKIKHKHKHKIKHKHKEK=K7K:KAKAKCKCKBKCK_K‰KŸKŸK KƒKAKBK?K8KWKšKžKKžKžKKKœK KhK5KRK™KaK=KBK@K„K¡KœKžKšKRK>KgKŸKžKKKKœK¢KjK;KCK@KAKtK¢KŸK K K K K K KŸK›KUKKBKBKK£KŸKŸK¢KlK@KSKšK¢K K KŸK¡K]K:K>K=K=KK7K:K9KXK†KžKœKdKCKKK¢KÃK¼KÁK€KKKKKK"KCK\KµK¾K¾KÀK«K¢K¢K¢K¢K¥KšKVKHKœKÃK¾KÀK¶K˜KkK?KDKCKAK@KDKEKVK²K¾K½KÀK¦KGK@KBK@KBK@K>KAKBKEKAKVK´K¿K»K¼K»K`K:K>KKEKCK@K0K*K*K*K)K)K(K'K;KBKAK>K0K-K*KDK­KµK4KK K K K K +KKKKKKK K KK;K?K>K@K3K%K&K%K%K'K K KKK +K KK;KYK¯KµK¶K¶KµK´KºKŒKEKhK½K^K:K@e]rÂ(KœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœK›K›KœKœKcK9K,KKK‰KÝK³KlK;K=K*K&K>K@K=K:K8K,K;KEKCKCKKKAKAKCKEKDK’KÃKºKºKÃK‰K;K>KK>K?K;K*K&K%K%K%K&KKKKK KK0KCK‡K»KµKµK´K´K¶K¯K`KEK¢KK@K@e]rÃ(KœKœKœKœKœKœKœKœKœKœKœKœK›K›K›K›KœKœKœKœKœKœKœKœK›K›K›K›K›K›K›K›K›KœKœKœKœKœK›K›KK™K]K7K/KLK”KÛK­KfK;K=K*K*K>K?K>K:K6K+KKAK;KDKK KKžKžKKKœK¢K„KKCK:KiK£KœKœK£KlK;KRK”K K K KKžK¦KƒK>KBKAK=KZK›K¡K K K K K K KŸK¦KrK>KMK˜KxK=KDK8KoK¤KžK K¥KKIKBK|K£K K KŸK£KKK?KDKDK@K5K2K5K4K5K4K1K2K3K2K5KBK>K6K5K5K=K{KŸKRKK?K?KBKHKBKlK½K»K»KÀK­KKK9KK2K#K#K%K%K%KKKKKKK#KAK[K±K¸K´KµKµK´KºKŒKEKiK¼KaK9e]rÄ(KœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœK›KœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœK›K›KK–KXK4K4KOK KÙK¨K^K9KKBKEKEK@KJKBK;K?K;K?K…K£KKKžKžKŸKK KK@K7KzKŒKAKCK=K\K KKK¤KyK>KHKŠK¢K K KžKŸK¤K’KFKAK@K;KNK”K£K K K¡K¡K¡K K K¤K„KCKDK‰KK>KBKKCKCKAK7K3K4K4K4K4K1K2K3K2K2K>KCK6K5K5K8K^K‹K…K]KFK=K:K9K8KdKpKJK{KXKAKPK¬KÂK¾KÃK^KIK3KKK#KDKcK¼K¾K¾K¾K©K™K˜KœKžKŸK“KSKIKKÃK½K¾K¸K—K^KAKCKBKCK@KEKEKRK¯K¿K»K¿K®KMK@KBKBK@K>K?K?KBKDKEKNK¨K¿KºK»KÀKoK9K?K;K9K8K8K8K6K4K5K>KCK@KiK¼KºK¹K¹K¼KlK>KDKAK@K4K+K)K)K)K)K&K#K3KAK?K@K4K+K‹K½K´K¿KeKK K K K +K K +K KKK KKKK +K0K?KK:K9K7K+K>KDKCKBK7K)K,K,K!KKKKKKKKKKKKKKKKK K KKK +K K K KKKKKKKKKKKKKKKKKKKKKKKKK!K!K K5K@KGKKžKœKœK›K–K–K•K™KtKCKuK›K˜K—KžKžKKžKžKžKžKžKžKKK KŠKgKmKiKfKgKfKcKaK_K_K]K[KTKLK=K2K%KKKK*KBKNKKKMKNKLKKKKKKKLKIKHKKKKKKKLKKKKKKKKKKKLKJKHKHKHKKKKKHKIKHKHKHKHKHKHKHKHKHKHKHKHKHKIKIKGKFKFKGKHKGKAK;KKIK›K¢K K K¤KcK>KZKžK¡K K K¡K¡KTK:K=KK:K;K9KJKyKcK{K`KDKEKKÆK½KÄKŒK\KDKKKK@KOK¥KÀK½KÁK°KK†KƒKŠK“KžKfKAKzKÃK½K½K¾K”KxKIKBKBKBKBKBKFKBKŽKÄK»K»K¾KjKK?K?KBKBKGKCK„KÂKºKºKÁK™K?K;K:K:K8K8K8K6K5K3K:KDKDKLK£K¾K¹K¸K¾K”KBKBKAKBK=K+K)K)K)K)K'K$K)K>KBKCK;K8KœK½K·K¼K KK K K K +K K KKKK K +KKKKK;K:K=K=K0K$K#K&K&K'KKKKKKK,K@K\KµK¹K²K®K³K³K¹K‰KAKjK½Kbe]rÆ(K›KœKKKKKKKKKKKKKžKKKKKœK›KœKœKœKœK›KœKKKKKœK›KœKœKKœK›KœKœKŸK‰KOK-KK;K9K5K-KAKCKCKCK7K)K*K*KKKKKKKKKKKKKKKKKK K K K K +K K K KKKKKKKKKKKKKKKKKKKK K KKKK K!K K5KBKGKKŸKœKKŸKžKKœK¢K|K:KJK†K‘K™KKKžKœKKžKœKœKžKKK K‹KdKbKdKeKcK_KaKbKgKsK{K[K/K#K!K!KKKKKKK2KHKNKKKKKKKKKKKLKIKHKJKLKKKKKKKKKKKKKKKLKKKJKJKJKLKKKHKHKHKHKHKHKHKHKHKHKHKHKHKHKIKHKGKHKHKHKHKGKGKHKFK>K8K:K>KDKHKGKDKDKCK:KpK¤KžKœKŸK K¡K KŸKžKQK5KbKœKQK>K@KGK”K¡KŸK¢K”KFKK@KxK¥K K K¡K¡K¡K¡K K¢KKUK>KfK¡KQK:K@K?KŒK£K KŸK¦KvK?KOK•K¤K¡K¢KŸK¥KfK7K?K=KKBKBKBKBKGKEKiK½K»KºKÂK‘K>KAK@K?K?K?K?K@KAKHKCK`K¹K»K»K½K·KWK7K:K:K8K7K6K5K5K2K4KAKEK?K}KÀK¸K¹KºKµK[K@KCKBKAK1K*K)K)K)K'K%K%K:KBKAK>KQK­K»K¹K¸K¾KPKK K K +K K +K KKKK K K +K +K +K/K9K;K?K8K$K%K&K%K$K%KKK KKKKAK@KŽK¼K²K²K³K´K¶K­K_KDK Ke]rÇ(K›KœKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKœK›KœK›KœKœK›KKžKžKžKžKœK›K›KœKžKK›KKK¢KƒKIK-K?KYKÁKÏK–KKK8K7K"K5K?K>K;K8K3K-K@KCKCKCK7K)K+K(KKKKKKKKKKKKKKKKKK K K K K +K K K KKKKKKKKKKKKKK KKKKKK K KKKKK!K K6KDKHKK KKžKKKžKžK¡KŒK[K"KPKƒK™KKœK K—KšK˜K›KžKKžKK K‹K`K]K_KkKtK|K†KK˜KK¡KK‚KXK3K K!K$K"KKKKK"KKiK£K K K¡K K¡K¡K K K¢KeK=KUK KbK8KAK8K{K¥KŸKŸK¥KˆKDKGK„K¥K¡K£KŸK¦K}K;K@K=KK3K1K4K2K4K5K3K2K/K/K0K>K>K4K5K5K;KSK€K|KdKCKKCKBKBKBKEKEKNKªKÀKºK¿K°KNKK>KCKFKHKœK¾KºKºKÃK}K6K;K:K8K8K8K6K4K3K2K:KCKAKYK³K»K¹K¸KÀK„K?KEKBKBK:K*K)K)K)K&K&K&K/K>K@K=K[K´KºK¹K¸K¿KKK +K K +K +K K KKKKKKK KKK7K8K?K=K.K$K%K$K#K&KKKKKK K1KAKaK±KµKµKµKµK³K¸KˆKCKhK¼e]rÈ(KKKKKKKKKKKKKžKžKžKKKKKKKKKKKKKKKKžKKKKKKKKKœK¡K|KGK/KBK^KÊKÌKŽKGK9K7K!K7K@K>K;K9K1K.KCKAKAKAK6K)K*K)KKKKKKKKKKKKKKKKKK K K K K K KKKKKKKKKKKKKKKKKKKK K K K K KKK!K!K"K7KCKJKK KKžKK K–KvK€KgK9K%KXKoKvK¤K£K“K–K˜KŽK›KžKKKKŸK”KzK„KŽK—KžK K K KŸKKKžK K¡KKgK;K%K K%K$K KKKK,KBKMKKKJKLKIKHKIKIKIKIKIKKKLKIKIKLKJKHKKKLKJKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKGKGKGKGKFKGKFKFKGKHKGKBK8K8K;K2K4KEKIKFKHKbK‰K¤K£K K KŸK¨KlK2KIK™KiK=KEK=K|K¥KŸK K¡K[K9KZKœK¡K K K¡KŸK¦K{KKsK¤K K£K¡K¦KŽKBK>K>K>K=KK4KK@KGKCKDKAK>K>KAKBKAK6K2K3K2K4K1K2K2K0K/K.K9KAK7K5K4K7K_K¡KkK{KMK>K:K:K9KHKQKeK†KdKCKGKšKÄK»KÂKŒK]KJKKKK=KOK©KÂK½KÀK£K†KšK“K–KŸK¡KeK=K}KÃK»K¼K»K«KKIK?KAKBKBKBKDKAKˆKÃKºKºKÀKqK9K@K?K?K=K=K=K=KAKEKAKvK½KºK»KÀK¥KCK:K9K7K8K:K7K4K4K4K9K?KBKAKK¿K¹K¹K½K©KMK@KAKBKK6K%K$K%K%K&K%KKKK KK KCKDKK»K´K´KµK´K¶K¬K]KEK¢e]rÉ(KžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKKK¡KvKEK+KDKhKÒKÅK†KBK9K4K!K7K?K>K:K9K0K/KAKAKAKBK2K)K,K(KKKKKKKKKKKKKKKKKK K K K K K KKKKKKKKKKKKKKKKKKKK K!K K K!K K"K%K%K#K8KCKJKK KKKžKšKvKKKEKIK.K7KtK|KK˜KKvK‡KŽKŠK›KžKžKžKžKžKžKŸK K¢KžKžKžKKKžKžKKKžKžKŸK¡K–KuKKK.K#K&K#KKKKK2KGKMKKKIKHKHKHKIKHKHKJKKKHKIKKKJKHKJKKKIKGKHKIKIKHKHKHKHKHKIKIKIKHKHKHKHKHKIKGKGKFKFKFKFKFKFKFKFKEKGKHK@K5K-K5KBKDKEKHKCKGKeKŽK¤K¢KžK¥KzK2KBKKyKK?K=KK?K?K=K=KKoKºKµK¶KµK¿K~K K K K K KK +K +KKKKKKKK!K>KKIKkKK¤K¥KˆK7K:K„K‰K;KAK8K]K¤K K K¦KzK9KHKŽK£K K£K¡K K¢K”KHK?K?KKuK›KGK=K=KFK˜K¢K¡K¢K§KkK=KUKœK¤K¢K¢K¡K¤KaK9K?K?KK4K3K3K2K2K2K2K0K.K-K/KBK=K5K8K7K?KƒK¦KˆKbKBK;K9K:K3K5KIKeK~KLK@K_K»K¾K¿KºKsKNKKKGK.K$KEKiK½K»K¼K¹K‡KŽK•KžK¤K§KšKSKGKžKÀKºK¾KµK¬K|K=KCKBK?K?KCKDKJK¥KÂK¹K½K¶KUKKK?KAKEKCKK½K¹KºKÁKŒK9K;K:K9K8K6K4K5K5K0K9KCKCKJK K¼KµKµK¼K˜KBKAKBKAK9K(K(K)K&K%K&K$K)K@KBK?KJK¥K¹K¶K¶K¸K¯K+KK K K K KKKKK K KKKKK8K=K=K=K4K$K&K&K%K&K$KKKKKK#KAKEK‘K¹K´KµKµK´K¶K«K^KEe]rË(KžKžKžKžKKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKKŸKiKAK,KIKzKÚK¼KwK=KK:K9K/K3KAKBKBK@K0K*K+K)KKKKKKKKKKKKKKKKKK K K +K +K K KKKKKKKKKKKKKKKKK K K!K K K K!K K!K!K#K$K#K7KDKEKuKŸKKžKžK™K‘K›K—K£K¢KKfKmKxKzKtKkKKžK”KŸK K¡KŸKŸK¡K KžK K¡KŸKŸK K¡K¡K¡K¡KŸKŸK¡K KžKŸKžKžKŸK£K¢KŽKjK>K$K#K'K(KKK)KBKJKHKIKJKIKHKIKJKIKHKHKIKKKJKIKIKHKHKIKJKIKHKHKHKIKHKFKHKIKHKHKIKHKHKFKEKFKGKFKFKFKFKFKFKFKGKFKFKGKGKCK:K8K9KKQK¡K¢K K¥KˆKK@KK¦K¢K¢K£K£K£K£K¢K¢KKVK;KaK£KVK:K@K;KŠK¦K¢K¡K©K}K?KHKŽK¦K¢K£K¡K¦KwK9K?K>KK9K9K:K?KlK‘K…KOKCKMK¦KÄK½KÀKŒKZKJK_K{K:KKK?KFKCKjK»K¼K»K¾K¯KMK7K9K8K8K6K4K5K4K1K3K?KDK?K{K½K·K·KºK¶K]K>KBK@K?K/K'K)K'K'K&K%K#K6KDKAKK;K9K-K5KCKCKDKAK/K*K,K)KKKKKKKKKKKKKKKKKK K K K K K KKKKKKKKKKKKKKKKK!K!K K K K!K!K K"K$K$K#K#K8KDKFKyK›KžKžKžK›K™K–KxK^K‚K™K–KK{KŠKvKrK•KK˜K¢K K K¡K¡K K¡K¡K¡K K¡K¡K¡K¡K¡K¡K K¡K¡K¡K¡K¡K¡K¡K¡K KŸKžK K¤K˜KyKMK-K#K+K-KKK0KCKJKFKGKHKKKLKIKHKIKHKHKKKLKIKHKHKIKIKIKIKIKIKIKHKFKHKIKIKIKIKGKFKGKGKFKFKFKFKFKFKFKFKFKFKFKFKFKGKCKDKDK=K:K=K?KBKFKHKFKCKTKpKEK0KfKœKKK?KAKEK–K¥K¡K¢K—KFK:KoK¨K¢K¢K£K£K¢K¦KbKK=KqK§K¢K¢K£K¢K¢K¢K¢K¢K¦KeKK=K=KK@KBKBK?K7K3K2K4K5K3K2K3K0K.K-K8KEK8K4K5K5KVKœK{KSKHK@K7K9K9K@KXKpKmKPKBKEK‰KÅK¼KÁK¦KyKEKAKdKaK>KHKKÁK¹K¿K©KoKyKK¢K¥KªK‚KBK\K¶K½KºKÀKžKkKLK?KBK?K?K@KEKBK]K¸K¼KºKÀKŸKAK>K?K>K:K3K6K=KK@K>K9K8K-K5KCKBKCK?K.K(K*K'KKKKKKKKKKKKKK KKKK K K +K K K KKKKKKKKKKKKKKKKK K K K K!K K!K"K"K#K$K#K#K7KBKMK‘KšKžK KŸK K¡K˜K…KK†KŠKK~KfK€K‰K}K‘KKœK¡K K¡K K K¡K K K K¡K K K¡K¡K¡K¡K¡K K K¡K K K K K K K¡K¡K KŸK K¦K¡K†K\K7K*K'K'K"K"K5KEKHKHKHKJKIKHKHKIKHKIKJKIKHKIKHKGKGKGKGKHKIKHKFKHKIKGKHKIKHKHKGKFKFKFKFKFKFKFKFKFKGKGKGKGKGKGKEKEKFKDKAK>K;KK?KBKBKAK:K1K3K3K3K3K2K3K0K,K-K4KCK;K4K5K7KEKK™KPKDKBK:K:K9K;KGKVKVKUKDKCKgKÀK¾K¿K·K…K]K[KgKˆKcK>KqK¾KºK½K·KwKcKsK›K¦K©K›KQKHKŸKÁKºK¼K·KžK`K>KBK?K?KK@K=K8K5K,K7KCKBKBK>K,K(K)K&KKKKKKKKKKKKKK!K KKK K +K K +K KKKKKKKKKKKKKKKKKK!K K!K K K K!K$K"K#K%K#K#K7KBKNK‹K”KœK¡K¡K¡K KK–KŒK—KdKYK‹KKKKK‚KKœK¡K K K¡K K K¡K¡K¡K¡K¡K¡K K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K K¡K¡K K KŸK K£K•KmKXKK9K;KBKAK=K2K2K2K2K2K2K3K0K,K.K.K>K>K4K5K7K9K~K—KFKNKDK;K8K:K7K;KFK9K0KBKEKLK«KÂK½K¾KœK^KjK{KjK…KHKTK³K¾KºKÀK†KpKbKwK«K¦K§KfK=K}KÁKºK¼K¼K³KKDKAK?K?KKGKCK^K¶KºK¹KºK·KXK2K8K8K6K5K3K2K3K2K1K?KCK?KgK¸K·K¶KµK»KqK:KCKAK?K5K(K)K)K&K%K$K"K/K?K>K>KaK³KµK¶KµK¼K–KKKKKKKKK K K K +K +K KKKK;K8K5K+K8KCKCKDK>K-K*K)K$KKKKKKKKKKKKK!K!K KKK K +K K K K KKKKKKKKKKKKKKK K K K!K K"K#K#K#K$K"K#K$K#K&K8KBKMKK‘KœK K K K¡K’KnKKKrKuKkKvKKtKKxKrK€KœK£K K K K K KŸK K¡K K K¡K¡K K K K K K K K K K K K K¡K¢K¢K¢K¢K K K K•KƒKnKrK‡KuKHK&K$K#K#K3KIKLKHKHKIKHKHKIKIKHKHKIKHKGKGKFKFKGKGKGKHKGKGKFKDKIKHKGKGKFKFKFKFKGKFKFKFKFKFKGKFKFKGKFKFKFKFKFKGKEKBKBK>K:K8KK?KAKAK?KBKCK7KKK?K@KDK—K»KµK¶K¶KºKDKþKKKKKKKKKK +K K K K +K*KK:K8K4K+K:KCKCKDK>K-K+K)K#KKKKKKKKKKKKK!K!K KKK K +K K K K KKKKKKKKKKKKKKK K K K"K!K#K$K$K$K$K"K#K%K#K&K8KBKLKŒKK›K K K¡KŸK˜K{KdK_KhK]KIKnKƒK|KoK~KšK˜KžK¢K£K¢K¢K£K KžK¡K¡K¡K K K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¢K£KK™K¡K K¡KžK„KƒK…KK–KKIK\K4K/K,K-K;KJKJKHKHKIKHKHKHKHKIKHKFKGKGKGKFKFKGKIKGKGKHKFKIKHKFKFKGKGKGKGKFKFKFKFKFKFKGKEKFKGKFKGKFKFKFKGKDKFKGKEKEK?K8K6K:K=K=KBKAK=K@K>K4K\K©K¢K K©K}K5K?K‰K¨K¡K£K£K¢K¥K™KJK@K?K;KAK„K§K¢K¦K¦K¦K£K£K¥K¥K¡KWK:KcK¦K\K:K?K8K†KªK¤K¢K§K†K@KCK‡KªK¤K¦K¥K«K‡KK9K?KCKCK6K.K2K3K3K2K3K2K/K.K,K7KDK7K4K6K6KPK¢KŠKJKGK@K9K9KKyK¼KµK¶K·K·K_K>KBK>K?K.K(K)K'K$K&K%K"K3KAK@K=KoKºK¶K·K´K¿K…KKKKKKKKKKK K +K +K +K KK:KK>K;K9K5K*K:KBKBKBK;K+K*K*K#KKKKKKKKKKKKK!K K!KKK K +K K +K K KKKKKKKKKKKKKK!K K!K K"K$K#K#K#K#K$K"K!K!K$K'K8KBKLKŽKtK‘K¤KŸK KŸKˆK‘KtKeKkKbKnK…K…KƒKfKK–KK’KzKqKšK•K‡K–K¡KŸK¡K£K K›K£K¢K¢K¢K¢K¢K¢K¢K¢K¢K¢K£K¢K K¢K™K‰K¡K¦K K¡KžK K–KKˆKsK|K¡KqKKKKK(K@KJKIKHKIKIKHKIKIKIKIKIKHKGKFKGKFKFKFKGKGKGKIKHKGKGKFKGKGKGKFKGKFKFKFKGKGKGKGKGKFKFKFKFKFKFKFKGKGKFKGKGKCK;K8K8KK?KK=K9K:K:KK7KCKCKBKBKAK9K=KCKCK:K/K2K3K2K2K3K2K/K.K,K0KBK:K3K5K3K@KtK‡K_KDKBK;K9KK?K?K>K>KDKAKwKÀKºKºK¿K…K:K=K=K=K=K=K;K9KK@K>K@K5K(K)K&K%K#K$K#K(KKK9K&K#K&K%K$K&KK KKKKK K K K–K¶K²KµKµK³e]rÒ(K¡K¡K¡K¡K¡K¡K¡K K¡K¡K¡K K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K K K¥K{KKK-KDK_KÉKÊKKGK9K7K!K4K?K=K:K9K4K*K>KBKBKBK:K+K*K*K#KKKKKKKKKKKKK!K K"KKK K +K K +K K KKKKKKKKKKKK K K!K!K!K"K"K$K#K#K#K#K$K#KK K%K&K9KCKKKŠKˆK‹K£KœK–KŒKUKXKBKSKbKQKSK|KhK„KˆK“K‡KK“K|KLKyK—KyKpK™KŸKK¡K¡KœK£K¢K£K£K£K£K£K£K£K£K£K£K¢K¡K KšKŸK•K‰KœK¢K£KKKŸKŸKvKqKlKgKKKKKKK,KDKLKHKGKIKHKHKHKHKHKHKGKFKFKFKFKFKFKFKGKIKHKGKGKFKEKDKDKFKFKGKFKFKGKGKGKGKGKFKFKFKFKFKFKFKFKFKFKFKFKFKGKCK=K7K:K=K>KAKAK@K?KJKpK™K¨K—KCK6KmK§K£K¥K¦K¤K¢K¨KeK:K@K=K8KdK¦K£K¦K¥K¦K¦K¦K¦K¤K«KvK;KHKšKƒK;KAK8K\KªK¥K¥K¥K¤KYK=KbK¥K¦K¥K¥K¦K¢KTK5K=K=K=K:K9K>KK+KFKCKCKAK@K9K9K@KCK;K1K2K2K2K2K3K2K/K.K-K.K>K=K4K5K5K;KLKyKHK4KEK;K:KK>K=KBKCKUK²K½K¹K»K©KIK;K=KKEK@KK¿K¸K¹KÀK‘K9K8K6K4K5K4K3K1K.K/K4KBKCKAKK¼KµK¶KºK¬KRK;K@K>K;K,K'K&K%K$K$K$K K3KAKBK?K~K»KµK¶K´K¼KsKKKKKKKKKKKKKK KKK=KKMKvK—KMK1K`K¦K¦K¥K¥K¦K¤K©KrK:K@K?K9KSK¡K¥K¥K¦K¦K¦K¦K¥K¤K«KˆKK=K=K;K9K;K&K!KCKCKDK@K>K:K9K@KBK?K1K1K3K2K2K3K1K/K.K.K-K:KCK5K4K4K4K^KKBK7KAK@K:K9KKhK»K¹K¹K»K²KOK3K5K5K5K4K3K2K/K0K1K>KDK=KcK¶K¶K¶KµKºKuK:K@K=K>K3K%K&K&K&K%K$K K(K@K>K>KVK®K·K¶K¶K¸K¦K$KKKKKKKKKKKKK K +K K2KK=K;K9K2K+KBKAKAKBK6K)K+K*K!KKKKKKKKKKKKK#K"K#KKK K K +K +K K KKKKKKKKKKKK K K!K"K"KK K$K#K$K#K$K%K%K&K&K%K&K:KCKJKƒK“KqKnK‹K‰KuKMKmK‚K…K}KŽKsKK¢K‰K‚K†K˜K•K|K8KFK{K“K~KiK†K“K“K£K“K”K¤K¢K¢K£K£K£K£K£K£K£K£K£K¢K¤K›KyK{K”K€K‡KqK}K€KkK•K‡K}KK^KfK#KKKKKKKKK(K?KJKIKGKHKHKHKHKHKGKFKFKFKFKFKFKGKGKGKGKGKFKFKFKGKFKFKGKFKFKFKGKGKGKGKFKFKFKGKFKDKFKGKFKFKFKFKFKGKFKDKDKAKBKDK6K(K/K>KCKDKAK>KRKFK0KSK¡K¥K¥K¥K¦K¤K¨K‚K>K@K?K9KHKšK¨K¥K¦K¦K¦K¦K§K¦K¨K–KGK:KsK¢KLKKBKBK7K0K1K2K2K1K0K0K-K,K+K6KCK8K4K5K5KHKuKCKIKQK?K9K9KK=KKEK@KoK¾K¸K¸KÀK‘K:K>KK>K=K8K)K&K&K&K%K#K#K#K8KCKBK?K‹K»KµK¶K´K¼KbKKKKKKKKKKKKK K KK K>KK1K$K&K(K+KŽK¬K%KK K KKK +K KKŽK¸K´K´e]rÕ(K K K K K K¢K£K£K£K¢K£K£K£K£K£K£K£K£K£K£K¢K K¡K£K£K£K£K£K£K£K£K¡K K¢K£K£K£K£K¢K KdK@K.KIK}KÙKºKzK=K8K0K"K7K=K=K=K:K1K-K@KBKAKBK5K(K,K*KKKKKKKKKKKKKK$K$K$KK K K K K +K K KKKKKKKKKKKK!K K!K#K#K!K"K$K#K#K#K$K&K&K%K&K%K%K;KCKJKdKƒKhKRKˆK„KKaKOKmKžKKeKxKtKKyK‡KKvK•KvKPKvK‘KwKRKlK|K‰K‹K£KK›K£K£K£K£K¢K¢K£K£K¢K¢K¢K£K¢K£K¡KuKvK‚KlKXKrKˆKMKxK–KqKbKK}KƒK'KKKKKKKKKKK-KEKIKHKGKHKIKIKHKFKFKFKFKFKFKFKFKFKFKFKFKFKFKFKGKFKFKFKFKFKFKFKFKFKFKFKFKGKEKCKEKGKFKFKFKFKFKGKGKDKBK?KDKEK@K9K:K;K=K?KAKBK>K=K:KFK•K­K¥K¥K¦K¥K§K‘KDKAK?K;K>K‹K«K¥K¥K¦K¥K¦K¨K§K¦K¢KSK9K`K§K_K9K?K8K‚K­K¤K¤KªKKCKAKK«K¥K¨K§K¨K“KCKK8KK=K=KCKDKRK®K»K¸K»K°KKK8K>K:K:K:K:K:K9K?KDK@K‚K¼K·K¹K¼K¡K=K5K5K4K5K3K1K3K3K.K2K=KDK>KwK»KµK¶K·K¸KdKKK7K&K$K'K9K›KºKiKK KKKKK K KK2KKK‡KÚK´KpK9K7K-K!K;K=K=K;K7K/K.KBKAKAKBK4K)K)K*KKKKKKKKKKKKKK#K#K$KKK K K K +KKKKKKKKKKKKKK!K!K K#K$K#K$K%K%K%K%K%K%K%K&K%K%K%K:KCKIKdKvKcKtK{KuKcKSKZK†K§KxKOKQK>KXKtKKxKjKxKrKwKˆK‰K|KrK‰K_KwKˆKŸK›KŸK¤KŸK¢K¢K¤K¥K¢K£K¥K¥K¥K£K£K£K¡KKK¢K›K‘KšKšK[KvKuKHK[KK‰K{K)KKKKKKK!K&K-K1K5KBKEKHKIKGKGKIKHKFKGKFKFKFKFKFKGKGKFKFKFKFKFKGKGKGKGKFKFKFKFKFKFKFKFKFKFKGKFKFKFKGKGKGKFKFKFKGKGKFKFKEKFKFKEKEKBKAK=KKAK?KYK‰K¦K©K¤K¤K§KKLK?K?K;K6KxK«K¤K¥K¥K§K§K¨K§K¥K©KbK8KOK¤KqK:KAK6KoK¬K¦K§K©KŸKOK=KkK©K¥K¨K§K¨K¢KOK:KKAK3K3K5K6KeKžK•KqKDKK=K=K?KEKCKŽK¿K¸K¹K¾KpK5K>K:K:K:K:K:K9K:KAKAK^K³K¹K¹K¹KºK]K1K6K5K5K4K0K0K0K/K.K9KBK@KSK¯K¸KµKµK½KŽK;K=KK8K7KAKBK@K3K/K0K/K0K/K.K/K,K*K)K8KDK7K5K5K4KOKKšK‡KPK?K:K9KK>K=K=K>KEKBKkK»K¹K¹K¿K—K=K>K:K:K:K9K:K9K9K@KBKDK›K¾K¸K¸KÀK‡K3K5K5K5K4K0K0K0K0K.K3K@KCKBKKºKµK¶K¸K­KQK9K=K=K;K*K&K&K$K$K"K!K!K2K@K?K;KiK¶K´K´K³KºKŒK KKKKKKKKKKKKKKKK6K>KK=KFKiK—K©K­KeK9K@KK‡K—K?KKBKAK4K.K0K/K0K/K/K/K,K)K(K1KCK;K4K4K5KBK‰K•K”KgK?KK\K´K»K»K¼K´K¡KTKKEKAKtK»K¶K¹K»K©KFK2K5K5K3K1K3K1K/K0K1K;KBK=KeKµK¶K¶K³KºKyK9K=K=K=K1K%K&K$K$K$K#K"K)K?K@K@KIK K¸K´K´K´K³K:KþK +KKKKKKKKKKKK +KK$K=KK=K;K9K8K,K3KBKAKBK?K/K(K)K*KKKKKKKKKKKKK!K#K$K"KKK K +K K KKKKKKKKKKKKK K K"K$K#K$K#K$K%K%K&K%K&K&K$K&K&K%K&K9KAKOKiKiK\KpK„K—KŽK^KkK°KšK{KrKTKmKZK`KJKhK‘KfK|KKfK{KzK’KdKAK…K–K…K¡K¤K¢KžK¥K¦K¥K¦K¦K¦K¦K¦K¦K¦K¦K¦K¥K¥K¤K¤K”KoKK—KšKKLKbK–KjKkKQKQKRK[KXKVKZK]K[KYKUKMKLKJKFKEK?KAK@KAKGKGKGKFKFKGKFKFKFKFKFKGKGKGKFKCKDKCKEKGKFKGKGKFKFKFKGKFKFKGKFKFKEKDKEKEKEKEKEKFKEKEKGKFKEKCKDKCKFKFKCKDKEKFKHKEKK?K„K¬K§K§K¦K¬KK=K:K=K;K9K9K:K5KK9KBKAK@K=K:K5K=KDKBK8K,K/K0K/K0K/K/K,K)K(K-K@K=K4K4K4K7K~K‡K\KbKBK=K8K9KK;K;KKGKAKŠKÀK¸K¸KÁKyK7KKyK¸K´K´K²K¼K}KKK KKKKKKKKKKK +K KK9KK;K(KvK´K¯K¯K·K^KK KKKKK +K KKK=K:K9K6K+K6KCKAK@K>K-K'K+K(KKKKKKKKKKKKK!K#K$K#KKK K +K +K +KKKKKKKKKKKKK!K K"K$K#K#K$K#K#K%K&K%K%K%K&K%K%K%K%K:KBKKK‚K|KFKwK’K’KKœK}KœK‘KgKJKUKpKmKvK…KnKŠKwKhKoK„K†KeK†K{KdKpKzK’K¦K¦K£KžK¦K¦K¥K¦K¦K¦K¦K¦K¦K¦K¥K¦K¥K¥K¤K¥K“K‹K¡K›KK K›K KK›K€KPKSKWK]K\K\K]K`K^K\K[KVKUKMKKKJKFKHKGKDKK;K9K:K9K9KK0KDKAK?K>K;K6K:KBKBK>K/K/K0K/K0K/K0K+K)K(K)K9K?K4K5K6K5KhK‰KSKgKLK=K9K:K8KGK'K&KK,KBK?KqKÁKºK½K¹K«K¨KŸKwK’KnKAKfK¼K»KºK½KKK KK2KMK;KEKGK?K|K¿K¸K¹K¹K´K˜KBK;K:K:K9KK?K>KRK¨K¶K´K²K²K¬K*KKKKKKKKKKKKKK K K,K>K=K=KK?KAK>K=K=K8K7K5K5K‚K¬K§K§K¨K¨K¨K¨K§K¨K­KaK6KRK¦KwK7K?K5KgK®K¦K§KªK¤KSK8K`K§K§K¨K©K¨KªK[K5KKKK…K¸K³K´K±KºKiKKKKKKKKKKKKKKKKK:KK=KKAKOK“K„KhKfKKŽKªKžK’KˆKkK‘K_KaK[K_KmKRK|KK„KVKMKeKK?K?KAK@K=K:K4KpK«K¦K§K¨K¨K¨K¨K§K§K®KtK6KCK—K‹K;K>K7KSK¨K©K§K§K¬KhK8KNKŸK©K©K«K§K­KsK4K:K9K:K8K7K:K)KKAKBK?K>K>K:K7K?KBK@K3K.K0K0K.K-K-K.K*K'K(K0K?K7K5K5K4K;KhK†KOK:KDK;K9K:K>K+KKK K;KCKEKKÀKºK½K³KŸK¤K§K¥KžKhK>KŒKÁK·K½K£K"K&K,K'K KK.KDKJK K¾KºK¼K¹K°KmK7K:K:K:K2K5KDK?K‚K¿K¸K¸KÀK€K5K;K9K7K8K8K8K7K6K@KCKJK¢K½K¸KµK¾K|K0K6K3K2K0K1K/K-K.K,K5K?KCKCKŒKºK³KµKµK®KTK;K;K:K9K*K"K$K$K$K!K"K!K,K?K?K>K\K±KµKµK´K¶K¢KKKKKKKKKKKKKKKK +K*KK2K2K/K'K$KKKKK#K6KFKEKCKDKDKCKFKGKFKFKFKFKFKGKFKDKDKCKDKDKFKFKDKEKFKFKFKGKFKCKCKCKDKDKDKDKDKDKDKEKCKCKDKCKCKCKCKCKDKCKAKAK@KBKKKMK>K7K9K>K?K?K=K?K=K[K§K¬K§K§K§K§K¨KªK§K­KˆKK:K6K;K@KCK7K-K.K0K/K/K.K-K+K)K(K+KK7K9K;K-KKKK1K>K?KKÃKºK¼K¶K¤K¦K§KK‚KxKAKmK¼K¹K»K¼KGKK@K(KKKKAKCK€KÀK¹K»K»K°KfK:K=K;K:K8K8KCK?K_K¹K¹K·K¾K¥KDK8K9K8K8K8K8K6K5K;KDK?KK¾K·K¶K»K¢K;K1K3K2K/K0K0K.K.K.K.KKgK´K´KµKµKºKyK9KK_KvKšKcK‘K¬K‡KtKWK9K'K/K5K+K KKKK+K=KCKDKDKCKFKFKFKGKGKGKGKGKFKDKDKCKDKDKFKFKCKEKFKFKFKFKFKCKCKCKCKCKCKDKDKDKDKEKCKCKDKCKCKCKCKCKCKCKBKAKBKAK?KIKLKCK9K;K=K:K6KK|K®K§KªKªK¬KšKEK8K:K:K:K9K7K9K;K8KBKBKAK>K:K6K9K?KAK:K-K.K0K/K0K.K-K,K)K(K'K7KBK7K4K5K5KKKuKtK„KRK=KKaKºK¼K»K¼K®K¨K©K–K—KƒKIKRK­K¼K¹KÃKwKK;K=K0K+K*KAKDK`K¸K¼K»K»KµKKJK;K;K9K8K8K>KCKFK¡K¿K¹K¹K¸KaK4K9K8K8K8K7K7K2K7KEKAK\K´K¹K¶K·KºKaK,K4K2K0K0K0K.K.K/K*K5KCKBKGKžK¸K´K¶K·K¡KDK9K:K:K5K&K$K#K K!K K KK-KBKCK=KiK¶K´KµKµK·KšK!K KKKKKKKKKKKKKK K/K?KK=KKDKdK”K¬K¬K¨K§K©K«K¤KPK3KZK«KcK4KK@K>K/K.K0K/K0K/K,K+K(K%K&K0K>K8K4K5K5K?KfKZKhKTK?K=K:K:K8K KK KK8KCKMK¥K¿KºK¿K³K¦K­K˜K€KŸKaKBK•K¿K·K¿KK,K4K9K?K>K-K/KDKJK¡K¿K»K¾K¯KxKZK7K:K:K:K9K=KFK@K}KÀK¹K¸K¿KˆK4K7K8K8K8K5K5K4K6K?KEKEK˜K½KµK¶K½KŒK1K4K0K0K0K0K/K,K.K-K-K?KCK=KvK¸K²K´K´K¹KfK2K;K9K8K.K$K!K!K!K!K!KK#K=KAK@KGKžK¸K´K´K´KµK`K#KKKKKKKKKKKKKKKK=K=K=K:KiK°K®K¯K¯K¯K³KVKK KKKKKe]rà(K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¥K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¥K§KœKYK:K2KKK„K×K´KrK;K8K/K!K8K?K=K;K8K0K/K@K?KBKAK7K)K(K)K#KKKKKKKKKKKKK$K$K&K"KK K K +K K KKKKKKKKKKKK K!K#K#K$K$K%K%K%K&K&K%K&K&K&K%K&K(K(K*K:K?KDKBK9K;KŽK–KXKyK°K¥KœK¤K¢K§KzK`KoKrKRKYKVKIK‚K˜K©K§K£K£K™K™K¢K–K¨K§K¨K¨K¨K¨K§KªKˆK|K«K¨K“K•K©K§K¥K‰KqKŸK¢K©K©K¨K¨K¨K¨K¨K¨K¨K§K§K§K§K§K¦K§K KK¤K¨KžK¦K†KzKˆKxKtK¦K¦K¨K«K K€KUK;K+K1K7K)KKK K7KDKDKDKCKEKFKEKFKFKEKFKEKCKEKFKFKEKCKDKCKEKFKDKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKDKCKCKCKCKBKCKBKBKBKAK@KAKBK?KAK=K2K+K0K9K>K=K@KAK=KGKlK™K­K©K§K¨K­K`K2KIK¥KyK4K>K3K`K¯K©KªKªKªK[K5KVK¥K¬K¨K¡KŸK©KgK6K>K;K9K9K9K8K8K8K@KBKAK@KK>KAK4K-K0K/K/K/K,K,K*K&K%K-K=K9K4K5K5K:KOKOKWKTK?K=K9K:K8K!KKK$K6K?KBK‡KÁK»K½K¶K«K«K«KŽKKxK?KuK½K¹KºKºKCKK KGK>K6K.KAK@K€K¿KºK¼K·KŽK„K=K8K:K9K9K;KAKAK^K³KºK¸K¼KªKBK4K8K7K6K5K5K5K4K;KEKAKrK¼K¶K·K¹K¬KGK/K1K0K/K/K/K,K-K,K)K9KDK?KTKªKµK´KµKºK“K;K9K:K:K3K#K!K!K!K K KKK3K?K@KK=K:K6K/K6K?KAKAKAK5K*K+K)K"KKKKKKKKKKKKK$K$K&K"KKK K +K +K KKKKKKKKKKKK!KK K#K$K%K&K&K&K&K&K%K)K)K&K$K)K)K(K*K;K@KFKHKgKHK…KŒK¢KpK•K€KlK“K¤K¢KˆKˆK…KƒK>K=KLKpKKŒK°K¥K¨K¤KœKœK K™K¥K¦K¨K§K¨K¦K¥K©K¢K}K›K«K¢K‰K”KŒK…KœK’K”K˜K£K¦K¨K§K¨K¨K¨K¨K¨K¨K¨K§K§K§K¨K¨K¨K©KªK‡KK–K…KTKbKRK“K©K¦K¤K¢K¨K­KªK’KkKGK3K+K.K/K#KK(K@KGKCKDKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKDKCKDKDKDKCKCKCKDKCKAKBKBKBKEKDKCKAKAK@KAKAKBKAKCKAK9K0K1K9K=K@K>K@K>K;KFKqKœK¬K¨K®KuK2K>K“KK;K>K8KKK©K«KªK©K®KpK6KFK™K®K§K¡K¢K¥KsK9K=K9K9K:K7K8K:K9KAKBKAK@K=K:K4K:K@K?K:K-K/K0K-K-K.K.K-K&K%K*K9K=K5K4K4K6KDKBKQKjKDK=K8K9K;K&KKKK)KK`K¶KºK¹K¼K¥K¢KWK5K;K8K8K8K=KDKFK˜K¾K¹KºK»KgK3K9K5K4K5K5K5K4K8KBKCKQK«K¹K¶KµK»KnK,K1K0K/K-K/K,K*K+K)K1K?KBK>KŽKºK³K´KµK±KUK6K:K8K7K(K!K!K!K KKKK&K>KAK@KPK¨K³K³K´K³K±KQK&K+K)K'K#KKK KKKK KKKKK;K9K>K:KoK´K®K¯K¯K­K¯KRKKKK%K'Ke]râ(K¦K¦K¥K¦K§K§K§K§K§K¨K§K§K§K§K§K§K§K§K§K§K§K§K§K§K§K¨K§K¦K§K§K§K¦K¥K¦K¦K§K¦K©KKSK3K6KNKKÙK©KbK7K6K4K5K9KKMKwKŸK³K‡K3K4K€K£KBK8K:K;K™K®KªK©K°K†K9K:K†K¯K«K¤KK”K€K=K:K:K:K9K8K9K9K:K;KAKAK?K>KK@KKvK½K¹K¸K¿KŽK4K6K5K5K5K5K5K3K3K?KEK?K‹K¼K¶KµK»K™K9K1K0K.K.K-K+K+K+K+K+K;KBK>KeK¶K´K´K³K¹K~K5K:K8K8K.K!K K K K KKKK7KAKAK>K…K·K±K³K±K¸K…K;KDKLKPKWKiKjKhKGKK K$K(KKKK0KKKBK?K=KQKK’K>K2KlK¬KTK6KK:K9K;K9K9K:K8K;K7KAKAK?K>K:K7K5KK0K-K-K-K.K-K+K*K%K%K$K.K?K7K2K5K4K>K‚KmKVKRK>K:K9K:K8KKKKK1KBKAK’KÁKºK¼K¹K¬K¯K¥K£K®K{KKK¿KºK»K¹K¨K’K=K5K9K8K8K8KBKCKXK°KºK¸K¼K¯KJK3K5K5K5K5K5K2K2K9KCK?KcK¶K¶K¶K¶KµKUK+K1K/K.K+K*K+K+K+K)K4KAKAKFKŸK¹K´K´K¶K¤KEK7K9K7K1K$KKKKKK KK-K?K?K>K[K°K³K±K±K²K­K{KqKpKcKPKWKUKQKHKFKNKFK+K1K)KK&K>K=K>K:KvK´K®K°K°K¯K®KPKK!K1K&Ke]rä(K§K§K§K§K¨K¨K¨K§K¨K¨K¨K§K§K§K§K§K§K§K§K¨K¨K§K§K§K¨K¨K§K§K§K§K¨K§K§K§K§K¨K¦K«KKKK/KAKQK³KÓKŸKWK6K7K5K4K9KK:K5K4K;K?K?K?K>K/K'K(K(KKKKKKKKKKKKKK&K%K&K!KKK K +K KKKKKKKKKKKK K K!K#K$K%K%K&K%K&K%K&K(K)K)K)K(K)K)K(K*K;K>KNKcKoKK“K¢KŸK=K'K0K9KMKXK}KžKKyKoK/KdK‚K}KK¡K«K©K¦K§K§K¨K©K¨K¦K§K¨K§K¨K¥KK®K|KjKŸKmK3KK…K‡KˆKKVKeKzKpK‹K¨K©K§K©KªKªKªK¨K§K§K©KªK¨K§K©KaKQK|K€K+KYK¤KŸKmK€K©K£K¥K›K”KKœK¨K©K«K¥K£K¨K­K¢K}KVK7K'K$K*K8KCKDKDKCKDKDKDKDKCKEKGKDKCKCKDKCKCKDKCKCKCKCKDKEKBKDKCKAKCKDKBKBKBKBKAKAKAKAKBKDKCKBKBKBKAKAKAKAKBK@K?KAKAKCKAKK?K>K=KK;K7K5KK>KuKÁKºK¼KºK®K°K¬K¥K°K‘K@K\K¶KºK¹K¿KwKYK‰K…KSKhK‹KfK?K`K¶K»K¹K»K¯K¥KZK1K9K8K5K4KKBKIK KºK¶K´K½KK,K1K0K.K,K*K+K)K*K'K,KK/K'K(K'KKKKKKKKKKKKK K&K%K&K!KK K K +K KKKKKKKKKKKKK K"K$K%K&K%K%K%K&K&K&K)K)K(K)K(K(K)K(K*K;K?KKKgKtKaKƒK¬K˜KSKVKjKSKIKSK˜KŠK}K KrK7KVKTKcK“K¨KaKsK«K©K¨K§K§K§K¨K¨K§K§K¨K¨K£K®K•KnK®KŽK,K\K”KšK£K€KYKyKƒK|KvKŒK£K¨K©K«K«KªK¨K¨K¨K©K«K¨K¨K¦K—KXKSKrKZKoK‰K{KuK£K£KžKK›KŠK’KpKK¥KKšK¢KœK¨K­K¯KªK”KiK@K)K*K7K>KDKDKDKCKDKDKCKDKGKDKCKCKEKCKCKDKCKCKCKCKDKDKCKCKCKAKCKCKAKAKAKAKAKAKAKAKBKCKCKAKAKAKBKBKBKAKAK@K?KAKBKAKAK@KBKKKBK?K?K>K;K6K;K@KBK7K,K-K-K-K-K+K+K+K&K&K%K7K>K1K3K2K6K7KKZK†KGKKoK»K¶K·K½K•K6K5K5K2K3K3K/K0K/K9KEK?K}K½KµK¶KºK§K=K+K-K,K+K-K-K)K(K(K(K8KBK?KRK«KµK´K³K»K‘KKKKKKK9KsKoKiKUKnKZK?K?K@KKKKCKDKCKCKDKDKDKCKCKCKDKCKCKCKCKCKCKCKCKDKCKCKCKDKBKAK@K@KAKAKAKAKAKAKAKBKBKAKBKBKBKBK@K?K?K@KBK@K>K?K?K>K@KCK@K=K8K6K8K9K8KKK9KKKaK¥K³KŒK9K9K:K9K:K9K7K8K7K;KBK>K?K?K=K6K7K@KBK:K+K,K.K.K-K+K+K,K'K%K%K2K?K5K4K4K3K=KKK`KZKK>K?K>K?KAK?K>K?K;K4K2K5K6KK?K=K@K9K1K4K7K“K¯K«KªKUK+K:K:K5KKKK¯K®K¡KKGK7K;K9K9K8K7K9K8K7K?K?K@K?KK?K=K.K-K-K-K-K+K+K+K(K%K%K,KKcK´K´KµK²K»KvKKKKKCKyK|KmKoKmKrKsKVK@K>KAK>KsK¶K±K±K±K´K¤KvKwKKKKyKqKhKdKdKDK.K!K.K8K'K2KK,KIKnKÓK¾K„KBK4K5K1K7K=KK?KK>K>K?K>K>K?K>K>K?K>K?K=K7K5K2K5K9KK?K>KK>K?K4K*K*K-K-K+K*K+K(K%K$K&KK?K^K¹K¼K»K»K|K7K'K K9KKKBKHK£K½K·K¿K”KGKdKlKYKYKfKeKCKGK¡K½K¸K»K±KqKDK3K6K4K5K5K9KFK?KiK¼K¸KµK»KžK/KKKKKK K KK%KEKKAK?KNK¦K´K±K±K²K²K†KyKKzKzK|KzKqKgKiK]K>K-K&K4K*K(K=K=K=K:KUK¦K­K¬K°K­K²K€K'K,K7e]ré(K§K¨K©K¨K§K©K©K©K©K©K©K©K©K©K©K©K§K©K©K¨K§K§K¨K©K©K©K©K©K©K©K§K¨K§K©K©K©K«K K\K;K.KHKvKÖK¹K}K>K5K6K/K5KK?K:K)K(K)K(KKKKKKKKKKKKK#K&K&K&KKKK K +K KKKKKKKKKKK K!K"K#K%K%K%K&K$K#K'K)K'K)K)K(K)K(K&K)K*K.KK?KAK>K=K>K?K>K?K?K>K?K?K>K>K>K?K@K>K9K4K3K7K:KK=KK;K9K8K6K9K3K;KAK@K?KKJK¥K¾KºKÀK‰KFK>K*K7KTKLK>K…KÀK¸K½K¯KLKGKQKOKVKvKpKHK>K‚K¿K¸KºK¼KlK9K1K,K)K'K#K K6KBKOK¨K¼KµK¶K¹K;KK K KKKKKKK?KAKQK«K¹K¶K¶K¸K—KqKRKKKKKKKKKK=KEK>KvK¸K³K´K²KºK_KKKKJKjKqKyK}KqKfKsKoKHK9KBKBK>K‚K¶K±K²K±KµKžKvK€KwKnKnKfKVKWKQKTKOK>K=KK=K>KK?K9K*K(K)K)KKKKKKKKKKKKK#K&K&K&KKK K K +K KKKKKKKKKKK!K K K"K&K&K%K(K"K K'K)K)K(K(K(K(K)K,K+K*K.KK[K©K¦K¤KªK—K‚K K¬K˜KPKRKOK'KdK7KKcKSK„KŸK›K§K“KrKtKhK‹K–KK¢K«KªK¬K‚K…K•K}K„KKZK`KbKrKaKjKŒK~KcKˆKkKcKxKoK›KK¡K­KªK«K«K«KªK«KªKªKªK¬K¬KªK©K²KeK9KvK–K“K¡K¡KhK„K§K1KqK±K©KªKªK©KœKK­K¬K¬KªK¬K­K­K­K­K¬KªKªK­K›K#KKKKKK%K?KFKDKCKDKCKCKCKCKCKCKDKCKDKCKAKBKDKBKAKCKCKBKBKBKBKBKBKBKBKBKBKBKBKAKBKBKBKBK@K?K?K>K>K>K?K=K?K?K>K?K>K>K>K?K?KKK?K=K9K5K8K?K?K5K(K+K*K*K+K*K(K)K$K&K$K.K@K5K1K3K1KKJKNK?KgK¹K¹K¹K¿KvKKK8K3KNKMK>KCK@K^K·KºK¶KÂKƒKKKKKK K K#KFKAK†K¼KµK¶KÂKrKKKK K K K K K K1KCK>KˆK½KµK¶K¹K§KlKAKK KKKKKK K K-KAK?KSK«KµK´K³KºK“KKK,KUKnKlKgKpK{KkKmKvKUK4KBKCK?KZK­K±K²K±K²K°KzKlKeKUKTKSKCK:K8KCK5K9KBK;K&KKK:K;K=K:K\K©K¬K¯K°K¯K´K‚KK?K7K'K(K)K&KKKKKKKKKKKKK%K&K%K&KKKK K +K KKKKKKKKKKK!K!K#K$K&K%K%K&K%K(K)K(K)K*K*K*K(K)K*K+K*K-K=K>K[K«KªK«KªK«K®K©K¨K­K‰K]KFKK+KK+KK_K…KvK–K«K’KŒKœK•KŠKhK~K¤K«K«K¬K¤K¦KŸKxKƒKgKUKYKXKnKCK`K“KyK^KoKfKbKKKvK­K›K¦KªK«K¬K¦KªK¬K«K¬KªKªK«K«KªK¬KŸKZKTK}KKK¨K KZKKwKAK«K¬K¬K¬K¬K­K¥KœK¬K­K­K¬K¬K­K¬K¬K­K¬K¬K¬K­K¦K2KKKKKKKK/KDKDKCKCKDKCKCKCKCKCKCKDKCKCKCKBKCKCKBKBKCKCKBKBKBKBKBKBKBKBK@K?KBKBKBKBKAKBKBKAKAKAK@K>K>K?K>K>K>K>K?K>K=K>K?K@K=K7K3K1K6K6K/K8K>K:K=K>K KkK‰K1K5K„K²K«K¨KKªK–KDK>K?KK@K:K&K)K+K+K)K)K*K(K"K%K%K)K>K6K1K3K2K:K6KKQKrK?K;K9K9KKcK·K¶K·K¶K¶KvK(KKKKKK K K K KKAKBK?KKºK´K´KµKµKCKK4KYK]KTKQKVK[KbKDKQKCK$K8KAK?K?KŽK¶K°K²K±K´K”KbK\K]KKKIKSKKKIK>K.KK@K6K&K(K)K%KKKKKKKKKKKKK&K&K%K&KKKK K +K KKKKKKKKKKK!K!K#K$K%K%K&K&K&K)K(K(K*K+K+K*K(K)K+K+K*K-K=K>K\K¬K«K«KªKªK«K©K£K«KYK]KK"KKK,KwKdK„KgKK©K˜K„KžK¨K°K–K|K‰K«K§K©KšKtKoKsK9K6KUKCK(KEKDKCKtKtKƒKTKYK‰KEKgK˜KK­K­K«K¨K£KªK­K­K£K§K®KªKªK¬K§KžKjK>K|K¦K©K«K¤K\K”KOKvK³KªK­K­K­K¬K«K™K¤K«K«K­K¬K¬K¬K¬K­K­K­K¬K¬K®K@KKKKKKKKKK8KDKEKCKDKCKCKCKCKCKCKCKDKCKAKCKDKBKBKDKCKBKBKBKBKBKBKBKBK@K>KAKAKAKAKAKAKAKBKBKBKAK?K?K>K?K?K>K>K?K>K=K>K?K>K>KK=K:K6K4K>K?K=K*K(K+K*K(K(K'K&K"K$K&K$K9KKdKµK´K´K²K¹KxK K%K@KFKBKGKNKKKfKUKK>K@K4K%K(K)K%KKKKKKKKKKKKK%K%K%K'KKKK K K KKKKKKKKKKK K K"K%K#K%K&K(K(K(K)K(K*K+K+K*K(K)K+K+K*K.KKAKBKAKBKAKAKAKAKAKBKBKBK@K>K>K>K>K>K>K>K>K>K>K?K>K>K>K=K=K4K.K3K8K9KK?KKDK—K´K±K±K¯K¶KrKKKKKKK3K8K*K KKK"K1KK%K8K:KK>K@K3K&K)K(K$KKKKKKKKKKKKK&K&K&K&KKKK K K KKKKKKKKKKK K!K#K$K#K%K&K(K)K(K)K(K*K+K*K*K(K)K+K+K+K.K=K=K_K­K«K¯KœKXKK>K>K>K>K?K>K>K>K?K?K>K=K>K>K=K9K6K5K8K:KK?KK4K'K(K#K'K%K K*KBK7K1K2K2KKKKK)KBK;K=KKrKÀK¹K¾K­K KK KKKK>KOK­KºK·KÁK}K K K K +K KKKCKIK¢K¼K·K¹KªK'K +K K K KK KK>KAK]K·K¸KµK¹K¨K KK K KKKK KKKDK>K_KµK¶KµK³K¼K[KK +KKKKKKK KKK:K@K=KxK·K²K²K±K¸KkKAKOK'K!KEKOK3K K-K1K$KKK0K@K?KK8KdK¯K¯K®K¯K®K¯KŽe]rï(K«KªKªKªKªKªKªKªKªKªKªKªKªKªKªKªKªKªKªK«K«KªKªK«KªKªKªKªK«KªKªKªK«KªKªKªK­KvKIK+KBKUKºKÎKœKTK4K6K#K'K9K9K9K7K4K*K.K@K>K>K@K2K'K*K&K"KKKKKKKKKKKKK(K)K(K&KKK K K K KKKKKKKKKKK!K!K$K#K#K%K%K(K)K(K)K(K*K+K)K(K(K)K*K-K.K1K?K=K_K­K«K®K KWKKKYK«K«KŽK^K’K¬K†K(K_KaK{KiKnK•K~K”K‰K~KK¯K©KªKŽKjK’K§K KwK‘K¨K„KKK4K?KcK§K’K€K§K–K‰KŒKVK_KŽK|KqK_K}KuKzKˆK‡KšK`KiKtK]K|KlKNKbK†KŒKbKbKqKUKK‹KuKxK|KK—K­K¬K­K­K®K«K«K¦K¥K©K®K¬K¨K¨K«K­K¬K¬K¬K«K¶KnK KKK(K,KK%K+K2K9K>KBK?K:K>KBKDKCKDKCKCKCKCKCKDKDKBKAKAKAKAKAKAKAKAKAKAKBK@K?K>K>K@KBKAKAKAKBKBKBKAK>K@KBK?K?K?K>K>K>K>K>K>K>K>K>K?K?K>K>K?K?KK>K;K9K5K2K=K?K;K%K&K(K;K>K.K$K#K'K*KKK;K9K0K1K1KKKKKK?K?K=KK=K>K?K;K=K=K=KCK–K±K«K¬K¬K®K§e]rð(KªK«K¬K¬K¬K¬K¬K¬K¬K¬K¬K¬K¬K¬K¬K¬K¬K¬K¬K«K«K¬K«KªK«K¬K¬K¬K«K«K¬K«KªK«K«KªK¬KlKEK)KDK[KÅKÈK—KNK4K6K!K)K:K;K:K7K5K+K/K@K>K?K@K3K&K)K(K"KKKKKKKKKKKKK'K(K(K&KKK K K K KKKKKKKKKKK K!K#K$K$K&K'K(K)K(K)K(K)K)K*K)K(K)K+K+K+K/K=KKFKLKLKJKHKGKHKCK:K7K@KEKCKCKCKCKCKCKCKCKBKAKBKAKAKAKAKBKAK@K@KBK?K=K@K@KAKAKAKAKBK@K@KBKAK@K@K@K?K>K?K>K>K>K>K>K>K>K>K>K>K>K>K>K>K?K?K?KK?K=K9K4K2K=K?K>K)K"K'K7KK0K0K2K#KKKKK7K@KK2KKKKKK2KHKKÀK·KÂKwKK +KKKK&K@KnK¾K¸K¸K¼KFKK K KKKK1KAK`KµK·K´K¾K„K K KKK K KKKFK@K|K»KµKµK¾K†KKKKKKKKKK'KFK=KsKºK´K´KµK´K6KKKKKKKKK KKKAK?K;K‰KºK²K³K±K³KRKK*K,K0K2K4K5K5K4K5K6K7K6KK:KiK®K¬K­K¬K¬K°e]rñ(KªK«K­K­K­K­K­K­K­K­K­K­K­K­K­K­K­K­K­K«K«K­K¬KªK¬K­K­K¬KªK«K­K«KªK¬K¬K«K©KgKAK)KFKdKÏKÅKŽKIK3K5KK+K;K=K;K6K5K*K1K@K>K?K@K1K'K)K)K"KKKKKKKKKKKKK'K(K(K'KKK K K K KKKKKKKKKKK K!K#K$K&K(K)K(K(K)K(K(K(K(K*K*K(K)K+K*K*K-KK_KVKŠKŽKXKMKtK}K¬K®K¶KcKuK·K©K˜KKoKeK“KŒKKjK(K[K[KtK|KzKlKƒKkKwKuK„KlKwKsK\K)KKKYKYKzKcK[KHK‹KKNKxK¢KK„KoKhK}KQK\K]KOKvK”KxKK‡K­K±K¬K­K­K¯K°K°K°K¯K°K°K­K®K°K°K¯K³KKXKPKLKJKOKPKPKMKOKNKOKNKJKIKKKHKBKKBKEKCKCKCKDKDKDKBKAKAKAKAKAKAKAKAKBKBKBK@K>KAKBKBKBKBKBKBK?K>KBKBKBK@K>K>K>K>K>K>K>K>K>K>K>K?K?K?K>K>K>K>K>K>K>K?K=K:K6K1K4K7K7K7K;K;K:KQK…K°K[K5K;K9K8K5K4K7K'KK?K>K?K?K:K6K4K;K?K>K3K%K$K/K?K@K7KKKK(KK$K?K3K0K0K*KKKKK-K@K;K=K?KKKÁK¹K¾K KKKKKKK?KTK¯K¼K¶K¿KvKK K +KKKKKDKIK¡KºKµK¹KªK#KKKKKKK +K;KBKYK²K·KµK¸KªK'KKKKKKKKKK@K?KRK«K¶K´K²K½KoKK +K +K K KKKKKK%K:K@KK?K@K.K&K)K)K!KKKKKKKKKKKKK'K&K&K%KK K K K KKKKKKKKKKK!K!K!K#K$K%K'K)K)K(K'K*K*K*K*K*K*K*K*K+K+K*K0K?K>KcK®K¬K¬K¬K®KŸK…KŽK\KKUKLKxK{K³KKK KoK¬K«K˜K‰K‚KŒK‘KK­K±K‘KWK¢K¬K¢KšKžKŸKœK£KKgKFKVKvK‡K]KIK\KqK[KjK_KLKyKmKPK=KjKVK>KCK†KZK.KK‘K£K«K K­KªKƒK(KEKPK:KUK#KXK}KsK}KŽK–K™KšK«K¨K§K±K¯K¯K¯K°K°K°K°K°K°K°K¯K³KˆKJKMKPKTKUKWKTKQKQKOKQKQKKKIKKKHKEKHKFK@K9K;KCKEKCKBKBKBKBKAKBKBKAKAKAKBKBKAKAKBKAKAK?K?K?K?K?KAKBKAKAK?K@KBKAKAK?K?KAK@K>K?K>K>K>K?K>K=K>K?K>K>K?K?K?K>K?KK;K7K4K7K?K>K8K)K"K(K=K@K>K1KKK K&K-K;K6K0K2K0KKKKKK@K:K>KEKSK1KKKKKK;KbK¸KºKºK¹K6KK KKK +K9KCK–K¿K¶K½K¡KKK K +K KKK?K?K€K½K´KµK½KOKK +KKKKKK)KEKCK˜K¼KµKµK¼KUKÿKKKKKKKK K3KEKAKŒKºK³K³K·K¤K-KK!K!K#K&K&K'K(K)K+K3K?K@KGKšKµK±K²K³K«KMK6K:K9K;K=KK?K?K?K?K?K>K‰K³K¯K²K±K´KŸK}KtK_K'K-K'KKKKKKKKKKK+K;K9KK?K@K.K%K)K)K!KKKKKKKKKKKK K'K%K&K$KK K K +K KKKKKKKKKKK"K!K!K#K$K%K'K)K(K)K(K(K+K*K+K*K*K*K*K)K+K*K0K@K>KcK¯K­K­K­K¬K°K‘KTKcKsK`K.KUKK³K—K2KK‹K³K¬K­K¯KªK“KzKqKžK­K¦K‚K§K­K®K’KK¯K›KzKDK>KIKrK K„KKKGKmKgKnKVKNKRKVKQK:KK^K9K(KgK?KIK§KnK“K°K®K¬K¨K–KLK0K5K?KYK+KDKIKjK–K¢K—K“K†K K©KªK°K°K°K°K°K°K°K°K°K°K°K¯K´K”KTKTKTKSKUKXKTKSKTKOKQKPKMKLKOKLKJKJKDKEK=K0K3K>KCKBKAKBKBKAKAKAKAKAKAKAKAKAKAKAKBKBK?K>K?K?K>K@KAKBKAK>K?KBKAKBK?K?KAKAK>K?K>K>K>K?K>KK?K>K>K>K>K>K>K>K=K=K>K=K5K*K(K0K2K2K4K6K-K,KgK9K9K9K7K6K4K7K7KK0KDK?K>K=K:K4K6K?K@K;K1K.K/K9K?K>K?K/KKKK*K=K9K1K2K4KKKKKK;KCKYKhK|KkK KKKK K5KLK§K¾K¸KÂKfKK +KKKK+KAKuK¾K¹K¹K¸K=KK K K KK K2KAK_K¶K¶KµK¾K…K K +K KKKKKKBK>KuK»KµKµK¾KKKKKKKKKKK*KCK>KdK¶K´K´K´K·K^K"K*K)K)K*K)K)K,K,K.K3K>K@K>KtK¶K±K²K°K·KyK4K9K9K:KK?K=K-K&K(K)K!KKKKKKKKKKKK K'K%K'K%KK K K K K KKKKKKKKKK"K!K!K#K#K&K(K)K&K'K)K'K)K*K+K+K*K)K(K"K*K*K0K?K;KeK²K®K°K­K¬K«K‘KxK]K1KiKQKcKhKŒKšK0K(K¡K¯K¬K©KK†K˜KTKeKwK¤K K®K¯K§K±K›K_K}K£KsK.K$KCKmK†K¥K…KWK5K-KSKŠKjKgK?K6K5K^K—KKaK;KyKOKrK¯KšK˜K¬K©K§KªK€K_K>K-K6KLKMK=KLKgKšK‚K€KKKK®K±K¯K°K°K°K°K°K°K°K°K°K°K¯K²KKWKUKVKUKUKXKWKVKVKQKPKSKPKRKPKKKIKEKAKK@KBKBKBK?K?KAKAKAKAKAKAKAKAKAKBK@K>KAKBKAKAKAKBKBK?K>K?K?K>K>K>K?K?K?K?K>K?K>K?K>K=K=K=K=K=K>K?K=K>K>K9K/K&K)K/K1K0K2KK,KK>K>K;K5K4K;K=K;K4K5K/K.K9K?K>K?K)KKKK6K?K1K/K3K%KKKKK0KHKzKK–K¡K*KKKKK+KCKŒKÁK·KÁK–K KKKKKKAKWK³K»K·KÁKoKK +KKK KKKCKHK¡KºKµK¹K«K$KK K +K K +K KK9KAKTK¯K¸K¶K¸K±KKIKŸK¸K´K´K¹KŽK-K+K.K-K.K,K,K/K0K3K1K8K?KKBK’K´K¯K°K±K¯KµK¦K@K(K3K2K0K4K4K2K0K+KK K#KKK/K=KK?K=K,K'K(K(K KKKKKKKKKKKK K'K&K'K$KK K K K K KKKKKKKKKK!K!K!K$K$K%K(K)K'K$K&K*K(K*K+K*K)K)K)K(K+K+K0K?K;KeK²K®K°K®K­K¯K¢KmK;K%K;KlKzKhK„KœK,K2K¢K¯K¯K¨KJKlK{KeKdKiK•K«K¯K®K©K¯K€K:KCKŒKoKKNKhKuKžK®KgKMKKKBKWKjK_KKiKbKUKVKšK‘KuKNK|KŠK¥K¤K±K©K´K“KK™KJKOKEK4K2KBKKŒKaK7KeK]K“KK‘KƒK§K±K°K°K°K°K°K°K°K°K°K°K°K°K²K¢KWKRKVKWKVKXKWKSKPKLKPKQKQKVK]K`KGK+K*K,K)K"KKKKK5KAKBKAK?K@KBKAKBK@K?KAKAKAKAKAKBKBKBKAKBK@K?KAKBKBKAKAKAKAK?K>K>K>K>K>K?K>K>K?K?K>K?K>K>K>K=K=K=K=K=K>K>K=K=K=K:K;K8K,K%K*K-K0KK K:K:K:KK>K>K;K7K3K7KK>K>K(KKK+K?K3K.K/K,K +KKKK%KAK†KªK¬K½K^KýKKKKKAKkK¾K¸K»K´K,KK KKK K:KDKœK¾K·K¿K›KKKKKKKK=K?KK¼KµK´K½KZKKKKKKKK0KFKAK“K¼KµK´K¾KnK K%K$K$K"K#K&K'K)K9KDK?K}K»K´K´KµK¯KHK(K.K-K-K/K0K0K1K3K1K8K?K?K>K„K¶K±K±K±K²K»KºKºK»KºK­K†KUKCKDKDKEKDKDK@KK?K>K+K(K)K(KKKKKKKKKKKKK"K)K)K)K%KKKK K K KKKKKKKKKKK K!K&K&K%K'K(K(K#K$K(K(K*K+K*K*K+K+K+K-K-K1K?KK?K>K>K>K>K>K>K>K>K?K?K?K?K?K=KKK@K=KK>K>K;K9K4K5K>K>K?K:K2K1K)K0K>K>K?K?K#KK K>K9K.K/K1KKKKKK;KyK¼K¸KÁKKKK KK K9KRK­K»K·KÁKYKþKKKKK-K@KyK¾K¸K¸K·KKoK¹K´K³K¹KœK0K%K(K(K%K&K)K'K$K/KDK>KWK¯K¶K´K³K»KtK*K0K/K/K2K3K2K2K2K2K7K>K@KK>K;K+K'K'K'KKKKKKKKKKKKK$K)K(K(K#KKK K K K KKKKKKKKKK K K"K%K$K%K(K(K'K(K'K(K*K*K+K,K,K*K+K*K-K-K1K?K=KfK³K¯K¯K²K«K®K”K—K\KVKhK~KiK±K®KŠK!K]K®K¯K¨K¡KtKYK@KeK|KMKK°K²K±K­K­KZK"K#KiKFKCKZKcK“K­KœKyKnKfKKKRKdKYKdKsKrKdK/KiK›K‚K¢K¯K®K°K®K«K¦KKlKXKmKbKMKK5KRKnKzKK‡KlKOKSK˜K“KvKŽK§K²K­K±K²K²K²K²K²K²K²K²K²K±K°K­K_KQK^KgKvK…K‘KžK¨K±K´KµKµK³K±K²K´K·K±K—KnKDK+K%K+K(K"KKK2KAKBK@K@KBKBKAKAKAKAKAKAKAKAKAKAKAKBKBK@K@KBKAK@K?K>K?K>K>K>K>K>K>K@K@K?K?K?K?K?K=KK=KKK>K;K9K3K1K>K@K>K@K9K0K0K,K1KKKBKAK’K»K³K³K¹KK9K0K3K2K3K4K3K4K3K4K8KKBKAK>K>K>K>K>K>K>K>K?K?K>K>K>K>K>K>K?K=KK8K&K K4K8K9K;K9K5K4K5KK'KAK>K>K;K8K5K1KK>K@KK8KK*K?K0K-K.K&KKKKK.KNK©K½K·K¿KNKKK K K)K;KtKÀK¸K¹K¬K3KK KKK$K>KHKŸK¼K·K¿KœK(K#K$K$K$K#K)KAK>KK¼KµKµK»KgKK'K&K%K%K%K$K6KEK;KŠK»K³K³K½K{K&K*K)K+K+K(K8KK^K7KCK=KlK¸K´K´K´K´K[K+K3K3K4K5K5K5K4K6K8K8KK?K;KOK£K±K¯K¯K®K²K_K'K/K0K8KHKDK/K1K"K3KKKPKSKSKRKQK@K8K:KK?K>K?K>K=K=K=K>K?K>K>K?K=KK?K=K:K7K3K8KK?K=K>K3K6K2K+K6K?K>K@K4K$K>K4K-K.K-KKK +K K%KAKK¿K¶KÃKKKKKK&K;KXK·K»K¸K¾K]KK%K!K!K#K:K?KK½K·KºK·KIK"K)K(K%K%K(KKLK¤KµK³K³KºK‡K.K/K3K4K4K4K5K7K7K6K?KGKAK?KOK§K³K±K±K±K²KµKµKµKµK¯KKyKRKHKHKJKKKLKKKCK>K?K=KƒK´K­K°K­K±K‘K6K1K5KK=K?K?K7K(K(K&K%KKKKKKKKKKKKK$K'K(K)K KKK K +K KKKKKKKKKKKK K!K$K$K%K'K)K)K(K(K)K+K*K*K*K*K+K*K+K-K-K1K?K:KiK¶K¡KKuKwKŒKNK K$K)KRKK“K§K“KXK&KƒK³K¯K¯K®K£K—KlKbKxKfKfK~K¡K²K±K°K®K°KŸK”K’K K‹KˆK¤KŒK|K¢K«K‘K˜KK–K†KlKDK'K.KKLK™KQK9K„K—KzK K³K¬K—K}KAK—K‡KWKQKEKpK^KoK†K K´K±K²K³K³K´K¨K K©K¦K´K±K²K²K²K²K²K²K²K²K²K²K²K±K±K±K±K±K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K±K±K±K²K¶K¸K°K˜KpKDK,KKK%K5KCKCKBKAK?KAKAK?K>KAK@K>K>K>KAKAK>K?KBK@KBK@K>K?K>K>K=KK>K>K>K>K=K=K=K=K=K=KK=KK;K9K4K6K=K>K?K=K9K7K0K>K2K+K7K>K>K@K4K4K8K-K-K,KKKKK"K;KpK¿K·K¾K¦K)KK#KK!K:KFKK½K·KÁK…K$K(K%K$K#K2K@K^KµK¹K¸K¿KrK!K+K)K'K(K'K6KDKIK¢K¸K³K¶K°KEK&K)K)K)K'K&K&K;K?KKK¦K·K´K³K¹K_K%K,K+K*K)K0KXK@K+K=KBK>K‚K·K²K´KµKªKDK.K3K5K4K5K5K8K8K5KFKcKAKCK>K†K¶K¯K²K±K²KµK´K´K³K²K¨KKcKJKHKKKLKKKMKHKK>K?K4K'K(K&K$KKKKKKKKKKKKK(K)K(K*K!KKK K KKKKKKKKKKK!K KK#K&K%K%K'K)K'K)K+K+K+K+K*K*K+K*K+K.K,K*K0K@KK>K?K?K>K=K=K?K?K?K?K?K?K?K?K?K?K?K>K?K>KK?K>K>KK=K>K?K>K>K?K=KK?K>K9K4K5K;K>K?K8K1K:K.K=K;K0K,K6K>K>K;K6K2K-K)K+K'KKKKK9KWKµK½K»K»KKKK%K"K!K3K>KKÀK¸K¼K§K2K#K'K#K'K,K?KIK¤K»KµK½KšK.K)K+K*K+K)K-KCKBKK¼KµK¶K¼KhK&K+K(K)K(K'K%K6KCK>K†K»K³K³K¹K‡K*K,K+K*K+K*K>K5K+K5KAK@K_K²KµK´K³K¹KnK-K3K5K5K7K7K7K:K8KNKKRK?KK=K>K@KK³K«K®K¯K³K…K2K;KQKBK*K>KMKLKNKPKNKTKRKQKMK8K,K7K:KK>K?K3K'K(K'K$KKKKKKKKKKKKK(K)K(K*K KKK K KKKKKKKKKKK K!K K"K%K&K&K(K(K&K+K*K*K*K*K+K*K+K*K,K.K,K*K0K@KK=K=K>K>K?K>K>K?K>K>K>K>K>K>K>K>KK?K?K>K=K=K?K>K=K>K?K?K?K>K=KK>K:K6K2K9K?K>K9K3K=K1K:K?KK@KaK¶K·KµK½K‘K.K*K)K)K)K)K'K.K@K=KaKµK³K´K¶K©K?K(K,K+K+K+K.K.K(K/K?K@KEKšK¸K³K´K¹K–K6K2K4K5K7K8K8K9KKK>K?K2K(K(K(K#KKKKKKKKKKKKK(K)K(K)KKKK +K K KKKKKKKKKKK!K!K!K#K&K)K)K(K)K(K(K(K(K*K+K*K+K*K,K.K.K-K1K?KK?K>KK?K>K>K?K>KK>K>KK?K>K>K?K?K?K>K=KK=K=K9K1K8K>KK>K@K2K(K(K%K KKKKKKKKKKKKK)K(K(K)KKKK K K KKKKKKKKKK K!K"K#K$K&K'K(K)K(K)K(K)K*K*K+K*K+K*K,K.K-K-K1K?K;KlK¸KcK%KCKK'K5KRK¥K«K©K›K›K¬K¥K KK˜K´K³K±K°K¥K¥K¸K€K\KnK¢KŠK„KuKCKK¯K±KµK¢K¢K‘K‡KfKjK`K€K¨K¬K¶K·KtKWKyKƒK‡K\K5K(K'KdK—KbK›K³KiKZKyK)KK@K(KUKoKvKŸK²K¯K¯K¤K²K³K³K³K³K³K³K³K³K´KµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµK´K´K³K³K·K»K¯K“KaK=K:K>K?K>K>KK?K>K>K?K=KK=K=K=K>K?K>K>K?K>K=K=K=K=K=K;K;K=KK5K$K6K7K8K6K6K4K7K+KK8K>K>K=KK>K?K7K0K?K>K?K;K.K1K;K7K2K=K0K#K!KK'K+KK%K9KbK¼K¹K¼K´K>K!K'K&K%K8K>K‰K¿K¸K¾K K3K)K*K*K(K.K@KPKªKºK´K½K”K,K*K,K*K+K*K0KDKBKƒK¸K±K³K»KjK'K,K+K*K)K)K(K3KBK>KK»K³K³K¹K“K.K,K,K+K)K'K+K-K,K3K@K>KVK¬K´K²K²K¹K}K1K5K5K7K8K9K8KBKwK£K±KgK>K@KOK§K³K±K±K±K³K²K°K²K³K²K¡K€KXKLKNKJKLKTKPKAK:K=K;KoK°K®K¬K­K¯K KLKEKIKDKHKGKAKCKIKGK=K8K-KKKKK0K9K9KK>K>K/K'K(K%K KKKKKKKKKKKKK)K(K(K*KKKK K K KKKKKKKKKK!K K#K$K&K%K%K'K)K(K(K(K)K+K*K*K*K*K*K+K(K-K-K1K>K:KoKµK¨K„KJKEK[KfKmK‹KªK§K¥KaK“KªKK+KoK‰K®K¸KœK}K®KžKqK0KDKŒKNKxK„KUK—K²K’K«K¦K¨KšK–KK©K˜K‰K­K·K•K]K5KkKzKtK~KWKAKK>K>K?K=K;K?K>K>K>KK>K?K>KK;K"K0K8K7K5K4K4K5K3KK2K@K>K=KK>K@K:K-K=K?K>K@KKK?KŒK¾K´K¸K­KCK(K-K)K*K+K,K=K@KcKµKµK´K¼K“K-K+K+K,K)K)K(K,K?K?K\K³KµK´K¶K°KGK&K+K*K+K+K-K.K,K.KK:KCK@K8K2K*KKKKKK*K:K9K;K9e]r(K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K°K·K‡KNK.K:KJK™K×K®KjK6K5K/KK3K:K9K7K4K1K1K9K>K?K?K=K,K'K(K%K KKKKKKKKKKKKK)K(K(K)KKKK K KKKKKKKKKKK K!K#K$K%K&K(K(K(K(K+K(K(K+K*K*K*K*K+K(K'K/K-K3K@K=KcK±K¥K‰KqKŠKK˜K“K•KŸK–K…KUKzKjK KIKLKyK›K¸K KfKŒK‘K{KzK{KbKVK˜K—KŽK‡K«KŽK˜KªK´K·K¶K¶K¶K®K’K¬KµK£KeKKKLKCK9KrKcKNK1K!K2KvKœK‰KKšK“K!KZKvKBK1KGKSKKK™K´K®K¥K´KµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµK¶KµKµK¶K¶KµKµK¶KµKµKµKµKµKµKµK¶K¶K¶K³KµK³K³KµK¡K©KK@K:K@KAKAK?K>K?K>KK>K>K>K>K?K>K=K>K?K?K>KK>K>K=KK>K=K:K4K1K;K=K>K>K>K?K0K9K@K>K?K@K8K,K0K3K?K>K>K(KKKK+K*K3KAKŽKÀK¸KÁK‡K"K'K&K$K,K?KSK¯K¼K·K¿KpK$K+K+K*K(K8K>KmK¼KµKµK¼KjK%K*K)K*K+K)K5KCKHK K¹K³KµK¯KGK'K+K+K*K(K)K+K:KBKDK›K»K´K³KºKqK$K,K*K+K,K-K.K.K,K6KBK=KfK³K±K±K°K·KdK-K4K5K4K9K;KWKK¬K°KªKUK?K>K\K¯K²K±K²K±K²K±K²K°K±K®K™KyKUKOKMKQKWKLKDK=KK:KyK²K«K®K®K°K™KMKFKFK=K0K4K9K,K KKKKKKK.KK1K8K9K9e]r(K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K±K¶K}KHK*K=KMK¤KÒK§KdK3K5K*KK5K:K:K8K4K1K2K:K>K@K?K=K,K'K(K%K KKKKKKKKKKKKK)K(K(K(KKKK +K KKKKKKKKKKK K!K#K$K%K'K)K(K)K(K%K(K*K*K*K*K*K+K*K+K+K.K-K4K@K:K]K²K®K K¢K~K‘K£K™K¨K³KªKƒKSK6KKK]K~K©K K±K°KxKrK¦K˜K…KKBKvK•K“K–KKšK·K¥K«K¶K´K´K´K´K³K³K°K³K¸K²KŽKnKMKZKKŒK‘KWK/K'K@KXKWK…K˜K]KKTKqKNKCKPKnKFK~K¶KžKŽK¹KµK´KµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµK·KµKµK·K·KµKµK·KµKµKµKµKµKµKµK¶K·K¶K³K´K´K¯K”K‰K¶KºK9KK4KBKBK?K>K?K>KK?K>K>K?K?K?K=KK?K?K>KK?K?K>K=KK>K?K,K)K7K8K8K8K5K5K7K KK@K>K?K>K:K7K0K9K=K>K?K>K?K3K6KAK?K?K?K>K3K)K6K?K>K?K;KKKKK-K5K:KoKÀKºK¼K¤K5K$K&K%K&K;KCK—K¾K·K½K“K-K'K+K*K*K2K?KQK­K¹K´K½KK.K,K,K+K+K)K0KCK?K„K»K³K³K»KlK%K,K+K*K)K(K)K2KBKKK= 0 + 1 1 1 1 1 + 1 1 1 1 -1 + 1 1 1 -1 1 + 1 1 1 -1 -1 + 1 1 -1 1 1 + 1 1 -1 1 -1 + 1 1 -1 -1 1 + 1 1 -1 -1 -1 + 1 -1 1 1 1 + 1 -1 1 1 -1 + 1 -1 1 -1 1 + 1 -1 1 -1 -1 + 1 -1 -1 1 1 + 1 -1 -1 1 -1 + 1 -1 -1 -1 1 + 1 -1 -1 -1 -1 + 1 2 0 0 0 + 1 0 2 0 0 + 1 0 0 2 0 + 1 0 0 0 2 + 1 -2 0 0 0 + 1 0 -2 0 0 + 1 0 0 -2 0 + 1 0 0 0 -2 diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/__init__.py b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..abe4a32f20d1f8740910a16de9e67a53621bc3e3 --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/__init__.py @@ -0,0 +1,29 @@ +""" +Spatial Transformations (:mod:`scipy.spatial.transform`) +======================================================== + +.. currentmodule:: scipy.spatial.transform + +This package implements various spatial transformations. For now, +only rotations are supported. + +Rotations in 3 dimensions +------------------------- +.. autosummary:: + :toctree: generated/ + + Rotation + Slerp + RotationSpline +""" +from ._rotation import Rotation, Slerp +from ._rotation_spline import RotationSpline + +# Deprecated namespaces, to be removed in v2.0.0 +from . import rotation + +__all__ = ['Rotation', 'Slerp', 'RotationSpline'] + +from scipy._lib._testutils import PytestTester +test = PytestTester(__name__) +del PytestTester diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/__pycache__/__init__.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0585c658ebe766af661416afebd1e8a2b8901910 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/__pycache__/__init__.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/__pycache__/_rotation_groups.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/__pycache__/_rotation_groups.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2268e85faf341457958c0a8a2aee3d7229d986fe Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/__pycache__/_rotation_groups.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/__pycache__/_rotation_spline.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/__pycache__/_rotation_spline.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9e87f7b4235ee2c82b91045a686e1784e39469db Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/__pycache__/_rotation_spline.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/__pycache__/rotation.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/__pycache__/rotation.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8d6bb13c141ad533d9faa31444499ef8150a9466 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/__pycache__/rotation.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/_rotation.cpython-310-x86_64-linux-gnu.so b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/_rotation.cpython-310-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..c610538cdfc644601f5113c98df8beb3345c49a6 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/_rotation.cpython-310-x86_64-linux-gnu.so differ diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/_rotation.pyi b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/_rotation.pyi new file mode 100644 index 0000000000000000000000000000000000000000..e7665001535e2fd44c14fc2b0488e0e2eee3b542 --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/_rotation.pyi @@ -0,0 +1,65 @@ +from __future__ import annotations +from typing import TYPE_CHECKING +from collections.abc import Sequence +import numpy as np + +if TYPE_CHECKING: + import numpy.typing as npt + +_IntegerType = int | np.integer + + +class Rotation: + def __init__(self, quat: npt.ArrayLike, normalize: bool = ..., copy: bool = ...) -> None: ... + @property + def single(self) -> bool: ... + def __len__(self) -> int: ... + @classmethod + def from_quat(cls, quat: npt.ArrayLike) -> Rotation: ... + @classmethod + def from_matrix(cls, matrix: npt.ArrayLike) -> Rotation: ... + @classmethod + def from_rotvec(cls, rotvec: npt.ArrayLike, degrees: bool = ...) -> Rotation: ... + @classmethod + def from_euler(cls, seq: str, angles: float | npt.ArrayLike, degrees: bool = ...) -> Rotation: ... + @classmethod + def from_davenport(cls, axes: npt.ArrayLike, order: str, angles: float | npt.ArrayLike, degrees: bool = ...) -> Rotation: ... + @classmethod + def from_mrp(cls, mrp: npt.ArrayLike) -> Rotation: ... + def as_quat(self, canonical: bool) -> np.ndarray: ... + def as_matrix(self) -> np.ndarray: ... + def as_rotvec(self, degrees: bool = ...) -> np.ndarray: ... + def as_euler(self, seq: str, degrees: bool = ...) -> np.ndarray: ... + def as_davenport(self, axes: npt.ArrayLike, order: str, degrees: bool = ...) -> np.ndarray: ... + def as_mrp(self) -> np.ndarray: ... + @classmethod + def concatenate(cls, rotations: Sequence[Rotation]) -> Rotation: ... + def apply(self, vectors: npt.ArrayLike, inverse: bool = ...) -> np.ndarray: ... + def __mul__(self, other: Rotation) -> Rotation: ... + def __pow__(self, n: float, modulus: int | None) -> Rotation: ... + def inv(self) -> Rotation: ... + def magnitude(self) -> np.ndarray | float: ... + def approx_equal(self, other: Rotation, atol: float | None, degrees: bool = ...) -> np.ndarray | bool: ... + def mean(self, weights: npt.ArrayLike | None = ...) -> Rotation: ... + def reduce(self, left: Rotation | None = ..., right: Rotation | None = ..., + return_indices: bool = ...) -> Rotation | tuple[Rotation, np.ndarray, np.ndarray]: ... + @classmethod + def create_group(cls, group: str, axis: str = ...) -> Rotation: ... + def __getitem__(self, indexer: int | slice | npt.ArrayLike) -> Rotation: ... + @classmethod + def identity(cls, num: int | None = ...) -> Rotation: ... + @classmethod + def random(cls, num: int | None = ..., + random_state: _IntegerType | np.random.Generator | np.random.RandomState | None = ...) -> Rotation: ... + @classmethod + def align_vectors(cls, a: npt.ArrayLike, b: npt.ArrayLike, + weights: npt.ArrayLike | None = ..., + return_sensitivity: bool = ...) -> tuple[Rotation, float] | tuple[Rotation, float, np.ndarray]:... + +class Slerp: + times: np.ndarray + timedelta: np.ndarray + rotations: Rotation + rotvecs: np.ndarray + def __init__(self, times: npt.ArrayLike, rotations: Rotation) -> None: ... + def __call__(self, times: npt.ArrayLike) -> Rotation: ... diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/_rotation_groups.py b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/_rotation_groups.py new file mode 100644 index 0000000000000000000000000000000000000000..870e9b9e2b44bff56b8228a70607e29f8173accc --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/_rotation_groups.py @@ -0,0 +1,140 @@ +import numpy as np +from scipy.constants import golden as phi + + +def icosahedral(cls): + g1 = tetrahedral(cls).as_quat() + a = 0.5 + b = 0.5 / phi + c = phi / 2 + g2 = np.array([[+a, +b, +c, 0], + [+a, +b, -c, 0], + [+a, +c, 0, +b], + [+a, +c, 0, -b], + [+a, -b, +c, 0], + [+a, -b, -c, 0], + [+a, -c, 0, +b], + [+a, -c, 0, -b], + [+a, 0, +b, +c], + [+a, 0, +b, -c], + [+a, 0, -b, +c], + [+a, 0, -b, -c], + [+b, +a, 0, +c], + [+b, +a, 0, -c], + [+b, +c, +a, 0], + [+b, +c, -a, 0], + [+b, -a, 0, +c], + [+b, -a, 0, -c], + [+b, -c, +a, 0], + [+b, -c, -a, 0], + [+b, 0, +c, +a], + [+b, 0, +c, -a], + [+b, 0, -c, +a], + [+b, 0, -c, -a], + [+c, +a, +b, 0], + [+c, +a, -b, 0], + [+c, +b, 0, +a], + [+c, +b, 0, -a], + [+c, -a, +b, 0], + [+c, -a, -b, 0], + [+c, -b, 0, +a], + [+c, -b, 0, -a], + [+c, 0, +a, +b], + [+c, 0, +a, -b], + [+c, 0, -a, +b], + [+c, 0, -a, -b], + [0, +a, +c, +b], + [0, +a, +c, -b], + [0, +a, -c, +b], + [0, +a, -c, -b], + [0, +b, +a, +c], + [0, +b, +a, -c], + [0, +b, -a, +c], + [0, +b, -a, -c], + [0, +c, +b, +a], + [0, +c, +b, -a], + [0, +c, -b, +a], + [0, +c, -b, -a]]) + return cls.from_quat(np.concatenate((g1, g2))) + + +def octahedral(cls): + g1 = tetrahedral(cls).as_quat() + c = np.sqrt(2) / 2 + g2 = np.array([[+c, 0, 0, +c], + [0, +c, 0, +c], + [0, 0, +c, +c], + [0, 0, -c, +c], + [0, -c, 0, +c], + [-c, 0, 0, +c], + [0, +c, +c, 0], + [0, -c, +c, 0], + [+c, 0, +c, 0], + [-c, 0, +c, 0], + [+c, +c, 0, 0], + [-c, +c, 0, 0]]) + return cls.from_quat(np.concatenate((g1, g2))) + + +def tetrahedral(cls): + g1 = np.eye(4) + c = 0.5 + g2 = np.array([[c, -c, -c, +c], + [c, -c, +c, +c], + [c, +c, -c, +c], + [c, +c, +c, +c], + [c, -c, -c, -c], + [c, -c, +c, -c], + [c, +c, -c, -c], + [c, +c, +c, -c]]) + return cls.from_quat(np.concatenate((g1, g2))) + + +def dicyclic(cls, n, axis=2): + g1 = cyclic(cls, n, axis).as_rotvec() + + thetas = np.linspace(0, np.pi, n, endpoint=False) + rv = np.pi * np.vstack([np.zeros(n), np.cos(thetas), np.sin(thetas)]).T + g2 = np.roll(rv, axis, axis=1) + return cls.from_rotvec(np.concatenate((g1, g2))) + + +def cyclic(cls, n, axis=2): + thetas = np.linspace(0, 2 * np.pi, n, endpoint=False) + rv = np.vstack([thetas, np.zeros(n), np.zeros(n)]).T + return cls.from_rotvec(np.roll(rv, axis, axis=1)) + + +def create_group(cls, group, axis='Z'): + if not isinstance(group, str): + raise ValueError("`group` argument must be a string") + + permitted_axes = ['x', 'y', 'z', 'X', 'Y', 'Z'] + if axis not in permitted_axes: + raise ValueError("`axis` must be one of " + ", ".join(permitted_axes)) + + if group in ['I', 'O', 'T']: + symbol = group + order = 1 + elif group[:1] in ['C', 'D'] and group[1:].isdigit(): + symbol = group[:1] + order = int(group[1:]) + else: + raise ValueError("`group` must be one of 'I', 'O', 'T', 'Dn', 'Cn'") + + if order < 1: + raise ValueError("Group order must be positive") + + axis = 'xyz'.index(axis.lower()) + if symbol == 'I': + return icosahedral(cls) + elif symbol == 'O': + return octahedral(cls) + elif symbol == 'T': + return tetrahedral(cls) + elif symbol == 'D': + return dicyclic(cls, order, axis=axis) + elif symbol == 'C': + return cyclic(cls, order, axis=axis) + else: + assert False diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/_rotation_spline.py b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/_rotation_spline.py new file mode 100644 index 0000000000000000000000000000000000000000..1c07129721e3652d018ffc3be485e6ed785f5564 --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/_rotation_spline.py @@ -0,0 +1,460 @@ +import numpy as np +from scipy.linalg import solve_banded +from ._rotation import Rotation + + +def _create_skew_matrix(x): + """Create skew-symmetric matrices corresponding to vectors. + + Parameters + ---------- + x : ndarray, shape (n, 3) + Set of vectors. + + Returns + ------- + ndarray, shape (n, 3, 3) + """ + result = np.zeros((len(x), 3, 3)) + result[:, 0, 1] = -x[:, 2] + result[:, 0, 2] = x[:, 1] + result[:, 1, 0] = x[:, 2] + result[:, 1, 2] = -x[:, 0] + result[:, 2, 0] = -x[:, 1] + result[:, 2, 1] = x[:, 0] + return result + + +def _matrix_vector_product_of_stacks(A, b): + """Compute the product of stack of matrices and vectors.""" + return np.einsum("ijk,ik->ij", A, b) + + +def _angular_rate_to_rotvec_dot_matrix(rotvecs): + """Compute matrices to transform angular rates to rot. vector derivatives. + + The matrices depend on the current attitude represented as a rotation + vector. + + Parameters + ---------- + rotvecs : ndarray, shape (n, 3) + Set of rotation vectors. + + Returns + ------- + ndarray, shape (n, 3, 3) + """ + norm = np.linalg.norm(rotvecs, axis=1) + k = np.empty_like(norm) + + mask = norm > 1e-4 + nm = norm[mask] + k[mask] = (1 - 0.5 * nm / np.tan(0.5 * nm)) / nm**2 + mask = ~mask + nm = norm[mask] + k[mask] = 1/12 + 1/720 * nm**2 + + skew = _create_skew_matrix(rotvecs) + + result = np.empty((len(rotvecs), 3, 3)) + result[:] = np.identity(3) + result[:] += 0.5 * skew + result[:] += k[:, None, None] * np.matmul(skew, skew) + + return result + + +def _rotvec_dot_to_angular_rate_matrix(rotvecs): + """Compute matrices to transform rot. vector derivatives to angular rates. + + The matrices depend on the current attitude represented as a rotation + vector. + + Parameters + ---------- + rotvecs : ndarray, shape (n, 3) + Set of rotation vectors. + + Returns + ------- + ndarray, shape (n, 3, 3) + """ + norm = np.linalg.norm(rotvecs, axis=1) + k1 = np.empty_like(norm) + k2 = np.empty_like(norm) + + mask = norm > 1e-4 + nm = norm[mask] + k1[mask] = (1 - np.cos(nm)) / nm ** 2 + k2[mask] = (nm - np.sin(nm)) / nm ** 3 + + mask = ~mask + nm = norm[mask] + k1[mask] = 0.5 - nm ** 2 / 24 + k2[mask] = 1 / 6 - nm ** 2 / 120 + + skew = _create_skew_matrix(rotvecs) + + result = np.empty((len(rotvecs), 3, 3)) + result[:] = np.identity(3) + result[:] -= k1[:, None, None] * skew + result[:] += k2[:, None, None] * np.matmul(skew, skew) + + return result + + +def _angular_acceleration_nonlinear_term(rotvecs, rotvecs_dot): + """Compute the non-linear term in angular acceleration. + + The angular acceleration contains a quadratic term with respect to + the derivative of the rotation vector. This function computes that. + + Parameters + ---------- + rotvecs : ndarray, shape (n, 3) + Set of rotation vectors. + rotvecs_dot : ndarray, shape (n, 3) + Set of rotation vector derivatives. + + Returns + ------- + ndarray, shape (n, 3) + """ + norm = np.linalg.norm(rotvecs, axis=1) + dp = np.sum(rotvecs * rotvecs_dot, axis=1) + cp = np.cross(rotvecs, rotvecs_dot) + ccp = np.cross(rotvecs, cp) + dccp = np.cross(rotvecs_dot, cp) + + k1 = np.empty_like(norm) + k2 = np.empty_like(norm) + k3 = np.empty_like(norm) + + mask = norm > 1e-4 + nm = norm[mask] + k1[mask] = (-nm * np.sin(nm) - 2 * (np.cos(nm) - 1)) / nm ** 4 + k2[mask] = (-2 * nm + 3 * np.sin(nm) - nm * np.cos(nm)) / nm ** 5 + k3[mask] = (nm - np.sin(nm)) / nm ** 3 + + mask = ~mask + nm = norm[mask] + k1[mask] = 1/12 - nm ** 2 / 180 + k2[mask] = -1/60 + nm ** 2 / 12604 + k3[mask] = 1/6 - nm ** 2 / 120 + + dp = dp[:, None] + k1 = k1[:, None] + k2 = k2[:, None] + k3 = k3[:, None] + + return dp * (k1 * cp + k2 * ccp) + k3 * dccp + + +def _compute_angular_rate(rotvecs, rotvecs_dot): + """Compute angular rates given rotation vectors and its derivatives. + + Parameters + ---------- + rotvecs : ndarray, shape (n, 3) + Set of rotation vectors. + rotvecs_dot : ndarray, shape (n, 3) + Set of rotation vector derivatives. + + Returns + ------- + ndarray, shape (n, 3) + """ + return _matrix_vector_product_of_stacks( + _rotvec_dot_to_angular_rate_matrix(rotvecs), rotvecs_dot) + + +def _compute_angular_acceleration(rotvecs, rotvecs_dot, rotvecs_dot_dot): + """Compute angular acceleration given rotation vector and its derivatives. + + Parameters + ---------- + rotvecs : ndarray, shape (n, 3) + Set of rotation vectors. + rotvecs_dot : ndarray, shape (n, 3) + Set of rotation vector derivatives. + rotvecs_dot_dot : ndarray, shape (n, 3) + Set of rotation vector second derivatives. + + Returns + ------- + ndarray, shape (n, 3) + """ + return (_compute_angular_rate(rotvecs, rotvecs_dot_dot) + + _angular_acceleration_nonlinear_term(rotvecs, rotvecs_dot)) + + +def _create_block_3_diagonal_matrix(A, B, d): + """Create a 3-diagonal block matrix as banded. + + The matrix has the following structure: + + DB... + ADB.. + .ADB. + ..ADB + ...AD + + The blocks A, B and D are 3-by-3 matrices. The D matrices has the form + d * I. + + Parameters + ---------- + A : ndarray, shape (n, 3, 3) + Stack of A blocks. + B : ndarray, shape (n, 3, 3) + Stack of B blocks. + d : ndarray, shape (n + 1,) + Values for diagonal blocks. + + Returns + ------- + ndarray, shape (11, 3 * (n + 1)) + Matrix in the banded form as used by `scipy.linalg.solve_banded`. + """ + ind = np.arange(3) + ind_blocks = np.arange(len(A)) + + A_i = np.empty_like(A, dtype=int) + A_i[:] = ind[:, None] + A_i += 3 * (1 + ind_blocks[:, None, None]) + + A_j = np.empty_like(A, dtype=int) + A_j[:] = ind + A_j += 3 * ind_blocks[:, None, None] + + B_i = np.empty_like(B, dtype=int) + B_i[:] = ind[:, None] + B_i += 3 * ind_blocks[:, None, None] + + B_j = np.empty_like(B, dtype=int) + B_j[:] = ind + B_j += 3 * (1 + ind_blocks[:, None, None]) + + diag_i = diag_j = np.arange(3 * len(d)) + i = np.hstack((A_i.ravel(), B_i.ravel(), diag_i)) + j = np.hstack((A_j.ravel(), B_j.ravel(), diag_j)) + values = np.hstack((A.ravel(), B.ravel(), np.repeat(d, 3))) + + u = 5 + l = 5 + result = np.zeros((u + l + 1, 3 * len(d))) + result[u + i - j, j] = values + return result + + +class RotationSpline: + """Interpolate rotations with continuous angular rate and acceleration. + + The rotation vectors between each consecutive orientation are cubic + functions of time and it is guaranteed that angular rate and acceleration + are continuous. Such interpolation are analogous to cubic spline + interpolation. + + Refer to [1]_ for math and implementation details. + + Parameters + ---------- + times : array_like, shape (N,) + Times of the known rotations. At least 2 times must be specified. + rotations : `Rotation` instance + Rotations to perform the interpolation between. Must contain N + rotations. + + Methods + ------- + __call__ + + References + ---------- + .. [1] `Smooth Attitude Interpolation + `_ + + Examples + -------- + >>> from scipy.spatial.transform import Rotation, RotationSpline + >>> import numpy as np + + Define the sequence of times and rotations from the Euler angles: + + >>> times = [0, 10, 20, 40] + >>> angles = [[-10, 20, 30], [0, 15, 40], [-30, 45, 30], [20, 45, 90]] + >>> rotations = Rotation.from_euler('XYZ', angles, degrees=True) + + Create the interpolator object: + + >>> spline = RotationSpline(times, rotations) + + Interpolate the Euler angles, angular rate and acceleration: + + >>> angular_rate = np.rad2deg(spline(times, 1)) + >>> angular_acceleration = np.rad2deg(spline(times, 2)) + >>> times_plot = np.linspace(times[0], times[-1], 100) + >>> angles_plot = spline(times_plot).as_euler('XYZ', degrees=True) + >>> angular_rate_plot = np.rad2deg(spline(times_plot, 1)) + >>> angular_acceleration_plot = np.rad2deg(spline(times_plot, 2)) + + On this plot you see that Euler angles are continuous and smooth: + + >>> import matplotlib.pyplot as plt + >>> plt.plot(times_plot, angles_plot) + >>> plt.plot(times, angles, 'x') + >>> plt.title("Euler angles") + >>> plt.show() + + The angular rate is also smooth: + + >>> plt.plot(times_plot, angular_rate_plot) + >>> plt.plot(times, angular_rate, 'x') + >>> plt.title("Angular rate") + >>> plt.show() + + The angular acceleration is continuous, but not smooth. Also note that + the angular acceleration is not a piecewise-linear function, because + it is different from the second derivative of the rotation vector (which + is a piecewise-linear function as in the cubic spline). + + >>> plt.plot(times_plot, angular_acceleration_plot) + >>> plt.plot(times, angular_acceleration, 'x') + >>> plt.title("Angular acceleration") + >>> plt.show() + """ + # Parameters for the solver for angular rate. + MAX_ITER = 10 + TOL = 1e-9 + + def _solve_for_angular_rates(self, dt, angular_rates, rotvecs): + angular_rate_first = angular_rates[0].copy() + + A = _angular_rate_to_rotvec_dot_matrix(rotvecs) + A_inv = _rotvec_dot_to_angular_rate_matrix(rotvecs) + M = _create_block_3_diagonal_matrix( + 2 * A_inv[1:-1] / dt[1:-1, None, None], + 2 * A[1:-1] / dt[1:-1, None, None], + 4 * (1 / dt[:-1] + 1 / dt[1:])) + + b0 = 6 * (rotvecs[:-1] * dt[:-1, None] ** -2 + + rotvecs[1:] * dt[1:, None] ** -2) + b0[0] -= 2 / dt[0] * A_inv[0].dot(angular_rate_first) + b0[-1] -= 2 / dt[-1] * A[-1].dot(angular_rates[-1]) + + for iteration in range(self.MAX_ITER): + rotvecs_dot = _matrix_vector_product_of_stacks(A, angular_rates) + delta_beta = _angular_acceleration_nonlinear_term( + rotvecs[:-1], rotvecs_dot[:-1]) + b = b0 - delta_beta + angular_rates_new = solve_banded((5, 5), M, b.ravel()) + angular_rates_new = angular_rates_new.reshape((-1, 3)) + + delta = np.abs(angular_rates_new - angular_rates[:-1]) + angular_rates[:-1] = angular_rates_new + if np.all(delta < self.TOL * (1 + np.abs(angular_rates_new))): + break + + rotvecs_dot = _matrix_vector_product_of_stacks(A, angular_rates) + angular_rates = np.vstack((angular_rate_first, angular_rates[:-1])) + + return angular_rates, rotvecs_dot + + def __init__(self, times, rotations): + from scipy.interpolate import PPoly + + if rotations.single: + raise ValueError("`rotations` must be a sequence of rotations.") + + if len(rotations) == 1: + raise ValueError("`rotations` must contain at least 2 rotations.") + + times = np.asarray(times, dtype=float) + if times.ndim != 1: + raise ValueError("`times` must be 1-dimensional.") + + if len(times) != len(rotations): + raise ValueError("Expected number of rotations to be equal to " + "number of timestamps given, got {} rotations " + "and {} timestamps." + .format(len(rotations), len(times))) + + dt = np.diff(times) + if np.any(dt <= 0): + raise ValueError("Values in `times` must be in a strictly " + "increasing order.") + + rotvecs = (rotations[:-1].inv() * rotations[1:]).as_rotvec() + angular_rates = rotvecs / dt[:, None] + + if len(rotations) == 2: + rotvecs_dot = angular_rates + else: + angular_rates, rotvecs_dot = self._solve_for_angular_rates( + dt, angular_rates, rotvecs) + + dt = dt[:, None] + coeff = np.empty((4, len(times) - 1, 3)) + coeff[0] = (-2 * rotvecs + dt * angular_rates + + dt * rotvecs_dot) / dt ** 3 + coeff[1] = (3 * rotvecs - 2 * dt * angular_rates + - dt * rotvecs_dot) / dt ** 2 + coeff[2] = angular_rates + coeff[3] = 0 + + self.times = times + self.rotations = rotations + self.interpolator = PPoly(coeff, times) + + def __call__(self, times, order=0): + """Compute interpolated values. + + Parameters + ---------- + times : float or array_like + Times of interest. + order : {0, 1, 2}, optional + Order of differentiation: + + * 0 (default) : return Rotation + * 1 : return the angular rate in rad/sec + * 2 : return the angular acceleration in rad/sec/sec + + Returns + ------- + Interpolated Rotation, angular rate or acceleration. + """ + if order not in [0, 1, 2]: + raise ValueError("`order` must be 0, 1 or 2.") + + times = np.asarray(times, dtype=float) + if times.ndim > 1: + raise ValueError("`times` must be at most 1-dimensional.") + + singe_time = times.ndim == 0 + times = np.atleast_1d(times) + + rotvecs = self.interpolator(times) + if order == 0: + index = np.searchsorted(self.times, times, side='right') + index -= 1 + index[index < 0] = 0 + n_segments = len(self.times) - 1 + index[index > n_segments - 1] = n_segments - 1 + result = self.rotations[index] * Rotation.from_rotvec(rotvecs) + elif order == 1: + rotvecs_dot = self.interpolator(times, 1) + result = _compute_angular_rate(rotvecs, rotvecs_dot) + elif order == 2: + rotvecs_dot = self.interpolator(times, 1) + rotvecs_dot_dot = self.interpolator(times, 2) + result = _compute_angular_acceleration(rotvecs, rotvecs_dot, + rotvecs_dot_dot) + else: + assert False + + if singe_time: + result = result[0] + + return result diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/rotation.py b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/rotation.py new file mode 100644 index 0000000000000000000000000000000000000000..8aee10d960cffe9ce8aa7581ca633c6aad1d17a8 --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/rotation.py @@ -0,0 +1,24 @@ +# This file is not meant for public use and will be removed in SciPy v2.0.0. +# Use the `scipy.spatial` namespace for importing the functions +# included below. + +from scipy._lib.deprecation import _sub_module_deprecation + + +__all__ = [ # noqa: F822 + 'Rotation', + 'Slerp', + 'check_random_state', + 'create_group', + 're', +] + + +def __dir__(): + return __all__ + + +def __getattr__(name): + return _sub_module_deprecation(sub_package="spatial.transform", module="rotation", + private_modules=["_rotation"], all=__all__, + attribute=name) diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/tests/__init__.py b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/tests/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/tests/__pycache__/__init__.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/tests/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..818a9e83756d835b7b2c252119f21909fc9e6077 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/tests/__pycache__/__init__.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/tests/__pycache__/test_rotation.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/tests/__pycache__/test_rotation.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9bdc07585d479e262f83d7be3b3f4fd17601a81c Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/tests/__pycache__/test_rotation.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/tests/__pycache__/test_rotation_groups.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/tests/__pycache__/test_rotation_groups.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6b39300d26f43f91b8ab43ffc601bae4fc0a960f Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/tests/__pycache__/test_rotation_groups.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/tests/__pycache__/test_rotation_spline.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/tests/__pycache__/test_rotation_spline.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ba7c6f9c0957b00518b85602105ed2ea95306054 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/tests/__pycache__/test_rotation_spline.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/tests/test_rotation.py b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/tests/test_rotation.py new file mode 100644 index 0000000000000000000000000000000000000000..8a1176d4a2619c14dc8faa24115a2f0952c16180 --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/tests/test_rotation.py @@ -0,0 +1,1880 @@ +import pytest + +import numpy as np +from numpy.testing import assert_equal, assert_array_almost_equal +from numpy.testing import assert_allclose +from scipy.spatial.transform import Rotation, Slerp +from scipy.stats import special_ortho_group +from itertools import permutations + +import pickle +import copy + +def basis_vec(axis): + if axis == 'x': + return [1, 0, 0] + elif axis == 'y': + return [0, 1, 0] + elif axis == 'z': + return [0, 0, 1] + +def test_generic_quat_matrix(): + x = np.array([[3, 4, 0, 0], [5, 12, 0, 0]]) + r = Rotation.from_quat(x) + expected_quat = x / np.array([[5], [13]]) + assert_array_almost_equal(r.as_quat(), expected_quat) + + +def test_from_single_1d_quaternion(): + x = np.array([3, 4, 0, 0]) + r = Rotation.from_quat(x) + expected_quat = x / 5 + assert_array_almost_equal(r.as_quat(), expected_quat) + + +def test_from_single_2d_quaternion(): + x = np.array([[3, 4, 0, 0]]) + r = Rotation.from_quat(x) + expected_quat = x / 5 + assert_array_almost_equal(r.as_quat(), expected_quat) + + +def test_from_square_quat_matrix(): + # Ensure proper norm array broadcasting + x = np.array([ + [3, 0, 0, 4], + [5, 0, 12, 0], + [0, 0, 0, 1], + [-1, -1, -1, 1], + [0, 0, 0, -1], # Check double cover + [-1, -1, -1, -1] # Check double cover + ]) + r = Rotation.from_quat(x) + expected_quat = x / np.array([[5], [13], [1], [2], [1], [2]]) + assert_array_almost_equal(r.as_quat(), expected_quat) + + +def test_quat_double_to_canonical_single_cover(): + x = np.array([ + [-1, 0, 0, 0], + [0, -1, 0, 0], + [0, 0, -1, 0], + [0, 0, 0, -1], + [-1, -1, -1, -1] + ]) + r = Rotation.from_quat(x) + expected_quat = np.abs(x) / np.linalg.norm(x, axis=1)[:, None] + assert_allclose(r.as_quat(canonical=True), expected_quat) + + +def test_quat_double_cover(): + # See the Rotation.from_quat() docstring for scope of the quaternion + # double cover property. + # Check from_quat and as_quat(canonical=False) + q = np.array([0, 0, 0, -1]) + r = Rotation.from_quat(q) + assert_equal(q, r.as_quat(canonical=False)) + + # Check composition and inverse + q = np.array([1, 0, 0, 1])/np.sqrt(2) # 90 deg rotation about x + r = Rotation.from_quat(q) + r3 = r*r*r + assert_allclose(r.as_quat(canonical=False)*np.sqrt(2), + [1, 0, 0, 1]) + assert_allclose(r.inv().as_quat(canonical=False)*np.sqrt(2), + [-1, 0, 0, 1]) + assert_allclose(r3.as_quat(canonical=False)*np.sqrt(2), + [1, 0, 0, -1]) + assert_allclose(r3.inv().as_quat(canonical=False)*np.sqrt(2), + [-1, 0, 0, -1]) + + # More sanity checks + assert_allclose((r*r.inv()).as_quat(canonical=False), + [0, 0, 0, 1], atol=2e-16) + assert_allclose((r3*r3.inv()).as_quat(canonical=False), + [0, 0, 0, 1], atol=2e-16) + assert_allclose((r*r3).as_quat(canonical=False), + [0, 0, 0, -1], atol=2e-16) + assert_allclose((r.inv()*r3.inv()).as_quat(canonical=False), + [0, 0, 0, -1], atol=2e-16) + + +def test_malformed_1d_from_quat(): + with pytest.raises(ValueError): + Rotation.from_quat(np.array([1, 2, 3])) + + +def test_malformed_2d_from_quat(): + with pytest.raises(ValueError): + Rotation.from_quat(np.array([ + [1, 2, 3, 4, 5], + [4, 5, 6, 7, 8] + ])) + + +def test_zero_norms_from_quat(): + x = np.array([ + [3, 4, 0, 0], + [0, 0, 0, 0], + [5, 0, 12, 0] + ]) + with pytest.raises(ValueError): + Rotation.from_quat(x) + + +def test_as_matrix_single_1d_quaternion(): + quat = [0, 0, 0, 1] + mat = Rotation.from_quat(quat).as_matrix() + # mat.shape == (3,3) due to 1d input + assert_array_almost_equal(mat, np.eye(3)) + + +def test_as_matrix_single_2d_quaternion(): + quat = [[0, 0, 1, 1]] + mat = Rotation.from_quat(quat).as_matrix() + assert_equal(mat.shape, (1, 3, 3)) + expected_mat = np.array([ + [0, -1, 0], + [1, 0, 0], + [0, 0, 1] + ]) + assert_array_almost_equal(mat[0], expected_mat) + + +def test_as_matrix_from_square_input(): + quats = [ + [0, 0, 1, 1], + [0, 1, 0, 1], + [0, 0, 0, 1], + [0, 0, 0, -1] + ] + mat = Rotation.from_quat(quats).as_matrix() + assert_equal(mat.shape, (4, 3, 3)) + + expected0 = np.array([ + [0, -1, 0], + [1, 0, 0], + [0, 0, 1] + ]) + assert_array_almost_equal(mat[0], expected0) + + expected1 = np.array([ + [0, 0, 1], + [0, 1, 0], + [-1, 0, 0] + ]) + assert_array_almost_equal(mat[1], expected1) + + assert_array_almost_equal(mat[2], np.eye(3)) + assert_array_almost_equal(mat[3], np.eye(3)) + + +def test_as_matrix_from_generic_input(): + quats = [ + [0, 0, 1, 1], + [0, 1, 0, 1], + [1, 2, 3, 4] + ] + mat = Rotation.from_quat(quats).as_matrix() + assert_equal(mat.shape, (3, 3, 3)) + + expected0 = np.array([ + [0, -1, 0], + [1, 0, 0], + [0, 0, 1] + ]) + assert_array_almost_equal(mat[0], expected0) + + expected1 = np.array([ + [0, 0, 1], + [0, 1, 0], + [-1, 0, 0] + ]) + assert_array_almost_equal(mat[1], expected1) + + expected2 = np.array([ + [0.4, -2, 2.2], + [2.8, 1, 0.4], + [-1, 2, 2] + ]) / 3 + assert_array_almost_equal(mat[2], expected2) + + +def test_from_single_2d_matrix(): + mat = [ + [0, 0, 1], + [1, 0, 0], + [0, 1, 0] + ] + expected_quat = [0.5, 0.5, 0.5, 0.5] + assert_array_almost_equal( + Rotation.from_matrix(mat).as_quat(), + expected_quat) + + +def test_from_single_3d_matrix(): + mat = np.array([ + [0, 0, 1], + [1, 0, 0], + [0, 1, 0] + ]).reshape((1, 3, 3)) + expected_quat = np.array([0.5, 0.5, 0.5, 0.5]).reshape((1, 4)) + assert_array_almost_equal( + Rotation.from_matrix(mat).as_quat(), + expected_quat) + + +def test_from_matrix_calculation(): + expected_quat = np.array([1, 1, 6, 1]) / np.sqrt(39) + mat = np.array([ + [-0.8974359, -0.2564103, 0.3589744], + [0.3589744, -0.8974359, 0.2564103], + [0.2564103, 0.3589744, 0.8974359] + ]) + assert_array_almost_equal( + Rotation.from_matrix(mat).as_quat(), + expected_quat) + assert_array_almost_equal( + Rotation.from_matrix(mat.reshape((1, 3, 3))).as_quat(), + expected_quat.reshape((1, 4))) + + +def test_matrix_calculation_pipeline(): + mat = special_ortho_group.rvs(3, size=10, random_state=0) + assert_array_almost_equal(Rotation.from_matrix(mat).as_matrix(), mat) + + +def test_from_matrix_ortho_output(): + rnd = np.random.RandomState(0) + mat = rnd.random_sample((100, 3, 3)) + ortho_mat = Rotation.from_matrix(mat).as_matrix() + + mult_result = np.einsum('...ij,...jk->...ik', ortho_mat, + ortho_mat.transpose((0, 2, 1))) + + eye3d = np.zeros((100, 3, 3)) + for i in range(3): + eye3d[:, i, i] = 1.0 + + assert_array_almost_equal(mult_result, eye3d) + + +def test_from_1d_single_rotvec(): + rotvec = [1, 0, 0] + expected_quat = np.array([0.4794255, 0, 0, 0.8775826]) + result = Rotation.from_rotvec(rotvec) + assert_array_almost_equal(result.as_quat(), expected_quat) + + +def test_from_2d_single_rotvec(): + rotvec = [[1, 0, 0]] + expected_quat = np.array([[0.4794255, 0, 0, 0.8775826]]) + result = Rotation.from_rotvec(rotvec) + assert_array_almost_equal(result.as_quat(), expected_quat) + + +def test_from_generic_rotvec(): + rotvec = [ + [1, 2, 2], + [1, -1, 0.5], + [0, 0, 0] + ] + expected_quat = np.array([ + [0.3324983, 0.6649967, 0.6649967, 0.0707372], + [0.4544258, -0.4544258, 0.2272129, 0.7316889], + [0, 0, 0, 1] + ]) + assert_array_almost_equal( + Rotation.from_rotvec(rotvec).as_quat(), + expected_quat) + + +def test_from_rotvec_small_angle(): + rotvec = np.array([ + [5e-4 / np.sqrt(3), -5e-4 / np.sqrt(3), 5e-4 / np.sqrt(3)], + [0.2, 0.3, 0.4], + [0, 0, 0] + ]) + + quat = Rotation.from_rotvec(rotvec).as_quat() + # cos(theta/2) ~~ 1 for small theta + assert_allclose(quat[0, 3], 1) + # sin(theta/2) / theta ~~ 0.5 for small theta + assert_allclose(quat[0, :3], rotvec[0] * 0.5) + + assert_allclose(quat[1, 3], 0.9639685) + assert_allclose( + quat[1, :3], + np.array([ + 0.09879603932153465, + 0.14819405898230198, + 0.19759207864306931 + ])) + + assert_equal(quat[2], np.array([0, 0, 0, 1])) + + +def test_degrees_from_rotvec(): + rotvec1 = [1.0 / np.cbrt(3), 1.0 / np.cbrt(3), 1.0 / np.cbrt(3)] + rot1 = Rotation.from_rotvec(rotvec1, degrees=True) + quat1 = rot1.as_quat() + + rotvec2 = np.deg2rad(rotvec1) + rot2 = Rotation.from_rotvec(rotvec2) + quat2 = rot2.as_quat() + + assert_allclose(quat1, quat2) + + +def test_malformed_1d_from_rotvec(): + with pytest.raises(ValueError, match='Expected `rot_vec` to have shape'): + Rotation.from_rotvec([1, 2]) + + +def test_malformed_2d_from_rotvec(): + with pytest.raises(ValueError, match='Expected `rot_vec` to have shape'): + Rotation.from_rotvec([ + [1, 2, 3, 4], + [5, 6, 7, 8] + ]) + + +def test_as_generic_rotvec(): + quat = np.array([ + [1, 2, -1, 0.5], + [1, -1, 1, 0.0003], + [0, 0, 0, 1] + ]) + quat /= np.linalg.norm(quat, axis=1)[:, None] + + rotvec = Rotation.from_quat(quat).as_rotvec() + angle = np.linalg.norm(rotvec, axis=1) + + assert_allclose(quat[:, 3], np.cos(angle/2)) + assert_allclose(np.cross(rotvec, quat[:, :3]), np.zeros((3, 3))) + + +def test_as_rotvec_single_1d_input(): + quat = np.array([1, 2, -3, 2]) + expected_rotvec = np.array([0.5772381, 1.1544763, -1.7317144]) + + actual_rotvec = Rotation.from_quat(quat).as_rotvec() + + assert_equal(actual_rotvec.shape, (3,)) + assert_allclose(actual_rotvec, expected_rotvec) + + +def test_as_rotvec_single_2d_input(): + quat = np.array([[1, 2, -3, 2]]) + expected_rotvec = np.array([[0.5772381, 1.1544763, -1.7317144]]) + + actual_rotvec = Rotation.from_quat(quat).as_rotvec() + + assert_equal(actual_rotvec.shape, (1, 3)) + assert_allclose(actual_rotvec, expected_rotvec) + + +def test_as_rotvec_degrees(): + # x->y, y->z, z->x + mat = [[0, 0, 1], [1, 0, 0], [0, 1, 0]] + rot = Rotation.from_matrix(mat) + rotvec = rot.as_rotvec(degrees=True) + angle = np.linalg.norm(rotvec) + assert_allclose(angle, 120.0) + assert_allclose(rotvec[0], rotvec[1]) + assert_allclose(rotvec[1], rotvec[2]) + + +def test_rotvec_calc_pipeline(): + # Include small angles + rotvec = np.array([ + [0, 0, 0], + [1, -1, 2], + [-3e-4, 3.5e-4, 7.5e-5] + ]) + assert_allclose(Rotation.from_rotvec(rotvec).as_rotvec(), rotvec) + assert_allclose(Rotation.from_rotvec(rotvec, degrees=True).as_rotvec(degrees=True), + rotvec) + + +def test_from_1d_single_mrp(): + mrp = [0, 0, 1.0] + expected_quat = np.array([0, 0, 1, 0]) + result = Rotation.from_mrp(mrp) + assert_array_almost_equal(result.as_quat(), expected_quat) + + +def test_from_2d_single_mrp(): + mrp = [[0, 0, 1.0]] + expected_quat = np.array([[0, 0, 1, 0]]) + result = Rotation.from_mrp(mrp) + assert_array_almost_equal(result.as_quat(), expected_quat) + + +def test_from_generic_mrp(): + mrp = np.array([ + [1, 2, 2], + [1, -1, 0.5], + [0, 0, 0]]) + expected_quat = np.array([ + [0.2, 0.4, 0.4, -0.8], + [0.61538462, -0.61538462, 0.30769231, -0.38461538], + [0, 0, 0, 1]]) + assert_array_almost_equal(Rotation.from_mrp(mrp).as_quat(), expected_quat) + + +def test_malformed_1d_from_mrp(): + with pytest.raises(ValueError, match='Expected `mrp` to have shape'): + Rotation.from_mrp([1, 2]) + + +def test_malformed_2d_from_mrp(): + with pytest.raises(ValueError, match='Expected `mrp` to have shape'): + Rotation.from_mrp([ + [1, 2, 3, 4], + [5, 6, 7, 8] + ]) + + +def test_as_generic_mrp(): + quat = np.array([ + [1, 2, -1, 0.5], + [1, -1, 1, 0.0003], + [0, 0, 0, 1]]) + quat /= np.linalg.norm(quat, axis=1)[:, None] + + expected_mrp = np.array([ + [0.33333333, 0.66666667, -0.33333333], + [0.57725028, -0.57725028, 0.57725028], + [0, 0, 0]]) + assert_array_almost_equal(Rotation.from_quat(quat).as_mrp(), expected_mrp) + +def test_past_180_degree_rotation(): + # ensure that a > 180 degree rotation is returned as a <180 rotation in MRPs + # in this case 270 should be returned as -90 + expected_mrp = np.array([-np.tan(np.pi/2/4), 0.0, 0]) + assert_array_almost_equal( + Rotation.from_euler('xyz', [270, 0, 0], degrees=True).as_mrp(), + expected_mrp + ) + + +def test_as_mrp_single_1d_input(): + quat = np.array([1, 2, -3, 2]) + expected_mrp = np.array([0.16018862, 0.32037724, -0.48056586]) + + actual_mrp = Rotation.from_quat(quat).as_mrp() + + assert_equal(actual_mrp.shape, (3,)) + assert_allclose(actual_mrp, expected_mrp) + + +def test_as_mrp_single_2d_input(): + quat = np.array([[1, 2, -3, 2]]) + expected_mrp = np.array([[0.16018862, 0.32037724, -0.48056586]]) + + actual_mrp = Rotation.from_quat(quat).as_mrp() + + assert_equal(actual_mrp.shape, (1, 3)) + assert_allclose(actual_mrp, expected_mrp) + + +def test_mrp_calc_pipeline(): + actual_mrp = np.array([ + [0, 0, 0], + [1, -1, 2], + [0.41421356, 0, 0], + [0.1, 0.2, 0.1]]) + expected_mrp = np.array([ + [0, 0, 0], + [-0.16666667, 0.16666667, -0.33333333], + [0.41421356, 0, 0], + [0.1, 0.2, 0.1]]) + assert_allclose(Rotation.from_mrp(actual_mrp).as_mrp(), expected_mrp) + + +def test_from_euler_single_rotation(): + quat = Rotation.from_euler('z', 90, degrees=True).as_quat() + expected_quat = np.array([0, 0, 1, 1]) / np.sqrt(2) + assert_allclose(quat, expected_quat) + + +def test_single_intrinsic_extrinsic_rotation(): + extrinsic = Rotation.from_euler('z', 90, degrees=True).as_matrix() + intrinsic = Rotation.from_euler('Z', 90, degrees=True).as_matrix() + assert_allclose(extrinsic, intrinsic) + + +def test_from_euler_rotation_order(): + # Intrinsic rotation is same as extrinsic with order reversed + rnd = np.random.RandomState(0) + a = rnd.randint(low=0, high=180, size=(6, 3)) + b = a[:, ::-1] + x = Rotation.from_euler('xyz', a, degrees=True).as_quat() + y = Rotation.from_euler('ZYX', b, degrees=True).as_quat() + assert_allclose(x, y) + + +def test_from_euler_elementary_extrinsic_rotation(): + # Simple test to check if extrinsic rotations are implemented correctly + mat = Rotation.from_euler('zx', [90, 90], degrees=True).as_matrix() + expected_mat = np.array([ + [0, -1, 0], + [0, 0, -1], + [1, 0, 0] + ]) + assert_array_almost_equal(mat, expected_mat) + + +def test_from_euler_intrinsic_rotation_312(): + angles = [ + [30, 60, 45], + [30, 60, 30], + [45, 30, 60] + ] + mat = Rotation.from_euler('ZXY', angles, degrees=True).as_matrix() + + assert_array_almost_equal(mat[0], np.array([ + [0.3061862, -0.2500000, 0.9185587], + [0.8838835, 0.4330127, -0.1767767], + [-0.3535534, 0.8660254, 0.3535534] + ])) + + assert_array_almost_equal(mat[1], np.array([ + [0.5334936, -0.2500000, 0.8080127], + [0.8080127, 0.4330127, -0.3995191], + [-0.2500000, 0.8660254, 0.4330127] + ])) + + assert_array_almost_equal(mat[2], np.array([ + [0.0473672, -0.6123725, 0.7891491], + [0.6597396, 0.6123725, 0.4355958], + [-0.7500000, 0.5000000, 0.4330127] + ])) + + +def test_from_euler_intrinsic_rotation_313(): + angles = [ + [30, 60, 45], + [30, 60, 30], + [45, 30, 60] + ] + mat = Rotation.from_euler('ZXZ', angles, degrees=True).as_matrix() + + assert_array_almost_equal(mat[0], np.array([ + [0.43559574, -0.78914913, 0.4330127], + [0.65973961, -0.04736717, -0.750000], + [0.61237244, 0.61237244, 0.500000] + ])) + + assert_array_almost_equal(mat[1], np.array([ + [0.6250000, -0.64951905, 0.4330127], + [0.64951905, 0.1250000, -0.750000], + [0.4330127, 0.750000, 0.500000] + ])) + + assert_array_almost_equal(mat[2], np.array([ + [-0.1767767, -0.91855865, 0.35355339], + [0.88388348, -0.30618622, -0.35355339], + [0.4330127, 0.25000000, 0.8660254] + ])) + + +def test_from_euler_extrinsic_rotation_312(): + angles = [ + [30, 60, 45], + [30, 60, 30], + [45, 30, 60] + ] + mat = Rotation.from_euler('zxy', angles, degrees=True).as_matrix() + + assert_array_almost_equal(mat[0], np.array([ + [0.91855865, 0.1767767, 0.35355339], + [0.25000000, 0.4330127, -0.8660254], + [-0.30618622, 0.88388348, 0.35355339] + ])) + + assert_array_almost_equal(mat[1], np.array([ + [0.96650635, -0.0580127, 0.2500000], + [0.25000000, 0.4330127, -0.8660254], + [-0.0580127, 0.89951905, 0.4330127] + ])) + + assert_array_almost_equal(mat[2], np.array([ + [0.65973961, -0.04736717, 0.7500000], + [0.61237244, 0.61237244, -0.5000000], + [-0.43559574, 0.78914913, 0.4330127] + ])) + + +def test_from_euler_extrinsic_rotation_313(): + angles = [ + [30, 60, 45], + [30, 60, 30], + [45, 30, 60] + ] + mat = Rotation.from_euler('zxz', angles, degrees=True).as_matrix() + + assert_array_almost_equal(mat[0], np.array([ + [0.43559574, -0.65973961, 0.61237244], + [0.78914913, -0.04736717, -0.61237244], + [0.4330127, 0.75000000, 0.500000] + ])) + + assert_array_almost_equal(mat[1], np.array([ + [0.62500000, -0.64951905, 0.4330127], + [0.64951905, 0.12500000, -0.750000], + [0.4330127, 0.75000000, 0.500000] + ])) + + assert_array_almost_equal(mat[2], np.array([ + [-0.1767767, -0.88388348, 0.4330127], + [0.91855865, -0.30618622, -0.250000], + [0.35355339, 0.35355339, 0.8660254] + ])) + + +@pytest.mark.parametrize("seq_tuple", permutations("xyz")) +@pytest.mark.parametrize("intrinsic", (False, True)) +def test_as_euler_asymmetric_axes(seq_tuple, intrinsic): + # helper function for mean error tests + def test_stats(error, mean_max, rms_max): + mean = np.mean(error, axis=0) + std = np.std(error, axis=0) + rms = np.hypot(mean, std) + assert np.all(np.abs(mean) < mean_max) + assert np.all(rms < rms_max) + + rnd = np.random.RandomState(0) + n = 1000 + angles = np.empty((n, 3)) + angles[:, 0] = rnd.uniform(low=-np.pi, high=np.pi, size=(n,)) + angles[:, 1] = rnd.uniform(low=-np.pi / 2, high=np.pi / 2, size=(n,)) + angles[:, 2] = rnd.uniform(low=-np.pi, high=np.pi, size=(n,)) + + seq = "".join(seq_tuple) + if intrinsic: + # Extrinsic rotation (wrt to global world) at lower case + # intrinsinc (WRT the object itself) lower case. + seq = seq.upper() + rotation = Rotation.from_euler(seq, angles) + angles_quat = rotation.as_euler(seq) + angles_mat = rotation._as_euler_from_matrix(seq) + assert_allclose(angles, angles_quat, atol=0, rtol=1e-12) + assert_allclose(angles, angles_mat, atol=0, rtol=1e-12) + test_stats(angles_quat - angles, 1e-15, 1e-14) + test_stats(angles_mat - angles, 1e-15, 1e-14) + + + +@pytest.mark.parametrize("seq_tuple", permutations("xyz")) +@pytest.mark.parametrize("intrinsic", (False, True)) +def test_as_euler_symmetric_axes(seq_tuple, intrinsic): + # helper function for mean error tests + def test_stats(error, mean_max, rms_max): + mean = np.mean(error, axis=0) + std = np.std(error, axis=0) + rms = np.hypot(mean, std) + assert np.all(np.abs(mean) < mean_max) + assert np.all(rms < rms_max) + + rnd = np.random.RandomState(0) + n = 1000 + angles = np.empty((n, 3)) + angles[:, 0] = rnd.uniform(low=-np.pi, high=np.pi, size=(n,)) + angles[:, 1] = rnd.uniform(low=0, high=np.pi, size=(n,)) + angles[:, 2] = rnd.uniform(low=-np.pi, high=np.pi, size=(n,)) + + # Rotation of the form A/B/A are rotation around symmetric axes + seq = "".join([seq_tuple[0], seq_tuple[1], seq_tuple[0]]) + if intrinsic: + seq = seq.upper() + rotation = Rotation.from_euler(seq, angles) + angles_quat = rotation.as_euler(seq) + angles_mat = rotation._as_euler_from_matrix(seq) + assert_allclose(angles, angles_quat, atol=0, rtol=1e-13) + assert_allclose(angles, angles_mat, atol=0, rtol=1e-9) + test_stats(angles_quat - angles, 1e-16, 1e-14) + test_stats(angles_mat - angles, 1e-15, 1e-13) + + +@pytest.mark.parametrize("seq_tuple", permutations("xyz")) +@pytest.mark.parametrize("intrinsic", (False, True)) +def test_as_euler_degenerate_asymmetric_axes(seq_tuple, intrinsic): + # Since we cannot check for angle equality, we check for rotation matrix + # equality + angles = np.array([ + [45, 90, 35], + [35, -90, 20], + [35, 90, 25], + [25, -90, 15]]) + + seq = "".join(seq_tuple) + if intrinsic: + # Extrinsic rotation (wrt to global world) at lower case + # Intrinsic (WRT the object itself) upper case. + seq = seq.upper() + rotation = Rotation.from_euler(seq, angles, degrees=True) + mat_expected = rotation.as_matrix() + + with pytest.warns(UserWarning, match="Gimbal lock"): + angle_estimates = rotation.as_euler(seq, degrees=True) + mat_estimated = Rotation.from_euler(seq, angle_estimates, degrees=True).as_matrix() + + assert_array_almost_equal(mat_expected, mat_estimated) + + +@pytest.mark.parametrize("seq_tuple", permutations("xyz")) +@pytest.mark.parametrize("intrinsic", (False, True)) +def test_as_euler_degenerate_symmetric_axes(seq_tuple, intrinsic): + # Since we cannot check for angle equality, we check for rotation matrix + # equality + angles = np.array([ + [15, 0, 60], + [35, 0, 75], + [60, 180, 35], + [15, -180, 25]]) + + # Rotation of the form A/B/A are rotation around symmetric axes + seq = "".join([seq_tuple[0], seq_tuple[1], seq_tuple[0]]) + if intrinsic: + # Extrinsic rotation (wrt to global world) at lower case + # Intrinsic (WRT the object itself) upper case. + seq = seq.upper() + rotation = Rotation.from_euler(seq, angles, degrees=True) + mat_expected = rotation.as_matrix() + + with pytest.warns(UserWarning, match="Gimbal lock"): + angle_estimates = rotation.as_euler(seq, degrees=True) + mat_estimated = Rotation.from_euler(seq, angle_estimates, degrees=True).as_matrix() + + assert_array_almost_equal(mat_expected, mat_estimated) + + +@pytest.mark.parametrize("seq_tuple", permutations("xyz")) +@pytest.mark.parametrize("intrinsic", (False, True)) +def test_as_euler_degenerate_compare_algorithms(seq_tuple, intrinsic): + # this test makes sure that both algorithms are doing the same choices + # in degenerate cases + + # asymmetric axes + angles = np.array([ + [45, 90, 35], + [35, -90, 20], + [35, 90, 25], + [25, -90, 15]]) + + seq = "".join(seq_tuple) + if intrinsic: + # Extrinsic rotation (wrt to global world at lower case + # Intrinsic (WRT the object itself) upper case. + seq = seq.upper() + + rot = Rotation.from_euler(seq, angles, degrees=True) + with pytest.warns(UserWarning, match="Gimbal lock"): + estimates_matrix = rot._as_euler_from_matrix(seq, degrees=True) + with pytest.warns(UserWarning, match="Gimbal lock"): + estimates_quat = rot.as_euler(seq, degrees=True) + assert_allclose( + estimates_matrix[:, [0, 2]], estimates_quat[:, [0, 2]], atol=0, rtol=1e-12 + ) + assert_allclose(estimates_matrix[:, 1], estimates_quat[:, 1], atol=0, rtol=1e-7) + + # symmetric axes + # Absolute error tolerance must be looser to directly compare the results + # from both algorithms, because of numerical loss of precision for the + # method _as_euler_from_matrix near a zero angle value + + angles = np.array([ + [15, 0, 60], + [35, 0, 75], + [60, 180, 35], + [15, -180, 25]]) + + idx = angles[:, 1] == 0 # find problematic angles indices + + # Rotation of the form A/B/A are rotation around symmetric axes + seq = "".join([seq_tuple[0], seq_tuple[1], seq_tuple[0]]) + if intrinsic: + # Extrinsinc rotation (wrt to global world) at lower case + # Intrinsic (WRT the object itself) upper case. + seq = seq.upper() + + rot = Rotation.from_euler(seq, angles, degrees=True) + with pytest.warns(UserWarning, match="Gimbal lock"): + estimates_matrix = rot._as_euler_from_matrix(seq, degrees=True) + with pytest.warns(UserWarning, match="Gimbal lock"): + estimates_quat = rot.as_euler(seq, degrees=True) + assert_allclose( + estimates_matrix[:, [0, 2]], estimates_quat[:, [0, 2]], atol=0, rtol=1e-12 + ) + + assert_allclose( + estimates_matrix[~idx, 1], estimates_quat[~idx, 1], atol=0, rtol=1e-7 + ) + + assert_allclose( + estimates_matrix[idx, 1], estimates_quat[idx, 1], atol=1e-6 + ) # problematic, angles[1] = 0 + + +def test_inv(): + rnd = np.random.RandomState(0) + n = 10 + p = Rotation.random(num=n, random_state=rnd) + q = p.inv() + + p_mat = p.as_matrix() + q_mat = q.as_matrix() + result1 = np.einsum('...ij,...jk->...ik', p_mat, q_mat) + result2 = np.einsum('...ij,...jk->...ik', q_mat, p_mat) + + eye3d = np.empty((n, 3, 3)) + eye3d[:] = np.eye(3) + + assert_array_almost_equal(result1, eye3d) + assert_array_almost_equal(result2, eye3d) + + +def test_inv_single_rotation(): + rnd = np.random.RandomState(0) + p = Rotation.random(random_state=rnd) + q = p.inv() + + p_mat = p.as_matrix() + q_mat = q.as_matrix() + res1 = np.dot(p_mat, q_mat) + res2 = np.dot(q_mat, p_mat) + + eye = np.eye(3) + + assert_array_almost_equal(res1, eye) + assert_array_almost_equal(res2, eye) + + x = Rotation.random(num=1, random_state=rnd) + y = x.inv() + + x_matrix = x.as_matrix() + y_matrix = y.as_matrix() + result1 = np.einsum('...ij,...jk->...ik', x_matrix, y_matrix) + result2 = np.einsum('...ij,...jk->...ik', y_matrix, x_matrix) + + eye3d = np.empty((1, 3, 3)) + eye3d[:] = np.eye(3) + + assert_array_almost_equal(result1, eye3d) + assert_array_almost_equal(result2, eye3d) + + +def test_identity_magnitude(): + n = 10 + assert_allclose(Rotation.identity(n).magnitude(), 0) + assert_allclose(Rotation.identity(n).inv().magnitude(), 0) + + +def test_single_identity_magnitude(): + assert Rotation.identity().magnitude() == 0 + assert Rotation.identity().inv().magnitude() == 0 + + +def test_identity_invariance(): + n = 10 + p = Rotation.random(n, random_state=0) + + result = p * Rotation.identity(n) + assert_array_almost_equal(p.as_quat(), result.as_quat()) + + result = result * p.inv() + assert_array_almost_equal(result.magnitude(), np.zeros(n)) + + +def test_single_identity_invariance(): + n = 10 + p = Rotation.random(n, random_state=0) + + result = p * Rotation.identity() + assert_array_almost_equal(p.as_quat(), result.as_quat()) + + result = result * p.inv() + assert_array_almost_equal(result.magnitude(), np.zeros(n)) + + +def test_magnitude(): + r = Rotation.from_quat(np.eye(4)) + result = r.magnitude() + assert_array_almost_equal(result, [np.pi, np.pi, np.pi, 0]) + + r = Rotation.from_quat(-np.eye(4)) + result = r.magnitude() + assert_array_almost_equal(result, [np.pi, np.pi, np.pi, 0]) + + +def test_magnitude_single_rotation(): + r = Rotation.from_quat(np.eye(4)) + result1 = r[0].magnitude() + assert_allclose(result1, np.pi) + + result2 = r[3].magnitude() + assert_allclose(result2, 0) + + +def test_approx_equal(): + rng = np.random.RandomState(0) + p = Rotation.random(10, random_state=rng) + q = Rotation.random(10, random_state=rng) + r = p * q.inv() + r_mag = r.magnitude() + atol = np.median(r_mag) # ensure we get mix of Trues and Falses + assert_equal(p.approx_equal(q, atol), (r_mag < atol)) + + +def test_approx_equal_single_rotation(): + # also tests passing single argument to approx_equal + p = Rotation.from_rotvec([0, 0, 1e-9]) # less than default atol of 1e-8 + q = Rotation.from_quat(np.eye(4)) + assert p.approx_equal(q[3]) + assert not p.approx_equal(q[0]) + + # test passing atol and using degrees + assert not p.approx_equal(q[3], atol=1e-10) + assert not p.approx_equal(q[3], atol=1e-8, degrees=True) + with pytest.warns(UserWarning, match="atol must be set"): + assert p.approx_equal(q[3], degrees=True) + + +def test_mean(): + axes = np.concatenate((-np.eye(3), np.eye(3))) + thetas = np.linspace(0, np.pi / 2, 100) + for t in thetas: + r = Rotation.from_rotvec(t * axes) + assert_allclose(r.mean().magnitude(), 0, atol=1E-10) + + +def test_weighted_mean(): + # test that doubling a weight is equivalent to including a rotation twice. + axes = np.array([[0, 0, 0], [1, 0, 0], [1, 0, 0]]) + thetas = np.linspace(0, np.pi / 2, 100) + for t in thetas: + rw = Rotation.from_rotvec(t * axes[:2]) + mw = rw.mean(weights=[1, 2]) + + r = Rotation.from_rotvec(t * axes) + m = r.mean() + assert_allclose((m * mw.inv()).magnitude(), 0, atol=1E-10) + + +def test_mean_invalid_weights(): + with pytest.raises(ValueError, match="non-negative"): + r = Rotation.from_quat(np.eye(4)) + r.mean(weights=-np.ones(4)) + + +def test_reduction_no_indices(): + result = Rotation.identity().reduce(return_indices=False) + assert isinstance(result, Rotation) + + +def test_reduction_none_indices(): + result = Rotation.identity().reduce(return_indices=True) + assert type(result) == tuple + assert len(result) == 3 + + reduced, left_best, right_best = result + assert left_best is None + assert right_best is None + + +def test_reduction_scalar_calculation(): + rng = np.random.RandomState(0) + l = Rotation.random(5, random_state=rng) + r = Rotation.random(10, random_state=rng) + p = Rotation.random(7, random_state=rng) + reduced, left_best, right_best = p.reduce(l, r, return_indices=True) + + # Loop implementation of the vectorized calculation in Rotation.reduce + scalars = np.zeros((len(l), len(p), len(r))) + for i, li in enumerate(l): + for j, pj in enumerate(p): + for k, rk in enumerate(r): + scalars[i, j, k] = np.abs((li * pj * rk).as_quat()[3]) + scalars = np.reshape(np.moveaxis(scalars, 1, 0), (scalars.shape[1], -1)) + + max_ind = np.argmax(np.reshape(scalars, (len(p), -1)), axis=1) + left_best_check = max_ind // len(r) + right_best_check = max_ind % len(r) + assert (left_best == left_best_check).all() + assert (right_best == right_best_check).all() + + reduced_check = l[left_best_check] * p * r[right_best_check] + mag = (reduced.inv() * reduced_check).magnitude() + assert_array_almost_equal(mag, np.zeros(len(p))) + + +def test_apply_single_rotation_single_point(): + mat = np.array([ + [0, -1, 0], + [1, 0, 0], + [0, 0, 1] + ]) + r_1d = Rotation.from_matrix(mat) + r_2d = Rotation.from_matrix(np.expand_dims(mat, axis=0)) + + v_1d = np.array([1, 2, 3]) + v_2d = np.expand_dims(v_1d, axis=0) + v1d_rotated = np.array([-2, 1, 3]) + v2d_rotated = np.expand_dims(v1d_rotated, axis=0) + + assert_allclose(r_1d.apply(v_1d), v1d_rotated) + assert_allclose(r_1d.apply(v_2d), v2d_rotated) + assert_allclose(r_2d.apply(v_1d), v2d_rotated) + assert_allclose(r_2d.apply(v_2d), v2d_rotated) + + v1d_inverse = np.array([2, -1, 3]) + v2d_inverse = np.expand_dims(v1d_inverse, axis=0) + + assert_allclose(r_1d.apply(v_1d, inverse=True), v1d_inverse) + assert_allclose(r_1d.apply(v_2d, inverse=True), v2d_inverse) + assert_allclose(r_2d.apply(v_1d, inverse=True), v2d_inverse) + assert_allclose(r_2d.apply(v_2d, inverse=True), v2d_inverse) + + +def test_apply_single_rotation_multiple_points(): + mat = np.array([ + [0, -1, 0], + [1, 0, 0], + [0, 0, 1] + ]) + r1 = Rotation.from_matrix(mat) + r2 = Rotation.from_matrix(np.expand_dims(mat, axis=0)) + + v = np.array([[1, 2, 3], [4, 5, 6]]) + v_rotated = np.array([[-2, 1, 3], [-5, 4, 6]]) + + assert_allclose(r1.apply(v), v_rotated) + assert_allclose(r2.apply(v), v_rotated) + + v_inverse = np.array([[2, -1, 3], [5, -4, 6]]) + + assert_allclose(r1.apply(v, inverse=True), v_inverse) + assert_allclose(r2.apply(v, inverse=True), v_inverse) + + +def test_apply_multiple_rotations_single_point(): + mat = np.empty((2, 3, 3)) + mat[0] = np.array([ + [0, -1, 0], + [1, 0, 0], + [0, 0, 1] + ]) + mat[1] = np.array([ + [1, 0, 0], + [0, 0, -1], + [0, 1, 0] + ]) + r = Rotation.from_matrix(mat) + + v1 = np.array([1, 2, 3]) + v2 = np.expand_dims(v1, axis=0) + + v_rotated = np.array([[-2, 1, 3], [1, -3, 2]]) + + assert_allclose(r.apply(v1), v_rotated) + assert_allclose(r.apply(v2), v_rotated) + + v_inverse = np.array([[2, -1, 3], [1, 3, -2]]) + + assert_allclose(r.apply(v1, inverse=True), v_inverse) + assert_allclose(r.apply(v2, inverse=True), v_inverse) + + +def test_apply_multiple_rotations_multiple_points(): + mat = np.empty((2, 3, 3)) + mat[0] = np.array([ + [0, -1, 0], + [1, 0, 0], + [0, 0, 1] + ]) + mat[1] = np.array([ + [1, 0, 0], + [0, 0, -1], + [0, 1, 0] + ]) + r = Rotation.from_matrix(mat) + + v = np.array([[1, 2, 3], [4, 5, 6]]) + v_rotated = np.array([[-2, 1, 3], [4, -6, 5]]) + assert_allclose(r.apply(v), v_rotated) + + v_inverse = np.array([[2, -1, 3], [4, 6, -5]]) + assert_allclose(r.apply(v, inverse=True), v_inverse) + + +def test_getitem(): + mat = np.empty((2, 3, 3)) + mat[0] = np.array([ + [0, -1, 0], + [1, 0, 0], + [0, 0, 1] + ]) + mat[1] = np.array([ + [1, 0, 0], + [0, 0, -1], + [0, 1, 0] + ]) + r = Rotation.from_matrix(mat) + + assert_allclose(r[0].as_matrix(), mat[0], atol=1e-15) + assert_allclose(r[1].as_matrix(), mat[1], atol=1e-15) + assert_allclose(r[:-1].as_matrix(), np.expand_dims(mat[0], axis=0), atol=1e-15) + + +def test_getitem_single(): + with pytest.raises(TypeError, match='not subscriptable'): + Rotation.identity()[0] + + +def test_setitem_single(): + r = Rotation.identity() + with pytest.raises(TypeError, match='not subscriptable'): + r[0] = Rotation.identity() + + +def test_setitem_slice(): + rng = np.random.RandomState(seed=0) + r1 = Rotation.random(10, random_state=rng) + r2 = Rotation.random(5, random_state=rng) + r1[1:6] = r2 + assert_equal(r1[1:6].as_quat(), r2.as_quat()) + + +def test_setitem_integer(): + rng = np.random.RandomState(seed=0) + r1 = Rotation.random(10, random_state=rng) + r2 = Rotation.random(random_state=rng) + r1[1] = r2 + assert_equal(r1[1].as_quat(), r2.as_quat()) + + +def test_setitem_wrong_type(): + r = Rotation.random(10, random_state=0) + with pytest.raises(TypeError, match='Rotation object'): + r[0] = 1 + + +def test_n_rotations(): + mat = np.empty((2, 3, 3)) + mat[0] = np.array([ + [0, -1, 0], + [1, 0, 0], + [0, 0, 1] + ]) + mat[1] = np.array([ + [1, 0, 0], + [0, 0, -1], + [0, 1, 0] + ]) + r = Rotation.from_matrix(mat) + + assert_equal(len(r), 2) + assert_equal(len(r[:-1]), 1) + + +def test_random_rotation_shape(): + rnd = np.random.RandomState(0) + assert_equal(Rotation.random(random_state=rnd).as_quat().shape, (4,)) + assert_equal(Rotation.random(None, random_state=rnd).as_quat().shape, (4,)) + + assert_equal(Rotation.random(1, random_state=rnd).as_quat().shape, (1, 4)) + assert_equal(Rotation.random(5, random_state=rnd).as_quat().shape, (5, 4)) + + +def test_align_vectors_no_rotation(): + x = np.array([[1, 2, 3], [4, 5, 6]]) + y = x.copy() + + r, rssd = Rotation.align_vectors(x, y) + assert_array_almost_equal(r.as_matrix(), np.eye(3)) + assert_allclose(rssd, 0, atol=1e-6) + + +def test_align_vectors_no_noise(): + rnd = np.random.RandomState(0) + c = Rotation.random(random_state=rnd) + b = rnd.normal(size=(5, 3)) + a = c.apply(b) + + est, rssd = Rotation.align_vectors(a, b) + assert_allclose(c.as_quat(), est.as_quat()) + assert_allclose(rssd, 0, atol=1e-7) + + +def test_align_vectors_improper_rotation(): + # Tests correct logic for issue #10444 + x = np.array([[0.89299824, -0.44372674, 0.0752378], + [0.60221789, -0.47564102, -0.6411702]]) + y = np.array([[0.02386536, -0.82176463, 0.5693271], + [-0.27654929, -0.95191427, -0.1318321]]) + + est, rssd = Rotation.align_vectors(x, y) + assert_allclose(x, est.apply(y), atol=1e-6) + assert_allclose(rssd, 0, atol=1e-7) + + +def test_align_vectors_rssd_sensitivity(): + rssd_expected = 0.141421356237308 + sens_expected = np.array([[0.2, 0. , 0.], + [0. , 1.5, 1.], + [0. , 1. , 1.]]) + atol = 1e-6 + a = [[0, 1, 0], [0, 1, 1], [0, 1, 1]] + b = [[1, 0, 0], [1, 1.1, 0], [1, 0.9, 0]] + rot, rssd, sens = Rotation.align_vectors(a, b, return_sensitivity=True) + assert np.isclose(rssd, rssd_expected, atol=atol) + assert np.allclose(sens, sens_expected, atol=atol) + + +def test_align_vectors_scaled_weights(): + n = 10 + a = Rotation.random(n, random_state=0).apply([1, 0, 0]) + b = Rotation.random(n, random_state=1).apply([1, 0, 0]) + scale = 2 + + est1, rssd1, cov1 = Rotation.align_vectors(a, b, np.ones(n), True) + est2, rssd2, cov2 = Rotation.align_vectors(a, b, scale * np.ones(n), True) + + assert_allclose(est1.as_matrix(), est2.as_matrix()) + assert_allclose(np.sqrt(scale) * rssd1, rssd2, atol=1e-6) + assert_allclose(cov1, cov2) + + +def test_align_vectors_noise(): + rnd = np.random.RandomState(0) + n_vectors = 100 + rot = Rotation.random(random_state=rnd) + vectors = rnd.normal(size=(n_vectors, 3)) + result = rot.apply(vectors) + + # The paper adds noise as independently distributed angular errors + sigma = np.deg2rad(1) + tolerance = 1.5 * sigma + noise = Rotation.from_rotvec( + rnd.normal( + size=(n_vectors, 3), + scale=sigma + ) + ) + + # Attitude errors must preserve norm. Hence apply individual random + # rotations to each vector. + noisy_result = noise.apply(result) + + est, rssd, cov = Rotation.align_vectors(noisy_result, vectors, + return_sensitivity=True) + + # Use rotation compositions to find out closeness + error_vector = (rot * est.inv()).as_rotvec() + assert_allclose(error_vector[0], 0, atol=tolerance) + assert_allclose(error_vector[1], 0, atol=tolerance) + assert_allclose(error_vector[2], 0, atol=tolerance) + + # Check error bounds using covariance matrix + cov *= sigma + assert_allclose(cov[0, 0], 0, atol=tolerance) + assert_allclose(cov[1, 1], 0, atol=tolerance) + assert_allclose(cov[2, 2], 0, atol=tolerance) + + assert_allclose(rssd, np.sum((noisy_result - est.apply(vectors))**2)**0.5) + + +def test_align_vectors_invalid_input(): + with pytest.raises(ValueError, match="Expected input `a` to have shape"): + Rotation.align_vectors([1, 2, 3, 4], [1, 2, 3]) + + with pytest.raises(ValueError, match="Expected input `b` to have shape"): + Rotation.align_vectors([1, 2, 3], [1, 2, 3, 4]) + + with pytest.raises(ValueError, match="Expected inputs `a` and `b` " + "to have same shapes"): + Rotation.align_vectors([[1, 2, 3],[4, 5, 6]], [[1, 2, 3]]) + + with pytest.raises(ValueError, + match="Expected `weights` to be 1 dimensional"): + Rotation.align_vectors([[1, 2, 3]], [[1, 2, 3]], weights=[[1]]) + + with pytest.raises(ValueError, + match="Expected `weights` to have number of values"): + Rotation.align_vectors([[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]], + weights=[1, 2, 3]) + + with pytest.raises(ValueError, + match="`weights` may not contain negative values"): + Rotation.align_vectors([[1, 2, 3]], [[1, 2, 3]], weights=[-1]) + + with pytest.raises(ValueError, + match="Only one infinite weight is allowed"): + Rotation.align_vectors([[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]], + weights=[np.inf, np.inf]) + + with pytest.raises(ValueError, + match="Cannot align zero length primary vectors"): + Rotation.align_vectors([[0, 0, 0]], [[1, 2, 3]]) + + with pytest.raises(ValueError, + match="Cannot return sensitivity matrix"): + Rotation.align_vectors([[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]], + return_sensitivity=True, weights=[np.inf, 1]) + + with pytest.raises(ValueError, + match="Cannot return sensitivity matrix"): + Rotation.align_vectors([[1, 2, 3]], [[1, 2, 3]], + return_sensitivity=True) + + +def test_align_vectors_align_constrain(): + # Align the primary +X B axis with the primary +Y A axis, and rotate about + # it such that the +Y B axis (residual of the [1, 1, 0] secondary b vector) + # is aligned with the +Z A axis (residual of the [0, 1, 1] secondary a + # vector) + atol = 1e-12 + b = [[1, 0, 0], [1, 1, 0]] + a = [[0, 1, 0], [0, 1, 1]] + m_expected = np.array([[0, 0, 1], + [1, 0, 0], + [0, 1, 0]]) + R, rssd = Rotation.align_vectors(a, b, weights=[np.inf, 1]) + assert_allclose(R.as_matrix(), m_expected, atol=atol) + assert_allclose(R.apply(b), a, atol=atol) # Pri and sec align exactly + assert np.isclose(rssd, 0, atol=atol) + + # Do the same but with an inexact secondary rotation + b = [[1, 0, 0], [1, 2, 0]] + rssd_expected = 1.0 + R, rssd = Rotation.align_vectors(a, b, weights=[np.inf, 1]) + assert_allclose(R.as_matrix(), m_expected, atol=atol) + assert_allclose(R.apply(b)[0], a[0], atol=atol) # Only pri aligns exactly + assert np.isclose(rssd, rssd_expected, atol=atol) + a_expected = [[0, 1, 0], [0, 1, 2]] + assert_allclose(R.apply(b), a_expected, atol=atol) + + # Check random vectors + b = [[1, 2, 3], [-2, 3, -1]] + a = [[-1, 3, 2], [1, -1, 2]] + rssd_expected = 1.3101595297515016 + R, rssd = Rotation.align_vectors(a, b, weights=[np.inf, 1]) + assert_allclose(R.apply(b)[0], a[0], atol=atol) # Only pri aligns exactly + assert np.isclose(rssd, rssd_expected, atol=atol) + + +def test_align_vectors_near_inf(): + # align_vectors should return near the same result for high weights as for + # infinite weights. rssd will be different with floating point error on the + # exactly aligned vector being multiplied by a large non-infinite weight + n = 100 + mats = [] + for i in range(6): + mats.append(Rotation.random(n, random_state=10 + i).as_matrix()) + + for i in range(n): + # Get random pairs of 3-element vectors + a = [1*mats[0][i][0], 2*mats[1][i][0]] + b = [3*mats[2][i][0], 4*mats[3][i][0]] + + R, _ = Rotation.align_vectors(a, b, weights=[1e10, 1]) + R2, _ = Rotation.align_vectors(a, b, weights=[np.inf, 1]) + assert_allclose(R.as_matrix(), R2.as_matrix(), atol=1e-4) + + for i in range(n): + # Get random triplets of 3-element vectors + a = [1*mats[0][i][0], 2*mats[1][i][0], 3*mats[2][i][0]] + b = [4*mats[3][i][0], 5*mats[4][i][0], 6*mats[5][i][0]] + + R, _ = Rotation.align_vectors(a, b, weights=[1e10, 2, 1]) + R2, _ = Rotation.align_vectors(a, b, weights=[np.inf, 2, 1]) + assert_allclose(R.as_matrix(), R2.as_matrix(), atol=1e-4) + + +def test_align_vectors_parallel(): + atol = 1e-12 + a = [[1, 0, 0], [0, 1, 0]] + b = [[0, 1, 0], [0, 1, 0]] + m_expected = np.array([[0, 1, 0], + [-1, 0, 0], + [0, 0, 1]]) + R, _ = Rotation.align_vectors(a, b, weights=[np.inf, 1]) + assert_allclose(R.as_matrix(), m_expected, atol=atol) + R, _ = Rotation.align_vectors(a[0], b[0]) + assert_allclose(R.as_matrix(), m_expected, atol=atol) + assert_allclose(R.apply(b[0]), a[0], atol=atol) + + b = [[1, 0, 0], [1, 0, 0]] + m_expected = np.array([[1, 0, 0], + [0, 1, 0], + [0, 0, 1]]) + R, _ = Rotation.align_vectors(a, b, weights=[np.inf, 1]) + assert_allclose(R.as_matrix(), m_expected, atol=atol) + R, _ = Rotation.align_vectors(a[0], b[0]) + assert_allclose(R.as_matrix(), m_expected, atol=atol) + assert_allclose(R.apply(b[0]), a[0], atol=atol) + + +def test_align_vectors_primary_only(): + atol = 1e-12 + mats_a = Rotation.random(100, random_state=0).as_matrix() + mats_b = Rotation.random(100, random_state=1).as_matrix() + for mat_a, mat_b in zip(mats_a, mats_b): + # Get random 3-element unit vectors + a = mat_a[0] + b = mat_b[0] + + # Compare to align_vectors with primary only + R, rssd = Rotation.align_vectors(a, b) + assert_allclose(R.apply(b), a, atol=atol) + assert np.isclose(rssd, 0, atol=atol) + + +def test_slerp(): + rnd = np.random.RandomState(0) + + key_rots = Rotation.from_quat(rnd.uniform(size=(5, 4))) + key_quats = key_rots.as_quat() + + key_times = [0, 1, 2, 3, 4] + interpolator = Slerp(key_times, key_rots) + + times = [0, 0.5, 0.25, 1, 1.5, 2, 2.75, 3, 3.25, 3.60, 4] + interp_rots = interpolator(times) + interp_quats = interp_rots.as_quat() + + # Dot products are affected by sign of quaternions + interp_quats[interp_quats[:, -1] < 0] *= -1 + # Checking for quaternion equality, perform same operation + key_quats[key_quats[:, -1] < 0] *= -1 + + # Equality at keyframes, including both endpoints + assert_allclose(interp_quats[0], key_quats[0]) + assert_allclose(interp_quats[3], key_quats[1]) + assert_allclose(interp_quats[5], key_quats[2]) + assert_allclose(interp_quats[7], key_quats[3]) + assert_allclose(interp_quats[10], key_quats[4]) + + # Constant angular velocity between keyframes. Check by equating + # cos(theta) between quaternion pairs with equal time difference. + cos_theta1 = np.sum(interp_quats[0] * interp_quats[2]) + cos_theta2 = np.sum(interp_quats[2] * interp_quats[1]) + assert_allclose(cos_theta1, cos_theta2) + + cos_theta4 = np.sum(interp_quats[3] * interp_quats[4]) + cos_theta5 = np.sum(interp_quats[4] * interp_quats[5]) + assert_allclose(cos_theta4, cos_theta5) + + # theta1: 0 -> 0.25, theta3 : 0.5 -> 1 + # Use double angle formula for double the time difference + cos_theta3 = np.sum(interp_quats[1] * interp_quats[3]) + assert_allclose(cos_theta3, 2 * (cos_theta1**2) - 1) + + # Miscellaneous checks + assert_equal(len(interp_rots), len(times)) + + +def test_slerp_rot_is_rotation(): + with pytest.raises(TypeError, match="must be a `Rotation` instance"): + r = np.array([[1,2,3,4], + [0,0,0,1]]) + t = np.array([0, 1]) + Slerp(t, r) + + +def test_slerp_single_rot(): + msg = "must be a sequence of at least 2 rotations" + with pytest.raises(ValueError, match=msg): + r = Rotation.from_quat([1, 2, 3, 4]) + Slerp([1], r) + + +def test_slerp_rot_len1(): + msg = "must be a sequence of at least 2 rotations" + with pytest.raises(ValueError, match=msg): + r = Rotation.from_quat([[1, 2, 3, 4]]) + Slerp([1], r) + + +def test_slerp_time_dim_mismatch(): + with pytest.raises(ValueError, + match="times to be specified in a 1 dimensional array"): + rnd = np.random.RandomState(0) + r = Rotation.from_quat(rnd.uniform(size=(2, 4))) + t = np.array([[1], + [2]]) + Slerp(t, r) + + +def test_slerp_num_rotations_mismatch(): + with pytest.raises(ValueError, match="number of rotations to be equal to " + "number of timestamps"): + rnd = np.random.RandomState(0) + r = Rotation.from_quat(rnd.uniform(size=(5, 4))) + t = np.arange(7) + Slerp(t, r) + + +def test_slerp_equal_times(): + with pytest.raises(ValueError, match="strictly increasing order"): + rnd = np.random.RandomState(0) + r = Rotation.from_quat(rnd.uniform(size=(5, 4))) + t = [0, 1, 2, 2, 4] + Slerp(t, r) + + +def test_slerp_decreasing_times(): + with pytest.raises(ValueError, match="strictly increasing order"): + rnd = np.random.RandomState(0) + r = Rotation.from_quat(rnd.uniform(size=(5, 4))) + t = [0, 1, 3, 2, 4] + Slerp(t, r) + + +def test_slerp_call_time_dim_mismatch(): + rnd = np.random.RandomState(0) + r = Rotation.from_quat(rnd.uniform(size=(5, 4))) + t = np.arange(5) + s = Slerp(t, r) + + with pytest.raises(ValueError, + match="`times` must be at most 1-dimensional."): + interp_times = np.array([[3.5], + [4.2]]) + s(interp_times) + + +def test_slerp_call_time_out_of_range(): + rnd = np.random.RandomState(0) + r = Rotation.from_quat(rnd.uniform(size=(5, 4))) + t = np.arange(5) + 1 + s = Slerp(t, r) + + with pytest.raises(ValueError, match="times must be within the range"): + s([0, 1, 2]) + with pytest.raises(ValueError, match="times must be within the range"): + s([1, 2, 6]) + + +def test_slerp_call_scalar_time(): + r = Rotation.from_euler('X', [0, 80], degrees=True) + s = Slerp([0, 1], r) + + r_interpolated = s(0.25) + r_interpolated_expected = Rotation.from_euler('X', 20, degrees=True) + + delta = r_interpolated * r_interpolated_expected.inv() + + assert_allclose(delta.magnitude(), 0, atol=1e-16) + + +def test_multiplication_stability(): + qs = Rotation.random(50, random_state=0) + rs = Rotation.random(1000, random_state=1) + for q in qs: + rs *= q * rs + assert_allclose(np.linalg.norm(rs.as_quat(), axis=1), 1) + + +def test_pow(): + atol = 1e-14 + p = Rotation.random(10, random_state=0) + p_inv = p.inv() + # Test the short-cuts and other integers + for n in [-5, -2, -1, 0, 1, 2, 5]: + # Test accuracy + q = p ** n + r = Rotation.identity(10) + for _ in range(abs(n)): + if n > 0: + r = r * p + else: + r = r * p_inv + ang = (q * r.inv()).magnitude() + assert np.all(ang < atol) + + # Test shape preservation + r = Rotation.from_quat([0, 0, 0, 1]) + assert (r**n).as_quat().shape == (4,) + r = Rotation.from_quat([[0, 0, 0, 1]]) + assert (r**n).as_quat().shape == (1, 4) + + # Large angle fractional + for n in [-1.5, -0.5, -0.0, 0.0, 0.5, 1.5]: + q = p ** n + r = Rotation.from_rotvec(n * p.as_rotvec()) + assert_allclose(q.as_quat(), r.as_quat(), atol=atol) + + # Small angle + p = Rotation.from_rotvec([1e-12, 0, 0]) + n = 3 + q = p ** n + r = Rotation.from_rotvec(n * p.as_rotvec()) + assert_allclose(q.as_quat(), r.as_quat(), atol=atol) + + +def test_pow_errors(): + p = Rotation.random(random_state=0) + with pytest.raises(NotImplementedError, match='modulus not supported'): + pow(p, 1, 1) + + +def test_rotation_within_numpy_array(): + single = Rotation.random(random_state=0) + multiple = Rotation.random(2, random_state=1) + + array = np.array(single) + assert_equal(array.shape, ()) + + array = np.array(multiple) + assert_equal(array.shape, (2,)) + assert_allclose(array[0].as_matrix(), multiple[0].as_matrix()) + assert_allclose(array[1].as_matrix(), multiple[1].as_matrix()) + + array = np.array([single]) + assert_equal(array.shape, (1,)) + assert_equal(array[0], single) + + array = np.array([multiple]) + assert_equal(array.shape, (1, 2)) + assert_allclose(array[0, 0].as_matrix(), multiple[0].as_matrix()) + assert_allclose(array[0, 1].as_matrix(), multiple[1].as_matrix()) + + array = np.array([single, multiple], dtype=object) + assert_equal(array.shape, (2,)) + assert_equal(array[0], single) + assert_equal(array[1], multiple) + + array = np.array([multiple, multiple, multiple]) + assert_equal(array.shape, (3, 2)) + + +def test_pickling(): + r = Rotation.from_quat([0, 0, np.sin(np.pi/4), np.cos(np.pi/4)]) + pkl = pickle.dumps(r) + unpickled = pickle.loads(pkl) + assert_allclose(r.as_matrix(), unpickled.as_matrix(), atol=1e-15) + + +def test_deepcopy(): + r = Rotation.from_quat([0, 0, np.sin(np.pi/4), np.cos(np.pi/4)]) + r1 = copy.deepcopy(r) + assert_allclose(r.as_matrix(), r1.as_matrix(), atol=1e-15) + + +def test_as_euler_contiguous(): + r = Rotation.from_quat([0, 0, 0, 1]) + e1 = r.as_euler('xyz') # extrinsic euler rotation + e2 = r.as_euler('XYZ') # intrinsic + assert e1.flags['C_CONTIGUOUS'] is True + assert e2.flags['C_CONTIGUOUS'] is True + assert all(i >= 0 for i in e1.strides) + assert all(i >= 0 for i in e2.strides) + + +def test_concatenate(): + rotation = Rotation.random(10, random_state=0) + sizes = [1, 2, 3, 1, 3] + starts = [0] + list(np.cumsum(sizes)) + split = [rotation[i:i + n] for i, n in zip(starts, sizes)] + result = Rotation.concatenate(split) + assert_equal(rotation.as_quat(), result.as_quat()) + + +def test_concatenate_wrong_type(): + with pytest.raises(TypeError, match='Rotation objects only'): + Rotation.concatenate([Rotation.identity(), 1, None]) + + +# Regression test for gh-16663 +def test_len_and_bool(): + rotation_multi_empty = Rotation(np.empty((0, 4))) + rotation_multi_one = Rotation([[0, 0, 0, 1]]) + rotation_multi = Rotation([[0, 0, 0, 1], [0, 0, 0, 1]]) + rotation_single = Rotation([0, 0, 0, 1]) + + assert len(rotation_multi_empty) == 0 + assert len(rotation_multi_one) == 1 + assert len(rotation_multi) == 2 + with pytest.raises(TypeError, match="Single rotation has no len()."): + len(rotation_single) + + # Rotation should always be truthy. See gh-16663 + assert rotation_multi_empty + assert rotation_multi_one + assert rotation_multi + assert rotation_single + + +def test_from_davenport_single_rotation(): + axis = [0, 0, 1] + quat = Rotation.from_davenport(axis, 'extrinsic', 90, + degrees=True).as_quat() + expected_quat = np.array([0, 0, 1, 1]) / np.sqrt(2) + assert_allclose(quat, expected_quat) + + +def test_from_davenport_one_or_two_axes(): + ez = [0, 0, 1] + ey = [0, 1, 0] + + # Single rotation, single axis, axes.shape == (3, ) + rot = Rotation.from_rotvec(np.array(ez) * np.pi/4) + rot_dav = Rotation.from_davenport(ez, 'e', np.pi/4) + assert_allclose(rot.as_quat(canonical=True), + rot_dav.as_quat(canonical=True)) + + # Single rotation, single axis, axes.shape == (1, 3) + rot = Rotation.from_rotvec([np.array(ez) * np.pi/4]) + rot_dav = Rotation.from_davenport([ez], 'e', [np.pi/4]) + assert_allclose(rot.as_quat(canonical=True), + rot_dav.as_quat(canonical=True)) + + # Single rotation, two axes, axes.shape == (2, 3) + rot = Rotation.from_rotvec([np.array(ez) * np.pi/4, + np.array(ey) * np.pi/6]) + rot = rot[0] * rot[1] + rot_dav = Rotation.from_davenport([ey, ez], 'e', [np.pi/6, np.pi/4]) + assert_allclose(rot.as_quat(canonical=True), + rot_dav.as_quat(canonical=True)) + + # Two rotations, single axis, axes.shape == (3, ) + rot = Rotation.from_rotvec([np.array(ez) * np.pi/6, + np.array(ez) * np.pi/4]) + rot_dav = Rotation.from_davenport([ez], 'e', [np.pi/6, np.pi/4]) + assert_allclose(rot.as_quat(canonical=True), + rot_dav.as_quat(canonical=True)) + + +def test_from_davenport_invalid_input(): + ez = [0, 0, 1] + ey = [0, 1, 0] + ezy = [0, 1, 1] + with pytest.raises(ValueError, match="must be orthogonal"): + Rotation.from_davenport([ez, ezy], 'e', [0, 0]) + with pytest.raises(ValueError, match="must be orthogonal"): + Rotation.from_davenport([ez, ey, ezy], 'e', [0, 0, 0]) + with pytest.raises(ValueError, match="order should be"): + Rotation.from_davenport([ez], 'xyz', [0]) + with pytest.raises(ValueError, match="Expected `angles`"): + Rotation.from_davenport([ez, ey, ez], 'e', [0, 1, 2, 3]) + + +def test_as_davenport(): + rnd = np.random.RandomState(0) + n = 100 + angles = np.empty((n, 3)) + angles[:, 0] = rnd.uniform(low=-np.pi, high=np.pi, size=(n,)) + angles_middle = rnd.uniform(low=0, high=np.pi, size=(n,)) + angles[:, 2] = rnd.uniform(low=-np.pi, high=np.pi, size=(n,)) + lambdas = rnd.uniform(low=0, high=np.pi, size=(20,)) + + e1 = np.array([1, 0, 0]) + e2 = np.array([0, 1, 0]) + + for lamb in lambdas: + ax_lamb = [e1, e2, Rotation.from_rotvec(lamb*e2).apply(e1)] + angles[:, 1] = angles_middle - lamb + for order in ['extrinsic', 'intrinsic']: + ax = ax_lamb if order == 'intrinsic' else ax_lamb[::-1] + rot = Rotation.from_davenport(ax, order, angles) + angles_dav = rot.as_davenport(ax, order) + assert_allclose(angles_dav, angles) + + +def test_as_davenport_degenerate(): + # Since we cannot check for angle equality, we check for rotation matrix + # equality + rnd = np.random.RandomState(0) + n = 5 + angles = np.empty((n, 3)) + + # symmetric sequences + angles[:, 0] = rnd.uniform(low=-np.pi, high=np.pi, size=(n,)) + angles_middle = [rnd.choice([0, np.pi]) for i in range(n)] + angles[:, 2] = rnd.uniform(low=-np.pi, high=np.pi, size=(n,)) + lambdas = rnd.uniform(low=0, high=np.pi, size=(5,)) + + e1 = np.array([1, 0, 0]) + e2 = np.array([0, 1, 0]) + + for lamb in lambdas: + ax_lamb = [e1, e2, Rotation.from_rotvec(lamb*e2).apply(e1)] + angles[:, 1] = angles_middle - lamb + for order in ['extrinsic', 'intrinsic']: + ax = ax_lamb if order == 'intrinsic' else ax_lamb[::-1] + rot = Rotation.from_davenport(ax, order, angles) + with pytest.warns(UserWarning, match="Gimbal lock"): + angles_dav = rot.as_davenport(ax, order) + mat_expected = rot.as_matrix() + mat_estimated = Rotation.from_davenport(ax, order, angles_dav).as_matrix() + assert_array_almost_equal(mat_expected, mat_estimated) + + +def test_compare_from_davenport_from_euler(): + rnd = np.random.RandomState(0) + n = 100 + angles = np.empty((n, 3)) + + # symmetric sequences + angles[:, 0] = rnd.uniform(low=-np.pi, high=np.pi, size=(n,)) + angles[:, 1] = rnd.uniform(low=0, high=np.pi, size=(n,)) + angles[:, 2] = rnd.uniform(low=-np.pi, high=np.pi, size=(n,)) + for order in ['extrinsic', 'intrinsic']: + for seq_tuple in permutations('xyz'): + seq = ''.join([seq_tuple[0], seq_tuple[1], seq_tuple[0]]) + ax = [basis_vec(i) for i in seq] + if order == 'intrinsic': + seq = seq.upper() + eul = Rotation.from_euler(seq, angles) + dav = Rotation.from_davenport(ax, order, angles) + assert_allclose(eul.as_quat(canonical=True), dav.as_quat(canonical=True), + rtol=1e-12) + + # asymmetric sequences + angles[:, 1] -= np.pi / 2 + for order in ['extrinsic', 'intrinsic']: + for seq_tuple in permutations('xyz'): + seq = ''.join(seq_tuple) + ax = [basis_vec(i) for i in seq] + if order == 'intrinsic': + seq = seq.upper() + eul = Rotation.from_euler(seq, angles) + dav = Rotation.from_davenport(ax, order, angles) + assert_allclose(eul.as_quat(), dav.as_quat(), rtol=1e-12) + + +def test_compare_as_davenport_as_euler(): + rnd = np.random.RandomState(0) + n = 100 + angles = np.empty((n, 3)) + + # symmetric sequences + angles[:, 0] = rnd.uniform(low=-np.pi, high=np.pi, size=(n,)) + angles[:, 1] = rnd.uniform(low=0, high=np.pi, size=(n,)) + angles[:, 2] = rnd.uniform(low=-np.pi, high=np.pi, size=(n,)) + for order in ['extrinsic', 'intrinsic']: + for seq_tuple in permutations('xyz'): + seq = ''.join([seq_tuple[0], seq_tuple[1], seq_tuple[0]]) + ax = [basis_vec(i) for i in seq] + if order == 'intrinsic': + seq = seq.upper() + rot = Rotation.from_euler(seq, angles) + eul = rot.as_euler(seq) + dav = rot.as_davenport(ax, order) + assert_allclose(eul, dav, rtol=1e-12) + + # asymmetric sequences + angles[:, 1] -= np.pi / 2 + for order in ['extrinsic', 'intrinsic']: + for seq_tuple in permutations('xyz'): + seq = ''.join(seq_tuple) + ax = [basis_vec(i) for i in seq] + if order == 'intrinsic': + seq = seq.upper() + rot = Rotation.from_euler(seq, angles) + eul = rot.as_euler(seq) + dav = rot.as_davenport(ax, order) + assert_allclose(eul, dav, rtol=1e-12) diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/tests/test_rotation_groups.py b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/tests/test_rotation_groups.py new file mode 100644 index 0000000000000000000000000000000000000000..befe60c13c5a5863a2ae50f9d20e6d054795f6b9 --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/tests/test_rotation_groups.py @@ -0,0 +1,169 @@ +import pytest + +import numpy as np +from numpy.testing import assert_array_almost_equal +from scipy.spatial.transform import Rotation +from scipy.optimize import linear_sum_assignment +from scipy.spatial.distance import cdist +from scipy.constants import golden as phi +from scipy.spatial import cKDTree + + +TOL = 1E-12 +NS = range(1, 13) +NAMES = ["I", "O", "T"] + ["C%d" % n for n in NS] + ["D%d" % n for n in NS] +SIZES = [60, 24, 12] + list(NS) + [2 * n for n in NS] + + +def _calculate_rmsd(P, Q): + """Calculates the root-mean-square distance between the points of P and Q. + The distance is taken as the minimum over all possible matchings. It is + zero if P and Q are identical and non-zero if not. + """ + distance_matrix = cdist(P, Q, metric='sqeuclidean') + matching = linear_sum_assignment(distance_matrix) + return np.sqrt(distance_matrix[matching].sum()) + + +def _generate_pyramid(n, axis): + thetas = np.linspace(0, 2 * np.pi, n + 1)[:-1] + P = np.vstack([np.zeros(n), np.cos(thetas), np.sin(thetas)]).T + P = np.concatenate((P, [[1, 0, 0]])) + return np.roll(P, axis, axis=1) + + +def _generate_prism(n, axis): + thetas = np.linspace(0, 2 * np.pi, n + 1)[:-1] + bottom = np.vstack([-np.ones(n), np.cos(thetas), np.sin(thetas)]).T + top = np.vstack([+np.ones(n), np.cos(thetas), np.sin(thetas)]).T + P = np.concatenate((bottom, top)) + return np.roll(P, axis, axis=1) + + +def _generate_icosahedron(): + x = np.array([[0, -1, -phi], + [0, -1, +phi], + [0, +1, -phi], + [0, +1, +phi]]) + return np.concatenate([np.roll(x, i, axis=1) for i in range(3)]) + + +def _generate_octahedron(): + return np.array([[-1, 0, 0], [+1, 0, 0], [0, -1, 0], + [0, +1, 0], [0, 0, -1], [0, 0, +1]]) + + +def _generate_tetrahedron(): + return np.array([[1, 1, 1], [1, -1, -1], [-1, 1, -1], [-1, -1, 1]]) + + +@pytest.mark.parametrize("name", [-1, None, True, np.array(['C3'])]) +def test_group_type(name): + with pytest.raises(ValueError, + match="must be a string"): + Rotation.create_group(name) + + +@pytest.mark.parametrize("name", ["Q", " ", "CA", "C ", "DA", "D ", "I2", ""]) +def test_group_name(name): + with pytest.raises(ValueError, + match="must be one of 'I', 'O', 'T', 'Dn', 'Cn'"): + Rotation.create_group(name) + + +@pytest.mark.parametrize("name", ["C0", "D0"]) +def test_group_order_positive(name): + with pytest.raises(ValueError, + match="Group order must be positive"): + Rotation.create_group(name) + + +@pytest.mark.parametrize("axis", ['A', 'b', 0, 1, 2, 4, False, None]) +def test_axis_valid(axis): + with pytest.raises(ValueError, + match="`axis` must be one of"): + Rotation.create_group("C1", axis) + + +def test_icosahedral(): + """The icosahedral group fixes the rotations of an icosahedron. Here we + test that the icosahedron is invariant after application of the elements + of the rotation group.""" + P = _generate_icosahedron() + for g in Rotation.create_group("I"): + g = Rotation.from_quat(g.as_quat()) + assert _calculate_rmsd(P, g.apply(P)) < TOL + + +def test_octahedral(): + """Test that the octahedral group correctly fixes the rotations of an + octahedron.""" + P = _generate_octahedron() + for g in Rotation.create_group("O"): + assert _calculate_rmsd(P, g.apply(P)) < TOL + + +def test_tetrahedral(): + """Test that the tetrahedral group correctly fixes the rotations of a + tetrahedron.""" + P = _generate_tetrahedron() + for g in Rotation.create_group("T"): + assert _calculate_rmsd(P, g.apply(P)) < TOL + + +@pytest.mark.parametrize("n", NS) +@pytest.mark.parametrize("axis", 'XYZ') +def test_dicyclic(n, axis): + """Test that the dicyclic group correctly fixes the rotations of a + prism.""" + P = _generate_prism(n, axis='XYZ'.index(axis)) + for g in Rotation.create_group("D%d" % n, axis=axis): + assert _calculate_rmsd(P, g.apply(P)) < TOL + + +@pytest.mark.parametrize("n", NS) +@pytest.mark.parametrize("axis", 'XYZ') +def test_cyclic(n, axis): + """Test that the cyclic group correctly fixes the rotations of a + pyramid.""" + P = _generate_pyramid(n, axis='XYZ'.index(axis)) + for g in Rotation.create_group("C%d" % n, axis=axis): + assert _calculate_rmsd(P, g.apply(P)) < TOL + + +@pytest.mark.parametrize("name, size", zip(NAMES, SIZES)) +def test_group_sizes(name, size): + assert len(Rotation.create_group(name)) == size + + +@pytest.mark.parametrize("name, size", zip(NAMES, SIZES)) +def test_group_no_duplicates(name, size): + g = Rotation.create_group(name) + kdtree = cKDTree(g.as_quat()) + assert len(kdtree.query_pairs(1E-3)) == 0 + + +@pytest.mark.parametrize("name, size", zip(NAMES, SIZES)) +def test_group_symmetry(name, size): + g = Rotation.create_group(name) + q = np.concatenate((-g.as_quat(), g.as_quat())) + distance = np.sort(cdist(q, q)) + deltas = np.max(distance, axis=0) - np.min(distance, axis=0) + assert (deltas < TOL).all() + + +@pytest.mark.parametrize("name", NAMES) +def test_reduction(name): + """Test that the elements of the rotation group are correctly + mapped onto the identity rotation.""" + g = Rotation.create_group(name) + f = g.reduce(g) + assert_array_almost_equal(f.magnitude(), np.zeros(len(g))) + + +@pytest.mark.parametrize("name", NAMES) +def test_single_reduction(name): + g = Rotation.create_group(name) + f = g[-1].reduce(g) + assert_array_almost_equal(f.magnitude(), 0) + assert f.as_quat().shape == (4,) diff --git a/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/tests/test_rotation_spline.py b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/tests/test_rotation_spline.py new file mode 100644 index 0000000000000000000000000000000000000000..6441431f2fb54a95edd6364c4671bc55a2ce2b8f --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/scipy/spatial/transform/tests/test_rotation_spline.py @@ -0,0 +1,162 @@ +from itertools import product +import numpy as np +from numpy.testing import assert_allclose +from pytest import raises +from scipy.spatial.transform import Rotation, RotationSpline +from scipy.spatial.transform._rotation_spline import ( + _angular_rate_to_rotvec_dot_matrix, + _rotvec_dot_to_angular_rate_matrix, + _matrix_vector_product_of_stacks, + _angular_acceleration_nonlinear_term, + _create_block_3_diagonal_matrix) + + +def test_angular_rate_to_rotvec_conversions(): + np.random.seed(0) + rv = np.random.randn(4, 3) + A = _angular_rate_to_rotvec_dot_matrix(rv) + A_inv = _rotvec_dot_to_angular_rate_matrix(rv) + + # When the rotation vector is aligned with the angular rate, then + # the rotation vector rate and angular rate are the same. + assert_allclose(_matrix_vector_product_of_stacks(A, rv), rv) + assert_allclose(_matrix_vector_product_of_stacks(A_inv, rv), rv) + + # A and A_inv must be reciprocal to each other. + I_stack = np.empty((4, 3, 3)) + I_stack[:] = np.eye(3) + assert_allclose(np.matmul(A, A_inv), I_stack, atol=1e-15) + + +def test_angular_rate_nonlinear_term(): + # The only simple test is to check that the term is zero when + # the rotation vector + np.random.seed(0) + rv = np.random.rand(4, 3) + assert_allclose(_angular_acceleration_nonlinear_term(rv, rv), 0, + atol=1e-19) + + +def test_create_block_3_diagonal_matrix(): + np.random.seed(0) + A = np.empty((4, 3, 3)) + A[:] = np.arange(1, 5)[:, None, None] + + B = np.empty((4, 3, 3)) + B[:] = -np.arange(1, 5)[:, None, None] + d = 10 * np.arange(10, 15) + + banded = _create_block_3_diagonal_matrix(A, B, d) + + # Convert the banded matrix to the full matrix. + k, l = list(zip(*product(np.arange(banded.shape[0]), + np.arange(banded.shape[1])))) + k = np.asarray(k) + l = np.asarray(l) + + i = k - 5 + l + j = l + values = banded.ravel() + mask = (i >= 0) & (i < 15) + i = i[mask] + j = j[mask] + values = values[mask] + full = np.zeros((15, 15)) + full[i, j] = values + + zero = np.zeros((3, 3)) + eye = np.eye(3) + + # Create the reference full matrix in the most straightforward manner. + ref = np.block([ + [d[0] * eye, B[0], zero, zero, zero], + [A[0], d[1] * eye, B[1], zero, zero], + [zero, A[1], d[2] * eye, B[2], zero], + [zero, zero, A[2], d[3] * eye, B[3]], + [zero, zero, zero, A[3], d[4] * eye], + ]) + + assert_allclose(full, ref, atol=1e-19) + + +def test_spline_2_rotations(): + times = [0, 10] + rotations = Rotation.from_euler('xyz', [[0, 0, 0], [10, -20, 30]], + degrees=True) + spline = RotationSpline(times, rotations) + + rv = (rotations[0].inv() * rotations[1]).as_rotvec() + rate = rv / (times[1] - times[0]) + times_check = np.array([-1, 5, 12]) + dt = times_check - times[0] + rv_ref = rate * dt[:, None] + + assert_allclose(spline(times_check).as_rotvec(), rv_ref) + assert_allclose(spline(times_check, 1), np.resize(rate, (3, 3))) + assert_allclose(spline(times_check, 2), 0, atol=1e-16) + + +def test_constant_attitude(): + times = np.arange(10) + rotations = Rotation.from_rotvec(np.ones((10, 3))) + spline = RotationSpline(times, rotations) + + times_check = np.linspace(-1, 11) + assert_allclose(spline(times_check).as_rotvec(), 1, rtol=1e-15) + assert_allclose(spline(times_check, 1), 0, atol=1e-17) + assert_allclose(spline(times_check, 2), 0, atol=1e-17) + + assert_allclose(spline(5.5).as_rotvec(), 1, rtol=1e-15) + assert_allclose(spline(5.5, 1), 0, atol=1e-17) + assert_allclose(spline(5.5, 2), 0, atol=1e-17) + + +def test_spline_properties(): + times = np.array([0, 5, 15, 27]) + angles = [[-5, 10, 27], [3, 5, 38], [-12, 10, 25], [-15, 20, 11]] + + rotations = Rotation.from_euler('xyz', angles, degrees=True) + spline = RotationSpline(times, rotations) + + assert_allclose(spline(times).as_euler('xyz', degrees=True), angles) + assert_allclose(spline(0).as_euler('xyz', degrees=True), angles[0]) + + h = 1e-8 + rv0 = spline(times).as_rotvec() + rvm = spline(times - h).as_rotvec() + rvp = spline(times + h).as_rotvec() + # rtol bumped from 1e-15 to 1.5e-15 in gh18414 for linux 32 bit + assert_allclose(rv0, 0.5 * (rvp + rvm), rtol=1.5e-15) + + r0 = spline(times, 1) + rm = spline(times - h, 1) + rp = spline(times + h, 1) + assert_allclose(r0, 0.5 * (rm + rp), rtol=1e-14) + + a0 = spline(times, 2) + am = spline(times - h, 2) + ap = spline(times + h, 2) + assert_allclose(a0, am, rtol=1e-7) + assert_allclose(a0, ap, rtol=1e-7) + + +def test_error_handling(): + raises(ValueError, RotationSpline, [1.0], Rotation.random()) + + r = Rotation.random(10) + t = np.arange(10).reshape(5, 2) + raises(ValueError, RotationSpline, t, r) + + t = np.arange(9) + raises(ValueError, RotationSpline, t, r) + + t = np.arange(10) + t[5] = 0 + raises(ValueError, RotationSpline, t, r) + + t = np.arange(10) + + s = RotationSpline(t, r) + raises(ValueError, s, 10, -1) + + raises(ValueError, s, np.arange(10).reshape(5, 2))