diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml new file mode 100644 index 0000000..88c425f --- /dev/null +++ b/.github/workflows/test.yml @@ -0,0 +1,29 @@ +name: Test DefDAP + +on: [push, pull_request] + +jobs: + build: + + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + python-version: ["3.8", "3.9", "3.10", "3.11"] + + steps: + - uses: actions/checkout@v2 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v2 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies + run: | + python -m pip install --upgrade pip + python -m pip install --upgrade pytest + python -m pip install .[testing] + if [ -f requirements.txt ]; then pip install -r requirements.txt; fi + + - name: Test with pytest + run: | + pytest diff --git a/.gitignore b/.gitignore index 3cf0747..c4895be 100644 --- a/.gitignore +++ b/.gitignore @@ -33,3 +33,6 @@ DefDAP.egg-info/ # coverage .coverage + +# vscode +.vscode diff --git a/pytest.ini b/.pytest.ini similarity index 100% rename from pytest.ini rename to .pytest.ini diff --git a/.readthedocs.yml b/.readthedocs.yml index 3cf305d..5744e1f 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -10,4 +10,4 @@ python: - method: pip path: . extra_requirements: - - docs + - docs \ No newline at end of file diff --git a/.travis.yml b/.travis.yml deleted file mode 100644 index 2f4e240..0000000 --- a/.travis.yml +++ /dev/null @@ -1,15 +0,0 @@ -git: - quiet: true -language: python -python: - - 3.6 - - 3.7 - - 3.8 - - 3.9 -before_install: - - python --version - - pip install -U pip - - pip install -U pytest -install: - - pip install .[testing] -script: pytest diff --git a/CHANGELOG.md b/CHANGELOG.md index 443b9e9..fcdcf88 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,12 +1,46 @@ # Change Log + ## Current ### Added +- Each grain is assigned a phase and slip systems are automatically loaded + for a given phase based on crystal structure. + - This means that unit cells and slip traces plot correctly for grains + in a multi-phase EBSD map +- Add slip system file for FCC but in same order as DAMASK +- Use example_notebook to generate a 'How To Use' page in the documentation +- Add reader for EDAX .ang EBSD files, pyvale .csv files and openPIV-XL .npx files +- Added a `plot_map` function for grains +- Added more testing ### Changed +- All functions and arguments are now in snake_case instead of CamelCase +- Cropping and masking are now performed upon access to data +- Changed function names from CamelCase to snake_case +- Overhaul of data storage in the Map classes +- RDR calculation `calcRDR` in grain inspector is faster and more robust +- Improve formatting of grain inspector and RDR plot window +- Refactor boundary lines calculations +- Use GitHub actions to run `pytest` on commit push or pull request + +### Fixed +- Fix bug in grain inspector (`None` passed to `corrAngle` inadvertently) +- Fix EBSD grain linker +- Remove `IPython` and `jupyter` as requirements +- Bug in IPF traiangle plotting now fixed with options for `up` triangle (like MTEX) and `down` triangle (like OI) + + +## 0.93.5 (20-11-2023) + +### Added +- Add more options for colouring lines ### Fixed +- Fix bug with accessing slip systems in grain inspector +- Replace np.float with python float +- Remove in_place argument to skimage.morphology.remove_small_objects +- set_window_title has been moved from figure.canvas to figure.canvas.manager ## 0.93.5 (20-11-2023) @@ -24,7 +58,7 @@ ## 0.93.5 (17-01-2023) ### Added -- Add equality check for Quat +- Add equality check for `Quat` ### Fixed - Fix bug in boundary line warping @@ -59,7 +93,7 @@ ## 0.93.2 (16-04-2021) ### Added -- Reading of Channel project files that contain EDX data +- Reading of Channel5 project files that contain EDX data ### Fixed - Plotting unit cells @@ -75,21 +109,21 @@ ### Changed - Speed up EBSD map data rotation -- Speed up 'warp' grain finding +- Speed up `warp` grain finding - Store band slope and MAD arrays from EBSD -- Update nCorrToDavis.m script +- Update `nCorrToDavis.m` script - Better description of how to use the function - Sub-window size is subset radius * 2, as defined in nCorr - Subset spacing is subset spacing, as defined in nCorr - Generate phase boundary points and lines at same time as grain boundaries - Improve histogram plotting - - Options for scatter (as before), step and bar - - Options for logx, logy, loglog and linear + - Options for scatter (as before), `step` and `bar` + - Options for `logx`, `logy`, `loglog` and `linear` - Updates to example notebook ### Fixed - Fixed docstring links -- Fix bug in 'warp' grain finding algorithm +- Fix bug in `warp` grain finding algorithm ## 0.93.0 (20-02-2021) @@ -108,7 +142,7 @@ - Add misorientation calculation between neighbouring EBSD grains. - Add a `BoundarySegment` class to represent a section of grain boundary between 2 grain in an EBSD map. Objects of this class are assigned to edges of the neighbour network and contain all the boundary points between the grains. - Add Kuwahara filter for EBSD map noise reduction. -- Add shape property to maps. +- Add `shape` property to maps. - Read EBSD phases from file. - Add classes to represent phases and crystal structures. @@ -125,7 +159,7 @@ - Change docs over to readthedocs. - Move version number to own file. - Update neighbour network to use grains as nodes. -- Store grainID in grain objects. +- Store `grainID` in grain objects. - Split plotGrainDataMap into separate array construction and plotting function. - Update neighbour network construction to use new EBSD boundary definition. - Update flood fill algorithm for grain finding in a EBSD map. diff --git a/README.md b/README.md index 0847052..4bb670c 100644 --- a/README.md +++ b/README.md @@ -17,7 +17,7 @@ ## How to install - DefDAP can be installed from PyPI using the command `pip install defdap` -- If you use conda as your package manager (https://www.anaconda.com/), the prerequisite packages that are available from anaconda can be installed using the command `conda install scipy numpy matplotlib scikit-image pandas networkx jupyter ipython` (Anaconda3-2020.02 has been tested) +- If you use conda as your package manager (https://www.anaconda.com/), the prerequisite packages that are available from anaconda can be installed using the command `conda install scipy numpy matplotlib scikit-image pandas networkx` (Anaconda3-2020.02 has been tested) - For more information, see the [documentation](https://defdap.readthedocs.io/en/latest/installation.html) ## How to use @@ -43,8 +43,6 @@ The software uses the following open source packages: - [pandas](http://pandas.pydata.org) - [peakutils](https://peakutils.readthedocs.io/en/latest/) - [matplotlib_scalebar](https://pypi.org/project/matplotlib-scalebar/) -- [IPython](https://ipython.org/) -- [jupyter](https://jupyter.org/) ## License [Apache 2.0 license](https://www.apache.org/licenses/LICENSE-2.0) diff --git a/defdap/__init__.py b/defdap/__init__.py index a3579b3..75f37f8 100644 --- a/defdap/__init__.py +++ b/defdap/__init__.py @@ -1,3 +1,5 @@ +from defdap.experiment import Experiment + defaults = { # Convention to use when attaching an orthonormal frame to a crystal # structure. 'hkl' or 'tsl' @@ -14,6 +16,10 @@ 'slip_system_file': { 'FCC': 'cubic_fcc', 'BCC': 'cubic_bcc', - 'HCP': 'hexagonal_noca', + 'HCP': 'hexagonal_withca', }, + # up or down + 'ipf_triangle_convention': 'up' } + +anonymous_experiment = Experiment() diff --git a/defdap/_accelerated.py b/defdap/_accelerated.py new file mode 100644 index 0000000..dd90896 --- /dev/null +++ b/defdap/_accelerated.py @@ -0,0 +1,163 @@ +# Copyright 2025 Mechanics of Microstructures Group +# at The University of Manchester +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from numba import njit +import numpy as np + + +@njit +def find_first(arr): + for i in range(len(arr)): + if arr[i]: + return i + + +@njit +def flood_fill(seed, index, points_remaining, grains, boundary_x, boundary_y, + added_coords): + """Flood fill algorithm that uses the x and y boundary arrays to + fill a connected area around the seed point. The points are inserted + into a grain object and the grain map array is updated. + + Parameters + ---------- + seed : tuple of 2 int + Seed point x for flood fill + index : int + Value to fill in grain map + points_remaining : numpy.ndarray + Boolean map of the points that have not been assigned a grain yet + + Returns + ------- + grain : defdap.ebsd.Grain + New grain object with points added + """ + x, y = seed + grains[y, x] = index + points_remaining[y, x] = False + edge = [seed] + added_coords[0] = seed + npoints = 1 + + while edge: + x, y = edge.pop() + moves = [(x+1, y), (x-1, y), (x, y+1), (x, y-1)] + # get rid of any that go out of the map area + if x <= 0: + moves.pop(1) + elif x > grains.shape[1] - 2: + moves.pop(0) + if y <= 0: + moves.pop(-1) + elif y > grains.shape[0] - 2: + moves.pop(-2) + + for (s, t) in moves: + if grains[t, s] > 0: + continue + + add_point = False + + if t == y: + # moving horizontally + if s > x: + # moving right + add_point = not boundary_x[y, x] + else: + # moving left + add_point = not boundary_x[t, s] + else: + # moving vertically + if t > y: + # moving down + add_point = not boundary_y[y, x] + else: + # moving up + add_point = not boundary_y[t, s] + + if add_point: + added_coords[npoints] = s, t + grains[t, s] = index + points_remaining[t, s] = False + npoints += 1 + edge.append((s, t)) + + return added_coords[:npoints] + + +@njit +def flood_fill_dic(seed, index, points_remaining, grains, added_coords): + """Flood fill algorithm that uses the combined x and y boundary array + to fill a connected area around the seed point. The points are returned and + the grain map array is updated. + + Parameters + ---------- + seed : tuple of 2 int + Seed point x for flood fill + index : int + Value to fill in grain map + points_remaining : numpy.ndarray + Boolean map of the points remaining to assign a grain yet + grains : numpy.ndarray + added_coords : numpy.ndarray + Buffer for points in the grain + + Returns + ------- + numpy.ndarray + Flooded points (n, 2) + + """ + # add first point to the grain + x, y = seed + grains[y, x] = index + points_remaining[y, x] = False + edge = [seed] + added_coords[0] = seed + npoints = 1 + + while edge: + x, y = edge.pop() + + moves = [(x+1, y), (x-1, y), (x, y+1), (x, y-1)] + # get rid of any that go out of the map area + if x <= 0: + moves.pop(1) + elif x >= grains.shape[1] - 1: + moves.pop(0) + if y <= 0: + moves.pop(-1) + elif y >= grains.shape[0] - 1: + moves.pop(-2) + + for (s, t) in moves: + add_point = False + + if grains[t, s] == 0: + add_point = True + edge.append((s, t)) + + elif grains[t, s] == -1 and (s > x or t > y): + add_point = True + + if add_point: + added_coords[npoints] = (s, t) + grains[t, s] = index + points_remaining[t, s] = False + npoints += 1 + + return added_coords[:npoints] diff --git a/defdap/_version.py b/defdap/_version.py index a3748e9..918f053 100644 --- a/defdap/_version.py +++ b/defdap/_version.py @@ -1 +1 @@ -__version__ = '0.93.6' +__version__ = '0.93.6dev' diff --git a/defdap/base.py b/defdap/base.py index 81d83d0..771fa26 100755 --- a/defdap/base.py +++ b/defdap/base.py @@ -1,4 +1,4 @@ -# Copyright 2021 Mechanics of Microstructures Group +# Copyright 2025 Mechanics of Microstructures Group # at The University of Manchester # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,100 +13,129 @@ # See the License for the specific language governing permissions and # limitations under the License. +from abc import ABC, abstractmethod +from pathlib import Path + import numpy as np import networkx as nx +import defdap from defdap.quat import Quat from defdap import plotting from defdap.plotting import Plot, MapPlot, GrainPlot from skimage.measure import profile_line -from defdap.utils import reportProgress +from defdap.utils import report_progress, Datastore +from defdap.experiment import Frame -class Map(object): +class Map(ABC): """ Base class for a map. Contains common functionality for all maps. Attributes ---------- - grainList : list of defdap.base.Grain + _grains : list of defdap.base.Grain List of grains. - currGrainId : int - ID of last selected grain. + sel_grain : defdap.base.grain + The last selected grain """ - def __init__(self): - self.xDim = None - self.yDim = None + def __init__(self, file_name, data_type=None, experiment=None, + increment=None, frame=None, map_name=None): + """ - self.grainList = None - self.currGrainId = None # ID of last selected grain - self.homogPoints = [] + Parameters + ---------- + file_name : str + Path to EBSD file, including name, excluding extension. + data_type : str, {'OxfordBinary', 'OxfordText'} + Format of EBSD data file. - self.proxigramArr = None - self.neighbourNetwork = None + """ + + self.data = Datastore(crop_func=self.crop, mask_func=self.mask) + self.frame = frame if frame is not None else Frame() + if increment is not None: + self.increment = increment + self.experiment = self.increment.experiment + if experiment is not None: + assert self.experiment is experiment + else: + self.experiment = experiment + if experiment is None: + self.experiment = defdap.anonymous_experiment + self.increment = self.experiment.add_increment() + map_name = self.MAPNAME if map_name is None else map_name + self.increment.add_map(map_name, self) - self.grainPlot = None - self.profilePlot = None + self.shape = (0, 0) + + self._grains = None + + self.sel_grain = None + + self.proxigram_arr = None + self.neighbour_network = None + + self.grain_plot = None + self.profile_plot = None + + self.file_name = Path(file_name) + self.load_data(self.file_name, data_type=data_type) + + self.data.add_generator( + 'proxigram', self.calc_proxigram, unit='', type='map', order=0, + cropped=True + ) + + @abstractmethod + def load_data(self, file_name, data_type=None): + pass def __len__(self): - return len(self.grainList) + return len(self.grains) # allow array like getting of grains def __getitem__(self, key): - # Check that grains have been detected in the map - self.checkGrainsDetected() - - return self.grainList[key] + return self.grains[key] @property - def shape(self): - return self.yDim, self.xDim + def grains(self): + # try to access grains image to generate grains if necessary + self.data.grains + return self._grains - def checkGrainsDetected(self, raiseExc=True): - """Check if grains have been detected. - - Parameters - ---------- - raiseExc : bool - If True then an expception is raised if grains have not been - detected. + @property + def x_dim(self): + return self.shape[1] - Returns - ------- - bool: - True if grains detected, False otherwise. + @property + def y_dim(self): + return self.shape[0] - Raises - ------- - Exception - If grains not detected. + def crop(self, map_data, **kwargs): + return map_data + + def mask(self, map_data, **kwargs): + return map_data - """ + def set_homog_point(self, **kwargs): + return self.frame.set_homog_point(self, **kwargs) - if (self.grainList is None or - type(self.grainList) is not list or - len(self.grainList) < 1): - if raiseExc: - raise Exception("No grains detected.") - else: - return False - return True - - def plotGrainNumbers(self, dilateBoundaries=False, ax=None, **kwargs): + def plot_grain_numbers(self, dilate_boundaries=False, ax=None, **kwargs): """Plot a map with grains numbered. Parameters ---------- - dilateBoundaries : bool, optional + dilate_boundaries : bool, optional Set to true to dilate boundaries. ax : matplotlib.axes.Axes, optional axis to plot on, if not provided the current active axis is used. kwargs : dict, optional - Keyword arguments passed to :func:`defdap.plotting.MapPlot.addGrainNumbers` + Keyword arguments passed to :func:`defdap.plotting.MapPlot.add_grain_numbers` Returns ------- @@ -115,44 +144,42 @@ def plotGrainNumbers(self, dilateBoundaries=False, ax=None, **kwargs): """ plot = plotting.MapPlot(self, ax=ax) - plot.addGrainBoundaries(colour='black', dilate=dilateBoundaries) - plot.addGrainNumbers(**kwargs) + plot.add_grain_boundaries(colour='black', dilate=dilate_boundaries) + plot.add_grain_numbers(**kwargs) return plot - def locateGrainID(self, clickEvent=None, displaySelected=False, **kwargs): + def locate_grain(self, click_event=None, display_grain=False, **kwargs): """Interactive plot for identifying grains. Parameters ---------- - clickEvent : optional + click_event : optional Click handler to use. - displaySelected : bool, optional + display_grain : bool, optional If true, plot slip traces for grain selected by click. kwargs : dict, optional - Keyword arguments passed to :func:`defdap.base.Map.plotDefault` + Keyword arguments passed to :func:`defdap.base.Map.plot_default` """ - # Check that grains have been detected in the map - self.checkGrainsDetected() - # reset current selected grain and plot euler map with click handler - self.currGrainId = None - plot = self.plotDefault(makeInteractive=True, **kwargs) - if clickEvent is None: + plot = self.plot_default(make_interactive=True, **kwargs) + if click_event is None: # default click handler which highlights grain and prints id - plot.addEventHandler( + plot.add_event_handler( 'button_press_event', - lambda e, p: self.clickGrainID(e, p, displaySelected) + lambda e, p: self.click_grain_id(e, p, display_grain) ) else: # click handler loaded in as parameter. Pass current map # object to it. - plot.addEventHandler('button_press_event', clickEvent) + plot.add_event_handler('button_press_event', click_event) + if display_grain: + self.grain_plot = None return plot - def clickGrainID(self, event, plot, displaySelected): + def click_grain_id(self, event, plot, display_grain): """Event handler to capture clicking on a map. Parameters @@ -161,7 +188,7 @@ def clickGrainID(self, event, plot, displaySelected): Click event. plot : defdap.plotting.MapPlot Plot to capture clicks from. - displaySelected : bool + display_grain : bool If true, plot the selected grain alone in pop-out window. """ @@ -170,260 +197,99 @@ def clickGrainID(self, event, plot, displaySelected): return # grain id of selected grain - self.currGrainId = int(self.grains[int(event.ydata), int(event.xdata)] - 1) - print("Grain ID: {}".format(self.currGrainId)) + grain_id = self.data.grains[int(event.ydata), int(event.xdata)] - 1 + if grain_id < 0: + return + grain = self[grain_id] + self.sel_grain = grain + print("Grain ID: {}".format(grain_id)) # update the grain highlights layer in the plot - plot.addGrainHighlights([self.currGrainId], alpha=self.highlightAlpha) + plot.add_grain_highlights([grain_id], alpha=self.highlight_alpha) - if displaySelected: - currGrain = self[self.currGrainId] - if self.grainPlot is None or not self.grainPlot.exists: - self.grainPlot = currGrain.plotDefault(makeInteractive=True) + if display_grain: + if self.grain_plot is None or not self.grain_plot.exists: + self.grain_plot = grain.plot_default(make_interactive=True) else: - self.grainPlot.clear() - self.grainPlot.callingGrain = currGrain - currGrain.plotDefault(plot=self.grainPlot) - self.grainPlot.draw() + self.grain_plot.clear() + self.grain_plot.calling_grain = grain + grain.plot_default(plot=self.grain_plot) + self.grain_plot.draw() - def drawLineProfile(self, **kwargs): + def draw_line_profile(self, **kwargs): """Interactive plot for drawing a line profile of data. Parameters ---------- kwargs : dict, optional - Keyword arguments passed to :func:`defdap.base.Map.plotDefault` + Keyword arguments passed to :func:`defdap.base.Map.plot_default` """ - plot = self.plotDefault(makeInteractive=True, **kwargs) + plot = self.plot_default(make_interactive=True, **kwargs) - plot.addEventHandler('button_press_event', plot.lineSlice) - plot.addEventHandler('button_release_event', lambda e, p: plot.lineSlice(e, p, - action=self.calcLineProfile)) + plot.add_event_handler('button_press_event', plot.line_slice) + plot.add_event_handler( + 'button_release_event', + lambda e, p: plot.line_slice(e, p, action=self.calc_line_profile) + ) return plot - def calcLineProfile(self, plot, startEnd, **kwargs): + def calc_line_profile(self, plot, start_end, **kwargs): """Calculate and plot the line profile. Parameters ---------- plot : defdap.plotting.MapPlot Plot to calculate the line profile for. - startEnd : array_like + start_end : array_like Selected points (x0, y0, x1, y1). kwargs : dict, optional Keyword arguments passed to :func:`matplotlib.pyplot.plot` """ - x0, y0 = startEnd[0:2] - x1, y1 = startEnd[2:4] + x0, y0 = start_end[0:2] + x1, y1 = start_end[2:4] profile_length = np.sqrt((y1 - y0) ** 2 + (x1 - x0) ** 2) # Extract the values along the line zi = profile_line( - plot.imgLayers[0].get_array(), - (startEnd[1], startEnd[0]), - (startEnd[3], startEnd[2]), + plot.img_layers[0].get_array(), + (start_end[1], start_end[0]), + (start_end[3], start_end[2]), mode='nearest' ) xi = np.linspace(0, profile_length, len(zi)) - if self.profilePlot is None or not self.profilePlot.exists: - self.profilePlot = Plot(makeInteractive=True) - else: - self.profilePlot.clear() - - self.profilePlot.ax.plot(xi, zi, **kwargs) - self.profilePlot.ax.set_xlabel('Distance (pixels)') - self.profilePlot.ax.set_ylabel('Intensity') - self.profilePlot.draw() - - def setHomogPoint(self, binSize=1, points=None, **kwargs): - """ - Interactive tool to set homologous points. Right-click on a point - then click 'save point' to append to the homologous points list. - - Parameters - ---------- - binSize : int, optional - Binning applied to image, if applicable. - points : numpy.ndarray, optional - Array of (x,y) homologous points to set explicitly. - kwargs : dict, optional - Keyword arguments passed to :func:`defdap.base.Map.plotHomog` - - """ - if points is None: - plot = self.plotHomog(makeInteractive=True, **kwargs) - # Plot stored homogo points if there are any - if len(self.homogPoints) > 0: - homogPoints = np.array(self.homogPoints) * binSize - plot.addPoints(homogPoints[:, 0], homogPoints[:, 1], - c='y', s=60) - else: - # add empty points layer to update later - plot.addPoints([None], [None], c='y', s=60) - - # add empty points layer for current selected point - plot.addPoints([None], [None], c='w', s=60, marker='x') - - plot.addEventHandler('button_press_event', self.clickHomog) - plot.addEventHandler('key_press_event', self.keyHomog) - plot.addButton("Save point", - lambda e, p: self.clickSaveHomog(e, p, binSize), - color="0.85", hovercolor="blue") + if self.profile_plot is None or not self.profile_plot.exists: + self.profile_plot = Plot(make_interactive=True) else: - self.homogPoints = points + self.profile_plot.clear() - def clickHomog(self, event, plot): - """Event handler for capturing position when clicking on a map. + self.profile_plot.ax.plot(xi, zi, **kwargs) + self.profile_plot.ax.set_xlabel('Distance (pixels)') + self.profile_plot.ax.set_ylabel('Intensity') + self.profile_plot.draw() - Parameters - ---------- - event : - Click event. - plot : defdap.plotting.MapPlot - Plot to monitor. - - """ - # check if click was on the map - if event.inaxes is not plot.ax: - return - - # right mouse click or shift + left mouse click - # shift click doesn't work in osx backend - if (event.button == 3 or - (event.button == 1 and event.key == 'shift')): - plot.addPoints([int(event.xdata)], [int(event.ydata)], - updateLayer=1) - - def keyHomog(self, event, plot): - """Event handler for moving position using keyboard after clicking on a map. - - Parameters - ---------- - event : - Keypress event. - plot : defdap.plotting.MapPlot - Plot to monitor. - - """ - keys = ['left', 'right', 'up', 'down'] - key = event.key.split('+') - if key[-1] in keys: - # get the selected point - points = plot.imgLayers[plot.pointsLayerIDs[1]] - selPoint = points.get_offsets()[0] - - # check if a point is selected - if selPoint[0] is not None and selPoint[1] is not None: - # print(event.key) - move = 1 - if len(key) == 2 and key[0] == 'shift': - move = 10 - - if key[-1] == keys[0]: - selPoint[0] -= move - elif key[-1] == keys[1]: - selPoint[0] += move - elif key[-1] == keys[2]: - selPoint[1] -= move - elif key[-1] == keys[3]: - selPoint[1] += move - - plot.addPoints([selPoint[0]], [selPoint[1]], updateLayer=1) - - def clickSaveHomog(self, event, plot, binSize): - """Append the selected point on the map to homogPoints. - - Parameters - ---------- - event : - Button click event. - plot : defdap.plotting.MapPlot - Plot to monitor. - binSize : int, optional - Binning applied to image, if applicable. - - """ - # get the selected point - points = plot.imgLayers[plot.pointsLayerIDs[1]] - selPoint = points.get_offsets()[0] - - # Check if a point is selected - if selPoint[0] is not None and selPoint[1] is not None: - # remove selected point from plot - plot.addPoints([None], [None], updateLayer=1) - - # then scale and add to homog points list - selPoint = tuple((selPoint / binSize).round().astype(int)) - self.homogPoints.append(selPoint) - - # update the plotted homog points - homogPoints = np.array(self.homogPoints) * binSize - plot.addPoints(homogPoints[:, 0], homogPoints[:, 1], updateLayer=0) - - def updateHomogPoint(self, homogID, newPoint=None, delta=None): - """ - Update a homog point by either over writing it with a new point or - incrementing the current values. - - Parameters - ---------- - homogID : int - ID (place in list) of point to update or -1 for all. - newPoint : tuple, optional - (x, y) coordinates of new point. - delta : tuple, optional - Increments to current point (dx, dy). - - """ - if type(homogID) is not int: - raise Exception("homogID must be an integer.") - if homogID >= len(self.homogPoints): - raise Exception("homogID is out of range.") - - # Update all points - if homogID < 0: - for i in range(len(self.homogPoints)): - self.updateHomogPoint(homogID=i, delta=delta) - # Update a single point - else: - # overwrite point - if newPoint is not None: - if type(newPoint) is not tuple and len(newPoint) != 2: - raise Exception("newPoint must be a 2 component tuple") - - # increment current point - elif delta is not None: - if type(delta) is not tuple and len(delta) != 2: - raise Exception("delta must be a 2 component tuple") - newPoint = list(self.homogPoints[homogID]) - newPoint[0] += delta[0] - newPoint[1] += delta[1] - newPoint = tuple(newPoint) - - self.homogPoints[homogID] = newPoint - - @reportProgress("constructing neighbour network") - def buildNeighbourNetwork(self): + @report_progress("constructing neighbour network") + def build_neighbour_network(self): """Construct a list of neighbours """ + ## TODO: fix HRDIC NN # create network nn = nx.Graph() - nn.add_nodes_from(self.grainList) + nn.add_nodes_from(self.grains) - yLocs, xLocs = np.nonzero(self.boundaries) - totalPoints = len(xLocs) + y_locs, x_locs = np.nonzero(self.boundaries) + total_points = len(x_locs) - for iPoint, (x, y) in enumerate(zip(xLocs, yLocs)): + for i_point, (x, y) in enumerate(zip(x_locs, y_locs)): # report progress - yield iPoint / totalPoints + yield i_point / total_points - if (x == 0 or y == 0 or x == self.grains.shape[1] - 1 or - y == self.grains.shape[0] - 1): + if (x == 0 or y == 0 or x == self.data.grains.shape[1] - 1 or + y == self.data.grains.shape[0] - 1): # exclude boundary pixels of map continue @@ -433,10 +299,10 @@ def buildNeighbourNetwork(self): # use sets as they do not allow duplicate elements # minus 1 on all as the grain image starts labeling at 1 neighbours = { - self.grains[y + 1, x] - 1, - self.grains[y - 1, x] - 1, - self.grains[y, x + 1] - 1, - self.grains[y, x - 1] - 1 + self.data.grains[y + 1, x] - 1, + self.data.grains[y - 1, x] - 1, + self.data.grains[y, x + 1] - 1, + self.data.grains[y, x - 1] - 1 } # neighbours = set(neighbours) # remove boundary points (-2) and points in small @@ -445,29 +311,29 @@ def buildNeighbourNetwork(self): neighbours.discard(-3) neighbours = tuple(neighbours) - nunNeig = len(neighbours) - if nunNeig <= 1: + num_neigh = len(neighbours) + if num_neigh <= 1: continue - for i in range(nunNeig): - for j in range(i + 1, nunNeig): + for i in range(num_neigh): + for j in range(i + 1, num_neigh): # Add to network grain = self[neighbours[i]] - neiGrain = self[neighbours[j]] + neigh_grain = self[neighbours[j]] try: # look up boundary - nn[grain][neiGrain] + nn[grain][neigh_grain] except KeyError: # neighbour relation doesn't exist so add it - nn.add_edge(grain, neiGrain) + nn.add_edge(grain, neigh_grain) - self.neighbourNetwork = nn + self.neighbour_network = nn - def displayNeighbours(self, **kwargs): - return self.locateGrainID( - clickEvent=self.clickGrainNeighbours, **kwargs + def display_neighbours(self, **kwargs): + return self.locate_grain( + click_event=self.click_grain_neighbours, **kwargs ) - def clickGrainNeighbours(self, event, plot): + def click_grain_neighbours(self, event, plot): """Event handler to capture clicking and show neighbours of selected grain. Parameters @@ -483,34 +349,35 @@ def clickGrainNeighbours(self, event, plot): return # grain id of selected grain - grainId = int(self.grains[int(event.ydata), int(event.xdata)] - 1) - if grainId < 0: + grain_id = self.data.grains[int(event.ydata), int(event.xdata)] - 1 + if grain_id < 0: return - self.currGrainId = grainId - grain = self[grainId] + grain = self[grain_id] + self.sel_grain = grain # find first and second nearest neighbours - firstNeighbours = list(self.neighbourNetwork.neighbors(grain)) - highlightGrains = [grain] + firstNeighbours + first_neighbours = list(self.neighbour_network.neighbors(grain)) + highlight_grains = [grain] + first_neighbours - secondNeighbours = [] - for firstNeighbour in firstNeighbours: - trialSecondNeighbours = list( - self.neighbourNetwork.neighbors(firstNeighbour) + second_neighbours = [] + for firstNeighbour in first_neighbours: + trial_second_neighbours = list( + self.neighbour_network.neighbors(firstNeighbour) ) - for secondNeighbour in trialSecondNeighbours: - if (secondNeighbour not in highlightGrains and - secondNeighbour not in secondNeighbours): - secondNeighbours.append(secondNeighbour) - highlightGrains.extend(secondNeighbours) + for second_neighbour in trial_second_neighbours: + if (second_neighbour not in highlight_grains and + second_neighbour not in second_neighbours): + second_neighbours.append(second_neighbour) + highlight_grains.extend(second_neighbours) - highlightGrains = [grain.grainID for grain in highlightGrains] - highlightColours = ['white'] - highlightColours.extend(['yellow'] * len(firstNeighbours)) - highlightColours.append('green') + highlight_grains = [grain.grain_id for grain in highlight_grains] + highlight_colours = ['white'] + highlight_colours.extend(['yellow'] * len(first_neighbours)) + highlight_colours.append('green') # update the grain highlights layer in the plot - plot.addGrainHighlights(highlightGrains, grainColours=highlightColours) + plot.add_grain_highlights(highlight_grains, + grain_colours=highlight_colours) @property def proxigram(self): @@ -522,86 +389,215 @@ def proxigram(self): Distance from a grain boundary at each point in map. """ - self.calcProxigram(forceCalc=False) + self.calc_proxigram(force_calc=False) - return self.proxigramArr + return self.proxigram_arr - @reportProgress("calculating proxigram") - def calcProxigram(self, numTrials=500, forceCalc=True): + @report_progress("calculating proxigram") + def calc_proxigram(self, num_trials=500): """Calculate distance from a grain boundary at each point in map. Parameters ---------- - numTrials : int, optional + num_trials : int, optional number of trials. - forceCalc : bool, optional - Force calculation even is proxigramArr is populated. """ - if self.proxigramArr is not None and not forceCalc: - return - - proxBoundaries = np.copy(self.boundaries) - proxShape = proxBoundaries.shape - - # ebsd boundary arrays have extra boundary along right and - # bottom edge. These need to be removed right edge - if np.all(proxBoundaries[:, -1] == -1): - proxBoundaries[:, -1] = proxBoundaries[:, -2] - # bottom edge - if np.all(proxBoundaries[-1, :] == -1): - proxBoundaries[-1, :] = proxBoundaries[-2, :] - - # create list of positions of each boundary point - indexBoundaries = [] - for index, value in np.ndenumerate(proxBoundaries): - if value == -1: - indexBoundaries.append(index) - # add 0.5 to boundary coordiantes as they are placed on the + # add 0.5 to boundary coordinates as they are placed on the # bottom right edge pixels of grains - indexBoundaries = np.array(indexBoundaries) + 0.5 + index_boundaries = [t[::-1] for t in self.data.grain_boundaries.points] + index_boundaries = np.array(index_boundaries) + 0.5 # array of x and y coordinate of each pixel in the map - coords = np.zeros((2, proxShape[0], proxShape[1]), dtype=float) + coords = np.zeros((2,) + self.shape, dtype=float) coords[0], coords[1] = np.meshgrid( - range(proxShape[0]), range(proxShape[1]), indexing='ij' + range(self.shape[0]), range(self.shape[1]), indexing='ij' ) # array to store trial distance from each boundary point - trialDistances = np.full((numTrials + 1, proxShape[0], proxShape[1]), - 1000, dtype=float) + trial_distances = np.full((num_trials + 1,) + self.shape, + 1000, dtype=float) # loop over each boundary point (p) and calculate distance from # p to all points in the map store minimum once numTrails have # been made and start a new batch of trials - numBoundaryPoints = len(indexBoundaries) + num_boundary_points = len(index_boundaries) j = 1 - for i, indexBoundary in enumerate(indexBoundaries): - trialDistances[j] = np.sqrt((coords[0] - indexBoundary[0])**2 - + (coords[1] - indexBoundary[1])**2) + for i, index_boundary in enumerate(index_boundaries): + trial_distances[j] = np.sqrt((coords[0] - index_boundary[0])**2 + + (coords[1] - index_boundary[1])**2) - if j == numTrials: + if j == num_trials: # find current minimum distances and store - trialDistances[0] = trialDistances.min(axis=0) + trial_distances[0] = trial_distances.min(axis=0) j = 0 # report progress - yield i / numBoundaryPoints + yield i / num_boundary_points j += 1 # find final minimum distances to a boundary - self.proxigramArr = trialDistances.min(axis=0) + return trial_distances.min(axis=0) + + def _validate_map(self, map_name): + """Check the name exists and is a map data. + + Parameters + ---------- + map_name : str + + """ + if map_name not in self.data: + raise ValueError(f'`{map_name}` does not exist.') + if (self.data.get_metadata(map_name, 'type') != 'map' or + self.data.get_metadata(map_name, 'order') is None): + raise ValueError(f'`{map_name}` is not a valid map.') + + def _validate_component(self, map_name, comp): + """ + + Parameters + ---------- + map_name : str + comp : int or tuple of int or str + Component of the map data. This is either the + tensor component (tuple of ints) or the name of a calculation + to be applied e.g. 'norm', 'all_euler' or 'IPF_x'. + + Returns + ------- + tuple of int or str + + """ + order = self.data[map_name, 'order'] + if comp is None: + comp = self.data.get_metadata(map_name, 'default_component') + if comp is not None: + print(f'Using default component: `{comp}`') + + if comp is None: + if order != 0: + raise ValueError('`comp` must be specified.') + else: + return comp + + if isinstance(comp, int): + comp = (comp,) + if isinstance(comp, tuple) and len(comp) != order: + raise ValueError(f'Component length does not match data, expected ' + f'{self.data[map_name, "order"]} values but got ' + f'{len(comp)}.') + + return comp - trialDistances = None + def _extract_component(self, map_data, comp): + """Extract a component from the data. + + Parameters + ---------- + map_data : numpy.ndarray + Map data to extract from. + comp : tuple of int or str + Component of the map data to extract. This is either the + tensor component (tuple of ints) or the name of a calculation + to be applied e.g. 'norm', 'all_euler' or 'IPF_x'. + + Returns + ------- + numpy.ndarray + + """ + if comp is None: + return map_data + if isinstance(comp, tuple): + return map_data[comp] + if isinstance(comp, str): + comp = comp.lower() + if comp == 'norm': + if len(map_data.shape) == 3: + axis = 0 + elif len(map_data.shape) == 4: + axis = (0, 1) + else: + raise ValueError('Unsupported data for norm.') + + return np.linalg.norm(map_data, axis=axis) + + if comp == 'all_euler': + return self.calc_euler_colour(map_data) + + if comp.startswith('ipf'): + direction = comp.split('_')[1] + direction = { + 'x': np.array([1, 0, 0]), + 'y': np.array([0, 1, 0]), + 'z': np.array([0, 0, 1]), + }[direction] + return self.calc_ipf_colour(map_data, direction) + + raise ValueError(f'Invalid component `{comp}`') + + def plot_map(self, map_name, component=None, **kwargs): + """Plot a map of the data. + + Parameters + ---------- + map_name : str + Map data name to plot i.e. e, max_shear, euler_angle, orientation. + component : int or tuple of int or str + Component of the map data to plot. This is either the tensor + component (int or tuple of ints) or the name of a calculation + to be applied e.g. 'norm', 'all_euler' or 'IPF_x'. + kwargs + All arguments are passed to :func:`defdap.plotting.MapPlot.create`. - def calcGrainAv(self, mapData, grainIds=-1): + Returns + ------- + defdap.plotting.MapPlot + Plot containing map. + + """ + self._validate_map(map_name) + comp = self._validate_component(map_name, component) + + # Set default plot parameters then update with any input + plot_params = {} # should load default plotting params + plot_params.update(self.data.get_metadata(map_name, 'plot_params', {})) + + # Add extra info to label + clabel = plot_params.get('clabel') + if clabel is not None: + # tensor component + if isinstance(comp, tuple): + comp_fmt = ' (' + '{}' * len(comp) + ')' + clabel += comp_fmt.format(*(i+1 for i in comp)) + elif isinstance(comp, str): + clabel += f' ({comp.replace("_", " ")})' + # unit + unit = self.data.get_metadata(map_name, 'unit') + if unit is not None and unit != '': + clabel += f' ({unit})' + + plot_params['clabel'] = clabel + + if self.scale is not None: + binning = self.data.get_metadata(map_name, 'binning', 1) + plot_params['scale'] = self.scale / binning + + plot_params.update(kwargs) + + map_data = self._extract_component(self.data[map_name], comp) + + return MapPlot.create(self, map_data, **plot_params) + + def calc_grain_average(self, map_data, grain_ids=-1): """Calculate grain average of any DIC map data. Parameters ---------- - mapData : numpy.ndarray + map_data : numpy.ndarray Array of map data to grain average. This must be cropped! - grainIds : list, optional - grainIDs to perform operation on, set to -1 for all grains. + grain_ids : list, optional + grain_ids to perform operation on, set to -1 for all grains. Returns ------- @@ -609,72 +605,73 @@ def calcGrainAv(self, mapData, grainIds=-1): Array containing the grain average values. """ + if type(grain_ids) is int and grain_ids == -1: + grain_ids = range(len(self)) - # Check that grains have been detected in the map - self.checkGrainsDetected() + grain_average_data = np.zeros(len(grain_ids)) - if type(grainIds) is int and grainIds == -1: - grainIds = range(len(self)) + for i, grainId in enumerate(grain_ids): + grain = self[grainId] + grainData = grain.grain_data(map_data) + grain_average_data[i] = grainData.mean() - grainAvData = np.zeros(len(grainIds)) + return grain_average_data - for i, grainId in enumerate(grainIds): - grain = self[grainId] - grainData = grain.grainData(mapData) - grainAvData[i] = grainData.mean() + def grain_data_to_map(self, name): + map_data = np.zeros(self[0].data[name].shape[:-1] + self.shape) + for grain in self: + for i, point in enumerate(grain.data.point): + map_data[..., point[1], point[0]] = grain.data[name][..., i] - return grainAvData + return map_data - def grainDataToMapData(self, grainData, grainIds=-1, bg=0): + def grain_data_to_map_data(self, grain_data, grain_ids=-1, bg=0): """Create a map array with each grain filled with the given values. Parameters ---------- - grainData : list or numpy.ndarray + grain_data : list or numpy.ndarray Grain values. This can be a single value per grain or RGB values. - grainIds : list of int or int, optional + grain_ids : list of int or int, optional IDs of grains to plot for. Use -1 for all grains in the map. bg : int or real, optional Value to fill the background with. Returns ------- - grainMap: numpy.ndarray + grain_map: numpy.ndarray Array filled with grain data values """ - # Check that grains have been detected in the map - self.checkGrainsDetected() - - if type(grainIds) is int: - if grainIds == -1: - grainIds = range(len(self)) + if type(grain_ids) is int: + if grain_ids == -1: + grain_ids = range(len(self)) else: - grainIds = [grainIds] + grain_ids = [grain_ids] - grainData = np.array(grainData) - if grainData.shape[0] != len(grainIds): + grain_data = np.array(grain_data) + if grain_data.shape[0] != len(grain_ids): raise ValueError("The length of supplied grain data does not" "match the number of grains.") - if len(grainData.shape) == 1: - mapShape = [self.yDim, self.xDim] - elif len(grainData.shape) == 2 and grainData.shape[1] == 3: - mapShape = [self.yDim, self.xDim, 3] + if len(grain_data.shape) == 1: + mapShape = [self.y_dim, self.x_dim] + elif len(grain_data.shape) == 2 and grain_data.shape[1] == 3: + mapShape = [self.y_dim, self.x_dim, 3] else: raise ValueError("The grain data supplied must be either a" "single value or RGB values per grain.") - grainMap = np.full(mapShape, bg, dtype=grainData.dtype) - for grainId, grainValue in zip(grainIds, grainData): - for coord in self[grainId].coordList: - grainMap[coord[1], coord[0]] = grainValue + grain_map = np.full(mapShape, bg, dtype=grain_data.dtype) + for grainId, grain_value in zip(grain_ids, grain_data): + for point in self[grainId].data.point: + grain_map[point[1], point[0]] = grain_value - return grainMap + return grain_map - def plotGrainDataMap( - self, mapData=None, grainData=None, grainIds=-1, bg=0, **kwargs + def plot_grain_data_map( + self, map_data=None, grain_data=None, grain_ids=-1, bg=0, **kwargs ): """Plot a grain map with grains coloured by given data. The data can be provided as a list of values per grain or as a map which @@ -682,13 +679,13 @@ def plotGrainDataMap( Parameters ---------- - mapData : numpy.ndarray, optional + map_data : numpy.ndarray, optional Array of map data. This must be cropped! Either mapData or - grainData must be supplied. - grainData : list or np.array, optional + grain_data must be supplied. + grain_data : list or np.array, optional Grain values. This an be a single value per grain or RGB - values. You must supply either mapData or grainData. - grainIds: list of int or int, optional + values. You must supply either mapData or grain_data. + grain_ids: list of int or int, optional IDs of grains to plot for. Use -1 for all grains in the map. bg: int or real, optional Value to fill the background with. @@ -702,25 +699,25 @@ def plotGrainDataMap( """ # Set default plot parameters then update with any input - plotParams = {} - plotParams.update(kwargs) + plot_params = {} + plot_params.update(kwargs) - if grainData is None: - if mapData is None: - raise ValueError("Either 'mapData' or 'grainData' must " + if grain_data is None: + if map_data is None: + raise ValueError("Either 'mapData' or 'grain_data' must " "be supplied.") else: - grainData = self.calcGrainAv(mapData, grainIds=grainIds) + grain_data = self.calc_grain_average(map_data, grain_ids=grain_ids) - grainMap = self.grainDataToMapData(grainData, grainIds=grainIds, - bg=bg) + grain_map = self.grain_data_to_map_data(grain_data, grain_ids=grain_ids, + bg=bg) - plot = MapPlot.create(self, grainMap, **plotParams) + plot = MapPlot.create(self, grain_map, **plot_params) return plot - def plotGrainDataIPF( - self, direction, mapData=None, grainData=None, grainIds=-1, + def plot_grain_data_ipf( + self, direction, map_data=None, grain_data=None, grain_ids=-1, **kwargs ): """ @@ -731,79 +728,87 @@ def plotGrainDataIPF( ---------- direction : numpy.ndarray Vector of reference direction for the IPF. - mapData : numpy.ndarray + map_data : numpy.ndarray Array of map data. This must be cropped! Either mapData or - grainData must be supplied. - grainData : list or np.array, optional + grain_data must be supplied. + grain_data : list or np.array, optional Grain values. This an be a single value per grain or RGB - values. You must supply either mapData or grainData. - grainIds: list of int or int, optional + values. You must supply either mapData or grain_data. + grain_ids: list of int or int, optional IDs of grains to plot for. Use -1 for all grains in the map. kwargs : dict, optional - Keyword arguments passed to :func:`defdap.quat.Quat.plotIPF` + Keyword arguments passed to :func:`defdap.quat.Quat.plot_ipf` """ # Set default plot parameters then update with any input - plotParams = {} - plotParams.update(kwargs) + plot_params = {} + plot_params.update(kwargs) - if grainData is None: - if mapData is None: - raise ValueError("Either 'mapData' or 'grainData' must " + if grain_data is None: + if map_data is None: + raise ValueError("Either 'mapData' or 'grain_data' must " "be supplied.") else: - grainData = self.calcGrainAv(mapData, grainIds=grainIds) - - # Check that grains have been detected in the map - self.checkGrainsDetected() + grain_data = self.calc_grain_average(map_data, grain_ids=grain_ids) - if type(grainIds) is int and grainIds == -1: - grainIds = range(len(self)) + if type(grain_ids) is int and grain_ids == -1: + grain_ids = range(len(self)) - if len(grainData) != len(grainIds): - raise Exception("Must be 1 value for each grain in grainData.") + if len(grain_data) != len(grain_ids): + raise Exception("Must be 1 value for each grain in grain_data.") - grainOri = np.empty(len(grainIds), dtype=Quat) + grain_ori = np.empty(len(grain_ids), dtype=Quat) - for i, grainId in enumerate(grainIds): + for i, grainId in enumerate(grain_ids): grain = self[grainId] - grainOri[i] = grain.refOri + grain_ori[i] = grain.ref_ori - plot = Quat.plotIPF(grainOri, direction, self.crystalSym, - c=grainData, **plotParams) + plot = Quat.plot_ipf(grain_ori, direction, self.crystal_sym, + c=grain_data, **plot_params) return plot -class Grain(object): +class Grain(ABC): """ Base class for a grain. Attributes ---------- - grainID : int - - ownerMap : defdap.base.Map - - coordList : list of tuples + grain_id : int + owner_map : defdap.base.Map """ - def __init__(self, grainID, ownerMap): + def __init__(self, grain_id, owner_map, group_id): + self.data = Datastore(group_id=group_id) + self.data.add_derivative( + owner_map.data, self.grain_data, + in_props={ + 'type': 'map' + }, + out_props={ + 'type': 'list' + } + ) + self.data.add( + 'point', [], + unit='', type='list', order=1 + ) + # list of coords stored as tuples (x, y). These are coords in a # cropped image if crop exists. - self.grainID = grainID - self.ownerMap = ownerMap - self.coordList = [] + self.grain_id = grain_id + self.owner_map = owner_map def __len__(self): - return len(self.coordList) + return len(self.data.point) def __str__(self): - return f"Grain(ID={self.grainID})" + return f"Grain(ID={self.grain_id})" @property - def extremeCoords(self): + def extreme_coords(self): """Coordinates of the bounding box for a grain. Returns @@ -812,24 +817,19 @@ def extremeCoords(self): minimum x, minimum y, maximum x, maximum y. """ - coords = np.array(self.coordList, dtype=int) + return *self.data.point.min(axis=0), *self.data.point.max(axis=0) - x0, y0 = coords.min(axis=0) - xmax, ymax = coords.max(axis=0) - - return x0, y0, xmax, ymax - - def centreCoords(self, centreType="box", grainCoords=True): + def centre_coords(self, centre_type="box", grain_coords=True): """ Calculates the centre of the grain, either as the centre of the bounding box or the grains centre of mass. Parameters ---------- - centreType : str, optional, {'box', 'com'} + centre_type : str, optional, {'box', 'com'} Set how to calculate the centre. Either 'box' for centre of bounding box or 'com' for centre of mass. Default is 'box'. - grainCoords : bool, optional + grain_coords : bool, optional If set True the centre is returned in the grain coordinates otherwise in the map coordinates. Defaults is grain. @@ -839,22 +839,22 @@ def centreCoords(self, centreType="box", grainCoords=True): Coordinates of centre of grain. """ - x0, y0, xmax, ymax = self.extremeCoords - if centreType == "box": - xCentre = round((xmax + x0) / 2) - yCentre = round((ymax + y0) / 2) - elif centreType == "com": - xCentre, yCentre = np.array(self.coordList).mean(axis=0).round() + x0, y0, xmax, ymax = self.extreme_coords + if centre_type == "box": + x_centre = round((xmax + x0) / 2) + y_centre = round((ymax + y0) / 2) + elif centre_type == "com": + x_centre, y_centre = self.data.point.mean(axis=0).round() else: raise ValueError("centreType must be box or com") - if grainCoords: - xCentre -= x0 - yCentre -= y0 + if grain_coords: + x_centre -= x0 + y_centre -= y0 - return int(xCentre), int(yCentre) + return int(x_centre), int(y_centre) - def grainOutline(self, bg=np.nan, fg=0): + def grain_outline(self, bg=np.nan, fg=0): """Generate an array of the grain outline. Parameters @@ -870,27 +870,27 @@ def grainOutline(self, bg=np.nan, fg=0): Bounding box for grain with :obj:`~numpy.nan` outside the grain and given number within. """ - x0, y0, xmax, ymax = self.extremeCoords + x0, y0, xmax, ymax = self.extreme_coords # initialise array with nans so area not in grain displays white outline = np.full((ymax - y0 + 1, xmax - x0 + 1), bg, dtype=int) - for coord in self.coordList: + for coord in self.data.point: outline[coord[1] - y0, coord[0] - x0] = fg return outline - def plotOutline(self, ax=None, plotScaleBar=False, **kwargs): + def plot_outline(self, ax=None, plot_scale_bar=False, **kwargs): """Plot the outline of the grain. Parameters ---------- ax : matplotlib.axes.Axes axis to plot on, if not provided the current active axis is used. - plotScaleBar : bool + plot_scale_bar : bool plots the scale bar on the grain if true. kwargs : dict - keyword arguments passed to :func:`defdap.plotting.GrainPlot.addMap` + keyword arguments passed to :func:`defdap.plotting.GrainPlot.add_map` Returns ------- @@ -898,19 +898,19 @@ def plotOutline(self, ax=None, plotScaleBar=False, **kwargs): """ plot = plotting.GrainPlot(self, ax=ax) - plot.addMap(self.grainOutline(), **kwargs) + plot.addMap(self.grain_outline(), **kwargs) - if plotScaleBar: - plot.addScaleBar() + if plot_scale_bar: + plot.add_scale_bar() return plot - def grainData(self, mapData): + def grain_data(self, map_data): """Extract this grains data from the given map data. Parameters ---------- - mapData : numpy.ndarray + map_data : numpy.ndarray Array of map data. This must be cropped! Returns @@ -919,24 +919,19 @@ def grainData(self, mapData): Array containing this grains values from the given map data. """ - grainData = np.zeros(len(self), dtype=mapData.dtype) - - for i, coord in enumerate(self.coordList): - grainData[i] = mapData[coord[1], coord[0]] + return map_data[..., self.data.point[:, 1], self.data.point[:, 0]] - return grainData - - def grainMapData(self, mapData=None, grainData=None, bg=np.nan): + def grain_map_data(self, map_data=None, grain_data=None, bg=np.nan): """Extract a single grain map from the given map data. Parameters ---------- - mapData : numpy.ndarray + map_data : numpy.ndarray Array of map data. This must be cropped! Either this or - 'grainData' must be supplied and 'grainData' takes precedence. - grainData : numpy.ndarray + 'grain_data' must be supplied and 'grain_data' takes precedence. + grain_data : numpy.ndarray Array of data at each point in the grain. Either this or - 'mapData' must be supplied and 'grainData' takes precedence. + 'mapData' must be supplied and 'grain_data' takes precedence. bg : various, optional Value to fill the background with. Must be same dtype as input array. @@ -947,38 +942,38 @@ def grainMapData(self, mapData=None, grainData=None, bg=np.nan): Grain map extracted from given data. """ - if grainData is None: - if mapData is None: - raise ValueError("Either 'mapData' or 'grainData' must " + if grain_data is None: + if map_data is None: + raise ValueError("Either 'mapData' or 'grain_data' must " "be supplied.") else: - grainData = self.grainData(mapData) - x0, y0, xmax, ymax = self.extremeCoords + grain_data = self.grain_data(map_data) + x0, y0, xmax, ymax = self.extreme_coords - grainMapData = np.full((ymax - y0 + 1, xmax - x0 + 1), bg, - dtype=type(grainData[0])) + grain_map_data = np.full((ymax - y0 + 1, xmax - x0 + 1), bg, + dtype=type(grain_data[0])) - for coord, data in zip(self.coordList, grainData): - grainMapData[coord[1] - y0, coord[0] - x0] = data + for coord, data in zip(self.data.point, grain_data): + grain_map_data[coord[1] - y0, coord[0] - x0] = data - return grainMapData + return grain_map_data - def grainMapDataCoarse(self, mapData=None, grainData=None, - kernelSize=2, bg=np.nan): + def grain_map_data_coarse(self, map_data=None, grain_data=None, + kernel_size=2, bg=np.nan): """ - Create a coarsed data map of this grain only from the given map + Create a coarsened data map of this grain only from the given map data. Data is coarsened using a kernel at each pixel in the grain using only data in this grain. Parameters ---------- - mapData : numpy.ndarray + map_data : numpy.ndarray Array of map data. This must be cropped! Either this or - 'grainData' must be supplied and 'grainData' takes precedence. - grainData : numpy.ndarray + 'grain_data' must be supplied and 'grain_data' takes precedence. + grain_data : numpy.ndarray List of data at each point in the grain. Either this or - 'mapData' must be supplied and 'grainData' takes precedence. - kernelSize : int, optional + 'mapData' must be supplied and 'grain_data' takes precedence. + kernel_size : int, optional Size of kernel as the number of pixels to dilate by i.e 1 gives a 3x3 kernel. bg : various, optional @@ -991,68 +986,219 @@ def grainMapDataCoarse(self, mapData=None, grainData=None, Map of this grains coarsened data. """ - grainMapData = self.grainMapData(mapData=mapData, grainData=grainData) - grainMapDataCoarse = np.full_like(grainMapData, np.nan) + grain_map_data = self.grain_map_data(map_data=map_data, grain_data=grain_data) + grain_map_data_coarse = np.full_like(grain_map_data, np.nan) - for i, j in np.ndindex(grainMapData.shape): - if np.isnan(grainMapData[i, j]): - grainMapDataCoarse[i, j] = bg + for i, j in np.ndindex(grain_map_data.shape): + if np.isnan(grain_map_data[i, j]): + grain_map_data_coarse[i, j] = bg else: - coarseValue = 0 + coarse_value = 0 - if i - kernelSize >= 0: - yLow = i - kernelSize + if i - kernel_size >= 0: + yLow = i - kernel_size else: yLow = 0 - if i + kernelSize + 1 <= grainMapData.shape[0]: - yHigh = i + kernelSize + 1 + if i + kernel_size + 1 <= grain_map_data.shape[0]: + yHigh = i + kernel_size + 1 else: - yHigh = grainMapData.shape[0] - if j - kernelSize >= 0: - xLow = j - kernelSize + yHigh = grain_map_data.shape[0] + if j - kernel_size >= 0: + x_low = j - kernel_size else: - xLow = 0 - if j + kernelSize + 1 <= grainMapData.shape[1]: - xHigh = j + kernelSize + 1 + x_low = 0 + if j + kernel_size + 1 <= grain_map_data.shape[1]: + x_high = j + kernel_size + 1 else: - xHigh = grainMapData.shape[1] + x_high = grain_map_data.shape[1] - numPoints = 0 + num_points = 0 for k in range(yLow, yHigh): - for l in range(xLow, xHigh): - if not np.isnan(grainMapData[k, l]): - coarseValue += grainMapData[k, l] - numPoints += 1 + for l in range(x_low, x_high): + if not np.isnan(grain_map_data[k, l]): + coarse_value += grain_map_data[k, l] + num_points += 1 - if numPoints > 0: - grainMapDataCoarse[i, j] = coarseValue / numPoints + if num_points > 0: + grain_map_data_coarse[i, j] = coarse_value / num_points else: - grainMapDataCoarse[i, j] = np.nan + grain_map_data_coarse[i, j] = np.nan - return grainMapDataCoarse + return grain_map_data_coarse - def plotGrainData(self, mapData=None, grainData=None, **kwargs): + def plot_grain_data(self, map_data=None, grain_data=None, **kwargs): """ Plot a map of this grain from the given map data. Parameters ---------- - mapData : numpy.ndarray + map_data : numpy.ndarray Array of map data. This must be cropped! Either this or - 'grainData' must be supplied and 'grainData' takes precedence. - grainData : numpy.ndarray + 'grain_data' must be supplied and 'grain_data' takes precedence. + grain_data : numpy.ndarray List of data at each point in the grain. Either this or - 'mapData' must be supplied and 'grainData' takes precedence. + 'mapData' must be supplied and 'grain_data' takes precedence. kwargs : dict, optional Keyword arguments passed to :func:`defdap.plotting.GrainPlot.create` """ # Set default plot parameters then update with any input - plotParams = {} - plotParams.update(kwargs) + plot_params = {} + plot_params.update(kwargs) - grainMapData = self.grainMapData(mapData=mapData, grainData=grainData) + grain_map_data = self.grain_map_data(map_data=map_data, grain_data=grain_data) - plot = GrainPlot.create(self, grainMapData, **plotParams) + plot = GrainPlot.create(self, grain_map_data, **plot_params) return plot + + def _validate_list(self, list_name): + """Check the name exists and is a list data. + + Parameters + ---------- + list_name : str + + """ + if list_name not in self.data: + raise ValueError(f'`{list_name}` does not exist.') + if (self.data.get_metadata(list_name, 'type') != 'list' or + self.data.get_metadata(list_name, 'order') is None): + raise ValueError(f'`{list_name}` is not a valid data.') + + def _validate_component(self, map_name, comp): + """ + + Parameters + ---------- + map_name : str + comp : int or tuple of int or str + Component of the map data. This is either the + tensor component (tuple of ints) or the name of a calculation + to be applied e.g. 'norm', 'all_euler' or 'IPF_x'. + + Returns + ------- + tuple of int or str + + """ + order = self.data[map_name, 'order'] + if comp is None: + comp = self.data.get_metadata(map_name, 'default_component') + if comp is not None: + print(f'Using default component: `{comp}`') + + if comp is None: + if order != 0: + raise ValueError('`comp` must be specified.') + else: + return comp + + if isinstance(comp, int): + comp = (comp,) + if isinstance(comp, tuple) and len(comp) != order: + raise ValueError(f'Component length does not match data, expected ' + f'{self.data[map_name, "order"]} values but got ' + f'{len(comp)}.') + + return comp + + def _extract_component(self, map_data, comp): + """Extract a component from the data. + + Parameters + ---------- + map_data : numpy.ndarray + Map data to extract from. + comp : tuple of int or str + Component of the map data to extract. This is either the + tensor component (tuple of ints) or the name of a calculation + to be applied e.g. 'norm', 'all_euler' or 'IPF_x'. + + Returns + ------- + numpy.ndarray + + """ + if comp is None: + return map_data + if isinstance(comp, tuple): + return map_data[comp] + if isinstance(comp, str): + comp = comp.lower() + if comp == 'norm': + if len(map_data.shape) == 2: + axis = 0 + elif len(map_data.shape) == 3: + axis = (0, 1) + else: + raise ValueError('Unsupported data for norm.') + + return np.linalg.norm(map_data, axis=axis) + + if comp == 'all_euler': + return self.calc_euler_colour(map_data) + + if comp.startswith('ipf'): + direction = comp.split('_')[1] + direction = { + 'x': np.array([1, 0, 0]), + 'y': np.array([0, 1, 0]), + 'z': np.array([0, 0, 1]), + }[direction] + return self.calc_ipf_colour(map_data, direction) + + raise ValueError(f'Invalid component `{comp}`') + + def plot_map(self, map_name, component=None, **kwargs): + """Plot a map of the data. + + Parameters + ---------- + map_name : str + Map data name to plot i.e. e, max_shear, euler_angle, orientation. + component : int or tuple of int or str + Component of the map data to plot. This is either the tensor + component (int or tuple of ints) or the name of a calculation + to be applied e.g. 'norm', 'all_euler' or 'IPF_x'. + kwargs + All arguments are passed to :func:`defdap.plotting.MapPlot.create`. + + Returns + ------- + defdap.plotting.MapPlot + Plot containing map. + + """ + self._validate_list(map_name) + comp = self._validate_component(map_name, component) + + # Set default plot parameters then update with any input + plot_params = {} # should load default plotting params + plot_params.update(self.data.get_metadata(map_name, 'plot_params', {})) + + # Add extra info to label + clabel = plot_params.get('clabel') + if clabel is not None: + # tensor component + if isinstance(comp, tuple): + comp_fmt = ' (' + '{}' * len(comp) + ')' + clabel += comp_fmt.format(*(i+1 for i in comp)) + elif isinstance(comp, str): + clabel += f' ({comp.replace("_", " ")})' + # unit + unit = self.data.get_metadata(map_name, 'unit') + if unit is not None and unit != '': + clabel += f' ({unit})' + + plot_params['clabel'] = clabel + + if self.owner_map.scale is not None: + binning = self.data.get_metadata(map_name, 'binning', 1) + plot_params['scale'] = self.owner_map.scale / binning + + plot_params.update(kwargs) + + list_data = self._extract_component(self.data[map_name], comp) + + return self.plot_grain_data(grain_data=list_data, **plot_params) diff --git a/defdap/crystal.py b/defdap/crystal.py index 467a7b4..b38c418 100755 --- a/defdap/crystal.py +++ b/defdap/crystal.py @@ -1,4 +1,4 @@ -# Copyright 2021 Mechanics of Microstructures Group +# Copyright 2025 Mechanics of Microstructures Group # at The University of Manchester # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,81 +19,83 @@ from defdap import defaults from defdap.quat import Quat +from defdap.crystal_utils import * class Phase(object): - def __init__(self, name, laueGroup, spaceGroup, latticeParams): + def __init__(self, name, laue_group, space_group, lattice_params): """ Parameters ---------- name : str Name of the phase - laueGroup : int + laue_group : int Laue group - spaceGroup : int + space_group : int Space group - latticeParams : tuple + lattice_params : tuple Lattice parameters in order (a,b,c,alpha,beta,gamma) """ self.name = name - self.laueGroup = laueGroup - self.spaceGroup = spaceGroup - self.latticeParams = latticeParams + self.laue_group = laue_group + self.spaceGroup = space_group + self.lattice_params = lattice_params try: - self.crystalStructure = { + self.crystal_structure = { 9: crystalStructures['hexagonal'], 11: crystalStructures['cubic'], - }[laueGroup] + }[laue_group] except KeyError: - raise ValueError(f"Unknown Laue group key: {laueGroup}") + raise ValueError(f"Unknown Laue group key: {laue_group}") - if self.crystalStructure is crystalStructures['hexagonal']: + if self.crystal_structure is crystalStructures['hexagonal']: self.ss_file = defaults['slip_system_file']['HCP'] else: try: self.ss_file = defaults['slip_system_file'][ - {225: 'FCC', 229: 'BCC'}[spaceGroup] + {225: 'FCC', 229: 'BCC'}[space_group] + # See http://pd.chem.ucl.ac.uk/pdnn/symm3/allsgp.htm ] except KeyError: self.ss_file = None if self.ss_file is None: - self.slipSystems = None - self.slipTraceColours = None + self.slip_systems = None + self.slip_trace_colours = None else: - self.slipSystems, self.slipTraceColours = SlipSystem.load( - self.ss_file, self.crystalStructure, cOverA=self.cOverA + self.slip_systems, self.slip_trace_colours = SlipSystem.load( + self.ss_file, self.crystal_structure, c_over_a=self.c_over_a ) def __str__(self): text = ("Phase: {:}\n Crystal structure: {:}\n Lattice params: " "({:.2f}, {:.2f}, {:.2f}, {:.0f}, {:.0f}, {:.0f})\n" " Slip systems: {:}") - return text.format(self.name, self.crystalStructure.name, - *self.latticeParams[:3], - *np.array(self.latticeParams[3:])*180/np.pi, + return text.format(self.name, self.crystal_structure.name, + *self.lattice_params[:3], + *np.array(self.lattice_params[3:]) * 180 / np.pi, self.ss_file) @property - def cOverA(self): - if self.crystalStructure is crystalStructures['hexagonal']: - return self.latticeParams[2] / self.latticeParams[0] + def c_over_a(self): + if self.crystal_structure is crystalStructures['hexagonal']: + return self.lattice_params[2] / self.lattice_params[0] return None - def printSlipSystems(self): + def print_slip_systems(self): """Print a list of slip planes (with colours) and slip directions. """ # TODO: this should be moved to static method of the SlipSystem class - for i, (ssGroup, colour) in enumerate(zip(self.slipSystems, - self.slipTraceColours)): + for i, (ss_group, colour) in enumerate(zip(self.slip_systems, + self.slip_trace_colours)): print('Plane {0}: {1}\tColour: {2}'.format( - i, ssGroup[0].slipPlaneLabel, colour + i, ss_group[0].slip_plane_label, colour )) - for j, ss in enumerate(ssGroup): - print(' Direction {0}: {1}'.format(j, ss.slipDirLabel)) + for j, ss in enumerate(ss_group): + print(' Direction {0}: {1}'.format(j, ss.slip_dir_label)) class CrystalStructure(object): @@ -103,83 +105,11 @@ def __init__(self, name, symmetries, vertices, faces): self.vertices = vertices self.faces = faces - # TODO: Move these to the phase class where the lattice parameters - # can be accessed - @staticmethod - def lMatrix(a, b, c, alpha, beta, gamma, convention=None): - """ Construct L matrix based on Page 22 of - Randle and Engle - Introduction to texture analysis""" - lMatrix = np.zeros((3, 3)) - - cosAlpha = np.cos(alpha) - cosBeta = np.cos(beta) - cosGamma = np.cos(gamma) - - sinGamma = np.sin(gamma) - - lMatrix[0, 0] = a - lMatrix[0, 1] = b * cosGamma - lMatrix[0, 2] = c * cosBeta - - lMatrix[1, 1] = b * sinGamma - lMatrix[1, 2] = c * (cosAlpha - cosBeta * cosGamma) / sinGamma - - lMatrix[2, 2] = c * np.sqrt( - 1 + 2 * cosAlpha * cosBeta * cosGamma - - cosAlpha**2 - cosBeta**2 - cosGamma**2 - ) / sinGamma - - # OI/HKL convention - x // [10-10], y // a2 [-12-10] - # TSL convention - x // a1 [2-1-10], y // [01-10] - if convention is None: - convention = defaults['crystal_ortho_conv'] - - if convention.lower() in ['hkl', 'oi']: - # Swap 00 with 11 and 01 with 10 due to how OI orthonormalises - # From Brad Wynne - t1 = lMatrix[0, 0] - t2 = lMatrix[1, 0] - - lMatrix[0, 0] = lMatrix[1, 1] - lMatrix[1, 0] = lMatrix[0, 1] - - lMatrix[1, 1] = t1 - lMatrix[0, 1] = t2 - - elif convention.lower() != 'tsl': - raise ValueError( - f"Unknown convention '{convention}' for orthonormalisation of " - f"crystal structure, can be 'hkl' or 'tsl'" - ) - - # Set small components to 0 - lMatrix[np.abs(lMatrix) < 1e-10] = 0 - - return lMatrix - - @staticmethod - def qMatrix(lMatrix): - """ Construct matrix of reciprocal lattice vectors to transform - plane normals See C. T. Young and J. L. Lytton, J. Appl. Phys., - vol. 43, no. 4, pp. 1408–1417, 1972.""" - a = lMatrix[:, 0] - b = lMatrix[:, 1] - c = lMatrix[:, 2] - - volume = abs(np.dot(a, np.cross(b, c))) - aStar = np.cross(b, c) / volume - bStar = np.cross(c, a) / volume - cStar = np.cross(a, b) / volume - qMatrix = np.stack((aStar, bStar, cStar), axis=1) - - return qMatrix - - -overRoot2 = np.sqrt(2) / 2 +over_root2 = np.sqrt(2) / 2 sqrt3over2 = np.sqrt(3) / 2 # Use ideal ratio as only used for plotting unit cell -cOverA = 1.633 / 2 +c_over_a = 1.633 / 2 crystalStructures = { "cubic": CrystalStructure( @@ -189,23 +119,23 @@ def qMatrix(lMatrix): Quat(1.0, 0.0, 0.0, 0.0), # cubic tetrads(100) - Quat(overRoot2, overRoot2, 0.0, 0.0), + Quat(over_root2, over_root2, 0.0, 0.0), Quat(0.0, 1.0, 0.0, 0.0), - Quat(overRoot2, -overRoot2, 0.0, 0.0), - Quat(overRoot2, 0.0, overRoot2, 0.0), + Quat(over_root2, -over_root2, 0.0, 0.0), + Quat(over_root2, 0.0, over_root2, 0.0), Quat(0.0, 0.0, 1.0, 0.0), - Quat(overRoot2, 0.0, -overRoot2, 0.0), - Quat(overRoot2, 0.0, 0.0, overRoot2), + Quat(over_root2, 0.0, -over_root2, 0.0), + Quat(over_root2, 0.0, 0.0, over_root2), Quat(0.0, 0.0, 0.0, 1.0), - Quat(overRoot2, 0.0, 0.0, -overRoot2), + Quat(over_root2, 0.0, 0.0, -over_root2), # cubic dyads (110) - Quat(0.0, overRoot2, overRoot2, 0.0), - Quat(0.0, -overRoot2, overRoot2, 0.0), - Quat(0.0, overRoot2, 0.0, overRoot2), - Quat(0.0, -overRoot2, 0.0, overRoot2), - Quat(0.0, 0.0, overRoot2, overRoot2), - Quat(0.0, 0.0, -overRoot2, overRoot2), + Quat(0.0, over_root2, over_root2, 0.0), + Quat(0.0, -over_root2, over_root2, 0.0), + Quat(0.0, over_root2, 0.0, over_root2), + Quat(0.0, -over_root2, 0.0, over_root2), + Quat(0.0, 0.0, over_root2, over_root2), + Quat(0.0, 0.0, -over_root2, over_root2), # cubic triads (111) Quat(0.5, 0.5, 0.5, 0.5), @@ -259,18 +189,18 @@ def qMatrix(lMatrix): Quat(0.0, -sqrt3over2, -0.5, 0.0) ], np.array([ - [1, 0, -cOverA], - [0.5, sqrt3over2, -cOverA], - [-0.5, sqrt3over2, -cOverA], - [-1, 0, -cOverA], - [-0.5, -sqrt3over2, -cOverA], - [0.5, -sqrt3over2, -cOverA], - [1, 0, cOverA], - [0.5, sqrt3over2, cOverA], - [-0.5, sqrt3over2, cOverA], - [-1, 0, cOverA], - [-0.5, -sqrt3over2, cOverA], - [0.5, -sqrt3over2, cOverA] + [1, 0, -c_over_a], + [0.5, sqrt3over2, -c_over_a], + [-0.5, sqrt3over2, -c_over_a], + [-1, 0, -c_over_a], + [-0.5, -sqrt3over2, -c_over_a], + [0.5, -sqrt3over2, -c_over_a], + [1, 0, c_over_a], + [0.5, sqrt3over2, c_over_a], + [-0.5, sqrt3over2, c_over_a], + [-1, 0, c_over_a], + [-0.5, -sqrt3over2, c_over_a], + [0.5, -sqrt3over2, c_over_a] ]), [ [0, 1, 2, 3, 4, 5], @@ -290,74 +220,74 @@ class SlipSystem(object): """Class used for defining and performing operations on a slip system. """ - def __init__(self, slipPlane, slipDir, crystalStructure, cOverA=None): + def __init__(self, slip_plane, slip_dir, crystal_structure, c_over_a=None): """Initialise a slip system object. Parameters ---------- - slipPlane: nunpy.ndarray + slip_plane: numpy.ndarray Slip plane. - slipDir: numpy.ndarray + slip_dir: numpy.ndarray Slip direction. - crystalStructure : defdap.crystal.CrystalStructure + crystal_structure : defdap.crystal.CrystalStructure Crystal structure of the slip system. - cOverA : float, optional + c_over_a : float, optional C over a ratio for hexagonal crystals. """ - self.crystalStructure = crystalStructure + self.crystal_structure = crystal_structure # Stored as Miller indices (Miller-Bravais for hexagonal) - self.planeIdc = tuple(slipPlane) - self.dirIdc = tuple(slipDir) + self.plane_idc = tuple(slip_plane) + self.dir_idc = tuple(slip_dir) # Stored as vectors in a cartesian basis - if self.crystalStructure.name == "cubic": - self.slipPlane = slipPlane / norm(slipPlane) - self.slipDir = slipDir / norm(slipDir) - self.cOverA = None - elif self.crystalStructure.name == "hexagonal": - if cOverA is None: + if self.crystal_structure.name == "cubic": + self.slip_plane = slip_plane / norm(slip_plane) + self.slip_dir = slip_dir / norm(slip_dir) + self.c_over_a = None + elif self.crystal_structure.name == "hexagonal": + if c_over_a is None: raise Exception("No c over a ratio given") - self.cOverA = cOverA + self.c_over_a = c_over_a # Convert plane and dir from Miller-Bravais to Miller - slipPlaneM = convertIdc('mb', plane=slipPlane) - slipDirM = convertIdc('mb', dir=slipDir) + slip_plane_m = convert_idc('mb', plane=slip_plane) + slip_dir_m = convert_idc('mb', dir=slip_dir) # Transformation from crystal to orthonormal coords - lMatrix = CrystalStructure.lMatrix( - 1, 1, cOverA, np.pi / 2, np.pi / 2, np.pi * 2 / 3 + l_matrix = create_l_matrix( + 1, 1, c_over_a, np.pi / 2, np.pi / 2, np.pi * 2 / 3 ) # Q matrix for transforming planes - qMatrix = CrystalStructure.qMatrix(lMatrix) + q_matrix = create_q_matrix(l_matrix) # Transform into orthonormal basis and then normalise - self.slipPlane = np.matmul(qMatrix, slipPlaneM) - self.slipPlane /= norm(self.slipPlane) - self.slipDir = np.matmul(lMatrix, slipDirM) - self.slipDir /= norm(self.slipDir) + self.slip_plane = np.matmul(q_matrix, slip_plane_m) + self.slip_plane /= norm(self.slip_plane) + self.slip_dir = np.matmul(l_matrix, slip_dir_m) + self.slip_dir /= norm(self.slip_dir) else: raise Exception("Only cubic and hexagonal currently supported.") def __eq__(self, right): # or one divide the other should be a constant for each place. - return (posIdc(self.planeIdc) == posIdc(right.planeIdc) and - posIdc(self.dirIdc) == posIdc(right.dirIdc)) + return (pos_idc(self.plane_idc) == pos_idc(right.plane_idc) and + pos_idc(self.dir_idc) == pos_idc(right.dir_idc)) def __hash__(self): - return hash(posIdc(self.planeIdc) + posIdc(self.dirIdc)) + return hash(pos_idc(self.plane_idc) + pos_idc(self.dir_idc)) def __str__(self): - return self.slipPlaneLabel + self.slipDirLabel + return self.slip_plane_label + self.slip_dir_label def __repr__(self): - return (f"SlipSystem(slipPlane={self.slipPlaneLabel}, " - f"slipDir={self.slipDirLabel}, " - f"symmetry={self.crystalStructure.name})") + return (f"SlipSystem(slipPlane={self.slip_plane_label}, " + f"slipDir={self.slip_dir_label}, " + f"symmetry={self.crystal_structure.name})") @property - def slipPlaneLabel(self): + def slip_plane_label(self): """Return the slip plane label. For example '(111)'. Returns @@ -366,10 +296,10 @@ def slipPlaneLabel(self): Slip plane label. """ - return '(' + ''.join(map(strIdx, self.planeIdc)) + ')' + return idc_to_string(self.plane_idc, '()') @property - def slipDirLabel(self): + def slip_dir_label(self): """Returns the slip direction label. For example '[110]'. Returns @@ -378,9 +308,9 @@ def slipDirLabel(self): Slip direction label. """ - return '[' + ''.join(map(strIdx, self.dirIdc)) + ']' + return idc_to_string(self.dir_idc, '[]') - def generateFamily(self): + def generate_family(self): """Generate the family of slip systems which this system belongs to. Returns @@ -390,50 +320,50 @@ def generateFamily(self): """ # - symms = self.crystalStructure.symmetries + symms = self.crystal_structure.symmetries ss_family = set() # will not preserve order - plane = self.planeIdc - dir = self.dirIdc + plane = self.plane_idc + dir = self.dir_idc - if self.crystalStructure.name == 'hexagonal': + if self.crystal_structure.name == 'hexagonal': # Transformation from crystal to orthonormal coords - lMatrix = CrystalStructure.lMatrix( - 1, 1, self.cOverA, np.pi / 2, np.pi / 2, np.pi * 2 / 3 + l_matrix = create_l_matrix( + 1, 1, self.c_over_a, np.pi / 2, np.pi / 2, np.pi * 2 / 3 ) # Q matrix for transforming planes - qMatrix = CrystalStructure.qMatrix(lMatrix) + q_matrix = create_q_matrix(l_matrix) # Transform into orthonormal basis - plane = np.matmul(qMatrix, convertIdc('mb', plane=plane)) - dir = np.matmul(lMatrix, convertIdc('mb', dir=dir)) + plane = np.matmul(q_matrix, convert_idc('mb', plane=plane)) + dir = np.matmul(l_matrix, convert_idc('mb', dir=dir)) for i, symm in enumerate(symms): symm = symm.conjugate - plane_symm = symm.transformVector(plane) - dir_symm = symm.transformVector(dir) + plane_symm = symm.transform_vector(plane) + dir_symm = symm.transform_vector(dir) - if self.crystalStructure.name == 'hexagonal': - # qMatrix inverse is equal to lMatrix transposed and vice-versa - plane_symm = reduceIdc(convertIdc( - 'm', plane=safeIntCast(np.matmul(lMatrix.T, plane_symm)) + if self.crystal_structure.name == 'hexagonal': + # q_matrix inverse is equal to l_matrix transposed and vice-versa + plane_symm = reduce_idc(convert_idc( + 'm', plane=safe_int_cast(np.matmul(l_matrix.T, plane_symm)) )) - dir_symm = reduceIdc(convertIdc( - 'm', dir=safeIntCast(np.matmul(qMatrix.T, dir_symm)) + dir_symm = reduce_idc(convert_idc( + 'm', dir=safe_int_cast(np.matmul(q_matrix.T, dir_symm)) )) ss_family.add(SlipSystem( - posIdc(safeIntCast(plane_symm)), - posIdc(safeIntCast(dir_symm)), - self.crystalStructure, cOverA=self.cOverA + pos_idc(safe_int_cast(plane_symm)), + pos_idc(safe_int_cast(dir_symm)), + self.crystal_structure, c_over_a=self.c_over_a )) return ss_family @staticmethod - def load(name, crystalStructure, cOverA=None, groupBy='plane'): + def load(name, crystal_structure, c_over_a=None, group_by='plane'): """ Load in slip systems from file. 3 integers for slip plane normal and 3 for slip direction. Returns a list of list of slip @@ -444,11 +374,11 @@ def load(name, crystalStructure, cOverA=None, groupBy='plane'): name : str Name of the slip system file (without file extension) stored in the defdap install dir or path to a file. - crystalStructure : defdap.crystal.CrystalStructure + crystal_structure : defdap.crystal.CrystalStructure Crystal structure of the slip systems. - cOverA : float, optional + c_over_a : float, optional C over a ratio for hexagonal crystals. - groupBy : str, optional + group_by : str, optional How to group the slip systems, either by slip plane ('plane') or slip system family ('family') or don't group (None). @@ -465,60 +395,60 @@ def load(name, crystalStructure, cOverA=None, groupBy='plane'): """ # try and load from package dir first try: - fileExt = ".txt" - packageDir, _ = os.path.split(__file__) - filepath = f"{packageDir}/slip_systems/{name}{fileExt}" + file_ext = ".txt" + package_dir, _ = os.path.split(__file__) + filepath = f"{package_dir}/slip_systems/{name}{file_ext}" - slipSystemFile = open(filepath) + slip_system_file = open(filepath) except FileNotFoundError: # if it doesn't exist in the package dir, try and load the path try: filepath = name - slipSystemFile = open(filepath) + slip_system_file = open(filepath) except FileNotFoundError: raise(FileNotFoundError("Couldn't find the slip systems file")) - slipSystemFile.readline() - slipTraceColours = slipSystemFile.readline().strip().split(',') - slipSystemFile.close() + slip_system_file.readline() + slip_trace_colours = slip_system_file.readline().strip().split(',') + slip_system_file.close() - if crystalStructure.name == "hexagonal": - vectSize = 4 + if crystal_structure.name == "hexagonal": + vect_size = 4 else: - vectSize = 3 + vect_size = 3 - ssData = np.loadtxt(filepath, delimiter='\t', skiprows=2, + ss_data = np.loadtxt(filepath, delimiter='\t', skiprows=2, dtype=np.int8) - if ssData.shape[1] != 2 * vectSize: + if ss_data.shape[1] != 2 * vect_size: raise IOError("Slip system file not valid") # Create list of slip system objects - slipSystems = [] - for row in ssData: - slipSystems.append(SlipSystem( - row[0:vectSize], row[vectSize:2 * vectSize], - crystalStructure, cOverA=cOverA + slip_systems = [] + for row in ss_data: + slip_systems.append(SlipSystem( + row[0:vect_size], row[vect_size:2 * vect_size], + crystal_structure, c_over_a=c_over_a )) # Group slip systems is required - if groupBy is not None: - slipSystems = SlipSystem.group(slipSystems, groupBy) + if group_by is not None: + slip_systems = SlipSystem.group(slip_systems, group_by) - return slipSystems, slipTraceColours + return slip_systems, slip_trace_colours @staticmethod - def group(slipSystems, groupBy): + def group(slip_systems, group_by): """ Groups slip systems by their slip plane. Parameters ---------- - slipSystems : list of SlipSystem + slip_systems : list of SlipSystem A list of slip systems. - groupBy : str + group_by : str How to group the slip systems, either by slip plane ('plane') or slip system family ('family'). @@ -528,200 +458,40 @@ def group(slipSystems, groupBy): A list of list of grouped slip systems. """ - if groupBy.lower() == 'plane': + if group_by.lower() == 'plane': # Group by slip plane and keep slip plane order from file - groupedSlipSystems = [[slipSystems[0]]] - for ss in slipSystems[1:]: - for i, ssGroup in enumerate(groupedSlipSystems): - if posIdc(ss.planeIdc) == posIdc(ssGroup[0].planeIdc): - groupedSlipSystems[i].append(ss) + grouped_slip_systems = [[slip_systems[0]]] + for ss in slip_systems[1:]: + for i, ssGroup in enumerate(grouped_slip_systems): + if pos_idc(ss.plane_idc) == pos_idc(ssGroup[0].plane_idc): + grouped_slip_systems[i].append(ss) break else: - groupedSlipSystems.append([ss]) + grouped_slip_systems.append([ss]) - elif groupBy.lower() == 'family': - groupedSlipSystems = [] + elif group_by.lower() == 'family': + grouped_slip_systems = [] ssFamilies = [] - for ss in slipSystems: + for ss in slip_systems: for i, ssFamily in enumerate(ssFamilies): if ss in ssFamily: - groupedSlipSystems[i].append(ss) + grouped_slip_systems[i].append(ss) break else: - groupedSlipSystems.append([ss]) - ssFamilies.append(ss.generateFamily()) + grouped_slip_systems.append([ss]) + ssFamilies.append(ss.generate_family()) else: raise ValueError("Slip systems can be grouped by plane or family") - return groupedSlipSystems + return grouped_slip_systems @staticmethod - def printSlipSystemDirectory(): + def print_slip_system_directory(): """ Prints the location where slip system definition files are stored. """ - packageDir, _ = os.path.split(__file__) + package_dir, _ = os.path.split(__file__) print("Slip system definition files are stored in directory:") - print(f"{packageDir}/slip_systems/") - - -def convertIdc(inType, *, dir=None, plane=None): - """ - Convert between Miller and Miller-Bravais indices. - - Parameters - ---------- - inType : str {'m', 'mb'} - Type of indices provided. If 'm' converts from Miller to - Miller-Bravais, opposite for 'mb'. - dir : tuple of int or equivalent, optional - Direction to convert. This OR `plane` must me provided. - plane : tuple of int or equivalent, optional - Plane to convert. This OR `direction` must me provided. - - Returns - ------- - tuple of int - The converted plane or direction. - - """ - if dir is None and plane is None: - raise ValueError("One of either `direction` or `plane` must be " - "provided.") - if dir is not None and plane is not None: - raise ValueError("One of either `direction` or `plane` must be " - "provided, not both.") - - def checkLen(val, length): - if len(val) != length: - raise ValueError(f"Vector must have {length} values.") - - if inType.lower() == 'm': - if dir is None: - # plane M->MB - checkLen(plane, 3) - out = np.array(plane)[[0, 1, 0, 2]] - out[2] += plane[1] - out[2] *= -1 - - else: - # direction M->MB - checkLen(dir, 3) - u, v, w = dir - out = np.array([2*u-v, 2*v-u, -u-v, 3*w]) / 3 - try: - # Attempt to cast to integers - out = safeIntCast(out) - except ValueError: - pass - - elif inType.lower() == 'mb': - if dir is None: - # plane MB->M - checkLen(plane, 4) - out = np.array(plane)[[0, 1, 3]] - - else: - # direction MB->M - checkLen(dir, 4) - out = np.array(dir)[[0, 1, 3]] - out[[0, 1]] -= dir[2] - - else: - raise ValueError("`inType` must be either 'm' or 'mb'.") - - return tuple(out) - - -def posIdc(vec): - """ - Return a consistent positive version of a set of indices. - - Parameters - ---------- - vec : tuple of int or equivalent - Indices to convert. - - Returns - ------- - tuple of int - Positive version of indices. - - """ - for idx in vec: - if idx == 0: - continue - if idx > 0: - return tuple(vec) - else: - return tuple(-np.array(vec)) - - -def reduceIdc(vec): - """ - Reduce indices to lowest integers - - Parameters - ---------- - vec : tuple of int or equivalent - Indices to reduce. - - Returns - ------- - tuple of int - The reduced indices. - - """ - return tuple((np.array(vec) / np.gcd.reduce(vec)).astype(np.int8)) - - -def safeIntCast(vec, tol=1e-3): - """ - Cast a tuple of floats to integers, raising an error if rounding is - over a tolerance. - - Parameters - ---------- - vec : tuple of float or equivalent - Vector to cast. - tol : float - Tolerance above which an error is raised. - - Returns - ------- - tuple of int - - Raises - ------ - ValueError - If the rounding is over the tolerance for any value. - - """ - vec = np.array(vec) - vec_rounded = vec.round() - - if np.any(np.abs(vec - vec_rounded) > tol): - raise ValueError('Rounding too large', np.abs(vec - vec_rounded)) - - return tuple(vec_rounded.astype(np.int8)) - - -def strIdx(idx): - """ - String representation of an index with overbars. - - Parameters - ---------- - idx : int - - Returns - ------- - str - - """ - if not isinstance(idx, (int, np.integer)): - raise ValueError("Index must be an integer.") - - return str(idx) if idx >= 0 else str(-idx) + u'\u0305' + print(f"{package_dir}/slip_systems/") diff --git a/defdap/crystal_utils.py b/defdap/crystal_utils.py new file mode 100644 index 0000000..18018b5 --- /dev/null +++ b/defdap/crystal_utils.py @@ -0,0 +1,412 @@ +# Copyright 2024 Mechanics of Microstructures Group +# at The University of Manchester +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from functools import partial +import numpy as np + +from defdap import defaults + +__all__ = [ + 'create_l_matrix', + 'create_q_matrix', + 'convert_idc', + 'equavlent_indicies', + 'project_to_orth', + 'pos_idc', + 'reduce_idc', + 'safe_int_cast', + 'idc_to_string', + 'str_idx', +] + + +def create_l_matrix(a, b, c, alpha, beta, gamma, convention=None): + """ Construct L matrix based on Page 22 of + Randle and Engle - Introduction to texture analysis""" + l_matrix = np.zeros((3, 3)) + + cos_alpha = np.cos(alpha) + cos_beta = np.cos(beta) + cos_gamma = np.cos(gamma) + + sin_gamma = np.sin(gamma) + + l_matrix[0, 0] = a + l_matrix[0, 1] = b * cos_gamma + l_matrix[0, 2] = c * cos_beta + + l_matrix[1, 1] = b * sin_gamma + l_matrix[1, 2] = c * (cos_alpha - cos_beta * cos_gamma) / sin_gamma + + l_matrix[2, 2] = c * np.sqrt( + 1 + 2 * cos_alpha * cos_beta * cos_gamma - + cos_alpha**2 - cos_beta**2 - cos_gamma**2 + ) / sin_gamma + + # OI/HKL convention - x // [10-10], y // a2 [-12-10] + # TSL convention - x // a1 [2-1-10], y // [01-10] + if convention is None: + convention = defaults['crystal_ortho_conv'] + + if convention.lower() in ['hkl', 'oi']: + # Swap 00 with 11 and 01 with 10 due to how OI orthonormalises + # From Brad Wynne + t1 = l_matrix[0, 0] + t2 = l_matrix[1, 0] + + l_matrix[0, 0] = l_matrix[1, 1] + l_matrix[1, 0] = l_matrix[0, 1] + + l_matrix[1, 1] = t1 + l_matrix[0, 1] = t2 + + elif convention.lower() != 'tsl': + raise ValueError( + f"Unknown convention '{convention}' for orthonormalisation of " + f"crystal structure, can be 'hkl' or 'tsl'" + ) + + # Set small components to 0 + l_matrix[np.abs(l_matrix) < 1e-10] = 0 + + return l_matrix + + +def create_q_matrix(l_matrix): + """ Construct matrix of reciprocal lattice vectors to transform + plane normals See C. T. Young and J. L. Lytton, J. Appl. Phys., + vol. 43, no. 4, pp. 1408–1417, 1972.""" + a = l_matrix[:, 0] + b = l_matrix[:, 1] + c = l_matrix[:, 2] + + volume = abs(np.dot(a, np.cross(b, c))) + a_star = np.cross(b, c) / volume + b_star = np.cross(c, a) / volume + c_star = np.cross(a, b) / volume + + q_matrix = np.stack((a_star, b_star, c_star), axis=1) + + return q_matrix + + +def check_len(val, length): + if len(val) != length: + raise ValueError(f"Vector must have {length} values.") + + +def convert_idc(in_type, *, dir=None, plane=None): + """ + Convert between Miller and Miller-Bravais indices. + + Parameters + ---------- + in_type : str {'m', 'mb'} + Type of indices provided. If 'm' converts from Miller to + Miller-Bravais, opposite for 'mb'. + dir : tuple of int or equivalent, optional + Direction to convert. This OR `plane` must me provided. + plane : tuple of int or equivalent, optional + Plane to convert. This OR `direction` must me provided. + + Returns + ------- + tuple of int + The converted plane or direction. + + """ + if dir is None and plane is None: + raise ValueError("One of either `direction` or `plane` must be " + "provided.") + if dir is not None and plane is not None: + raise ValueError("One of either `direction` or `plane` must be " + "provided, not both.") + + if in_type.lower() == 'm': + if dir is None: + # plane M->MB + check_len(plane, 3) + out = np.array(plane)[[0, 1, 0, 2]] + out[2] += plane[1] + out[2] *= -1 + + else: + # direction M->MB + check_len(dir, 3) + u, v, w = dir + out = np.array([2*u-v, 2*v-u, -u-v, 3*w]) / 3 + try: + # Attempt to cast to integers + out = safe_int_cast(out) + except ValueError: + pass + + elif in_type.lower() == 'mb': + if dir is None: + # plane MB->M + check_len(plane, 4) + out = np.array(plane)[[0, 1, 3]] + + else: + # direction MB->M + check_len(dir, 4) + out = np.array(dir)[[0, 1, 3]] + out[[0, 1]] -= dir[2] + + else: + raise ValueError("`inType` must be either 'm' or 'mb'.") + + return tuple(out) + + +def equavlent_indicies( + crystal_symm, + symmetries, + *, + dir=None, + plane=None, + c_over_a=None, + in_type=None +): + if dir is None and plane is None: + raise ValueError("One of either `direction` or `plane` must be " + "provided.") + if dir is not None and plane is not None: + raise ValueError("One of either `direction` or `plane` must be " + "provided, not both.") + if in_type is None: + in_type = 'mb' if crystal_symm == 'hexagonal' else 'm' + + planes = [] + dirs = [] + + if in_type == 'mb': + if dir is None: + check_len(plane, 4) + plane = convert_idc('mb', plane=plane) + if plane is None: + check_len(dir, 4) + dir = convert_idc('mb', dir=dir) + elif in_type != 'm': + raise ValueError("`inType` must be either 'm' or 'mb'.") + + if dir is None: + check_len(plane, 3) + rtn = planes + else: + check_len(dir, 3) + rtn = dirs + + if crystal_symm == 'hexagonal': + # L matrix for transforming directions + l_matrix = create_l_matrix( + 1, 1, c_over_a, np.pi / 2, np.pi / 2, np.pi * 2 / 3 + ) + # Q matrix for transforming planes + q_matrix = create_q_matrix(l_matrix) + + if dir is None: + plane = np.matmul(q_matrix, plane) + else: + dir = np.matmul(l_matrix, dir) + + for i, symm in enumerate(symmetries): + if dir is None: + plane_symm = symm.transform_vector(plane) + if plane_symm[2] < 0: + plane_symm *= -1 + if crystal_symm == 'hexagonal': + # q_matrix inverse is equal to l_matrix transposed and vice-versa + plane_symm = reduce_idc(convert_idc( + 'm', plane=safe_int_cast(np.matmul(l_matrix.T, plane_symm)) + )) + planes.append(safe_int_cast(plane_symm)) + else: + dir_symm = symm.transform_vector(dir) + if dir_symm[2] < 0: + dir_symm *= -1 + if crystal_symm == 'hexagonal': + dir_symm = reduce_idc(convert_idc( + 'm', dir=safe_int_cast(np.matmul(q_matrix.T, dir_symm)) + )) + dirs.append(safe_int_cast(dir_symm)) + + return rtn + + +def project_to_orth(c_over_a, *, dir=None, plane=None, in_type='mb'): + """ + Project from crystal aligned coordinates to an orthogonal set. + + Parameters + ---------- + in_type : str {'m', 'mb'} + Type of indices provided + dir : tuple of int or equivalent, optional + Direction to convert. This OR `plane` must me provided. + plane : tuple of int or equivalent, optional + Plane to convert. This OR `direction` must me provided. + + Returns + ------- + + + """ + if dir is None and plane is None: + raise ValueError("One of either `direction` or `plane` must be " + "provided.") + if dir is not None and plane is not None: + raise ValueError("One of either `direction` or `plane` must be " + "provided, not both.") + + if in_type == 'mb': + if dir is None: + check_len(plane, 4) + plane = convert_idc('mb', plane=plane) + if plane is None: + check_len(dir, 4) + dir = convert_idc('mb', dir=dir) + elif in_type != 'm': + raise ValueError("`inType` must be either 'm' or 'mb'.") + + # L matrix for transforming directions + l_matrix = create_l_matrix( + 1, 1, c_over_a, np.pi / 2, np.pi / 2, np.pi * 2 / 3 + ) + + if dir is None: + check_len(plane, 3) + # Q matrix for transforming planes + q_matrix = create_q_matrix(l_matrix) + return np.matmul(q_matrix, plane) + else: + check_len(dir, 3) + return np.matmul(l_matrix, dir) + + +def pos_idc(vec): + """ + Return a consistent positive version of a set of indices. + + Parameters + ---------- + vec : tuple of int or equivalent + Indices to convert. + + Returns + ------- + tuple of int + Positive version of indices. + + """ + for idx in vec: + if idx == 0: + continue + if idx > 0: + return tuple(vec) + else: + return tuple(-np.array(vec)) + + +def reduce_idc(vec): + """ + Reduce indices to lowest integers + + Parameters + ---------- + vec : tuple of int or equivalent + Indices to reduce. + + Returns + ------- + tuple of int + The reduced indices. + + """ + return tuple((np.array(vec) / np.gcd.reduce(vec)).astype(np.int8)) + + +def safe_int_cast(vec, tol=1e-3): + """ + Cast a tuple of floats to integers, raising an error if rounding is + over a tolerance. + + Parameters + ---------- + vec : tuple of float or equivalent + Vector to cast. + tol : float + Tolerance above which an error is raised. + + Returns + ------- + tuple of int + + Raises + ------ + ValueError + If the rounding is over the tolerance for any value. + + """ + vec = np.array(vec) + vec_rounded = vec.round() + + if np.any(np.abs(vec - vec_rounded) > tol): + raise ValueError('Rounding too large', np.abs(vec - vec_rounded)) + + return tuple(vec_rounded.astype(np.int8)) + + +def idc_to_string(idc, brackets=None, str_type='unicode'): + """ + String representation of a set of indicies. + + Parameters + ---------- + idc : collection of int + brackets : str + String of opening and closing brackets eg '()' + str_type : str {'unicode', 'tex'} + + Returns + ------- + str + + """ + text = ''.join(map(partial(str_idx, str_type=str_type), idc)) + if brackets is not None: + text = brackets[0] + text + brackets[1] + return text + + +def str_idx(idx, str_type='unicode'): + """ + String representation of an index with overbars. + + Parameters + ---------- + idx : int + str_type : str {'unicode', 'tex'} + + Returns + ------- + str + + """ + if not isinstance(idx, (int, np.integer)): + raise ValueError("Index must be an integer.") + + pre, post = (r'$\bar{', r'}$') if str_type == 'tex' else ('', u'\u0305') + return str(idx) if idx >= 0 else pre + str(-idx) + post \ No newline at end of file diff --git a/defdap/ebsd.py b/defdap/ebsd.py index a64a533..db168d2 100755 --- a/defdap/ebsd.py +++ b/defdap/ebsd.py @@ -1,4 +1,4 @@ -# Copyright 2021 Mechanics of Microstructures Group +# Copyright 2025 Mechanics of Microstructures Group # at The University of Manchester # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -20,15 +20,16 @@ import copy from warnings import warn +from defdap.utils import Datastore from defdap.file_readers import EBSDDataLoader from defdap.file_writers import EBSDDataWriter from defdap.quat import Quat -from defdap.crystal import SlipSystem from defdap import base +from defdap._accelerated import flood_fill from defdap import defaults from defdap.plotting import MapPlot -from defdap.utils import reportProgress +from defdap.utils import report_progress class Map(base.Map): @@ -38,128 +39,139 @@ class Map(base.Map): Attributes ---------- - xDim : int - Size of map in x direction. - yDim : int - Size of map in y direction. - stepSize : float + step_size : float Step size in micron. - eulerAngleArray : numpy.ndarray - Euler angles for eaxh point of the map. Shape (3, yDim, xDim). - bandContrastArray : numpy.ndarray - Band contrast for each point of map. Shape (yDim, xDim). - quatArray : numpy.ndarray of defdap.quat.Quat - Quaterions for each point of map. Shape (yDim, xDim). - phaseArray : numpy.ndarray - Map of phase ids. 1-based, 0 is non-indexed points phases : list of defdap.crystal.Phase List of phases. - boundaries : numpy.ndarray - Map of boundaries. -1 for a boundary, 0 otherwise. - phaseBoundaries : numpy.ndarray - Map of phase boundaries. -1 for boundary, 0 otherwise. - grains : numpy.ndarray - Map of grains. Grain numbers start at 1 here but everywhere else - grainID starts at 0. Regions that are smaller than the minimum - grain size are given value -2. Remnant boundary points are -1. - misOri : numpy.ndarray + mis_ori : numpy.ndarray Map of misorientation. - misOriAxis : list of numpy.ndarray + mis_ori_axis : list of numpy.ndarray Map of misorientation axis components. - kam : numpy.ndarray - Map of KAM. origin : tuple(int) Map origin (x, y). Used by linker class where origin is a homologue point of the maps. - GND : numpy.ndarray - GND scalar map. - Nye : numpy.ndarray - 3x3 Nye tensor at each point. + + data : defdap.utils.Datastore + Must contain after loading data (maps): + phase : numpy.ndarray + 1-based, 0 is non-indexed points + euler_angle : numpy.ndarray + stored as (3, y_dim, x_dim) in radians + Generated data: + orientation : numpy.ndarray of defdap.quat.Quat + Quaterion for each point of map. Shape (y_dim, x_dim). + grain_boundaries : BoundarySet + phase_boundaries : BoundarySet + grains : numpy.ndarray of int + Map of grains. Grain numbers start at 1 here but everywhere else + grainID starts at 0. Regions that are smaller than the minimum + grain size are given value -2. Remnant boundary points are -1. + KAM : numpy.ndarray + Kernal average misorientaion map. + GND : numpy.ndarray + GND scalar map. + Nye_tensor : numpy.ndarray + 3x3 Nye tensor at each point. + Derived data: + grain_data_to_map : numpy.ndarray + Grain list data to map data from all grains """ - def __init__(self, fileName, dataType=None): + MAPNAME = 'ebsd' + + def __init__(self, *args, **kwargs): """ Initialise class and load EBSD data. Parameters ---------- - fileName : str - Path to EBSD file, including name, excluding extension. - dataType : str, {'OxfordBinary', 'OxfordText'} - Format of EBSD data file. + *args, **kwarg + Passed to base constructor """ - # Call base class constructor - super(Map, self).__init__() - - self.xDim = None - self.yDim = None - self.stepSize = None - self.eulerAngleArray = None - self.bandContrastArray = None - self.quatArray = None - self.phaseArray = None + # Initialise variables + self.step_size = None self.phases = [] - self.boundaries = None - self.boundariesX = None - self.boundariesY = None - self.boundaryLines = None - self.phaseBoundariesX = None - self.phaseBoundariesY = None - self.phaseBoundaryLines = None - self.phaseBoundaries = None - self.grains = None - self.misOri = None - self.misOriAxis = None - self.kam = None + + # Call base class constructor + super(Map, self).__init__(*args, **kwargs) + + self.mis_ori = None + self.mis_ori_axis = None self.origin = (0, 0) - self.GND = None - self.Nye = None - # Phase used for the maps crystal structure and cOverA. So old + # Phase used for the maps crystal structure and c_over_a. So old # functions still work for the 'main' phase in the map. 0-based - self.primaryPhaseID = 0 + self.primary_phase_id = 0 # Use euler map for defining homologous points - self.plotHomog = self.plotEulerMap - self.plotDefault = self.plotEulerMap - self.highlightAlpha = 1 + self.plot_default = self.plot_euler_map + self.homog_map_name = 'band_contrast' + self.highlight_alpha = 1 - self.loadData(fileName, dataType=dataType) + self.data.add_generator( + 'orientation', self.calc_quat_array, unit='', type='map', + order=0, default_component='IPF_x', + ) + self.data.add_generator( + ('phase_boundaries', 'grain_boundaries'), self.find_boundaries, + type='boundaries', + ) + self.data.add_generator( + 'grains', self.find_grains, unit='', type='map', order=0 + ) + self.data.add_generator( + 'KAM', self.calc_kam, unit='rad', type='map', order=0, + plot_params={ + 'plot_colour_bar': True, + 'clabel': 'KAM', + } + ) + self.data.add_generator( + ('GND', 'Nye_tensor'), self.calc_nye, + unit='', type='map', + metadatas=({ + 'order': 0, + 'plot_params': { + 'plot_colour_bar': True, + 'clabel': 'GND content', + } + }, { + 'order': 2, + 'save': False, + 'default_component': (0, 0), + 'plot_params': { + 'plot_colour_bar': True, + 'clabel': 'Nye tensor', + } + }) + ) - @reportProgress("loading EBSD data") - def loadData(self, fileName, dataType=None): + @report_progress("loading EBSD data") + def load_data(self, file_name, data_type=None): """Load in EBSD data from file. Parameters ---------- - fileName : str - Path to EBSD file, including name, excluding extension. - dataType : str, {'OxfordBinary', 'OxfordText'} + file_name : pathlib.Path + Path to EBSD file + data_type : str, {'OxfordBinary', 'OxfordText', 'EdaxAng', 'PythonDict'} Format of EBSD data file. """ - dataLoader = EBSDDataLoader.getLoader(dataType) - dataLoader.load(fileName) - - metadataDict = dataLoader.loadedMetadata - self.xDim = metadataDict['xDim'] - self.yDim = metadataDict['yDim'] - self.stepSize = metadataDict['stepSize'] - self.phases = metadataDict['phases'] - - dataDict = dataLoader.loadedData - self.eulerAngleArray = dataDict['eulerAngle'] - self.bandContrastArray = dataDict['bandContrast'] - self.bandSlopeArray = dataDict['bandSlope'] - self.meanAngularDeviationArray = dataDict['meanAngularDeviation'] - self.phaseArray = dataDict['phase'] - if int(metadataDict['EDX Windows']['Count']) > 0: - self.EDX = dataDict['EDXDict'] + data_loader = EBSDDataLoader.get_loader(data_type, file_name) + data_loader.load(file_name) + + metadata_dict = data_loader.loaded_metadata + self.shape = metadata_dict['shape'] + self.step_size = metadata_dict['step_size'] + self.phases = metadata_dict['phases'] + + self.data.update(data_loader.loaded_data) # write final status - yield "Loaded EBSD data (dimensions: {:} x {:} pixels, step " \ - "size: {:} um)".format(self.xDim, self.yDim, self.stepSize) + yield (f"Loaded EBSD data (dimensions: {self.x_dim} x {self.y_dim} " + f"pixels, step size: {self.step_size} um)") def save(self, file_name, data_type=None, file_dir=""): """Save EBSD map to file. @@ -177,17 +189,17 @@ def save(self, file_name, data_type=None, file_dir=""): data_writer = EBSDDataWriter.get_writer(data_type) data_writer.metadata['shape'] = self.shape - data_writer.metadata['step_size'] = self.stepSize + data_writer.metadata['step_size'] = self.step_size data_writer.metadata['phases'] = self.phases - data_writer.data['phase'] = self.phaseArray - data_writer.data['quat'] = self.quatArray - data_writer.data['band_contrast'] = self.bandContrastArray + data_writer.data['phase'] = self.data.phase + data_writer.data['quat'] = self.data.orientation + data_writer.data['band_contrast'] = self.data.band_contrast data_writer.write(file_name, file_dir=file_dir) @property - def crystalSym(self): + def crystal_sym(self): """Crystal symmetry of the primary phase. Returns @@ -196,10 +208,10 @@ def crystalSym(self): Crystal symmetry """ - return self.primaryPhase.crystalStructure.name + return self.primary_phase.crystal_structure.name @property - def cOverA(self): + def c_over_a(self): """C over A ratio of the primary phase Returns @@ -208,14 +220,14 @@ def cOverA(self): C over A ratio if hexagonal crystal structure otherwise None """ - return self.primaryPhase.cOverA + return self.primary_phase.c_over_a @property - def numPhases(self): + def num_phases(self): return len(self.phases) or None @property - def primaryPhase(self): + def primary_phase(self): """Primary phase of the EBSD map. Returns @@ -224,57 +236,84 @@ def primaryPhase(self): Primary phase """ - return self.phases[self.primaryPhaseID] + return self.phases[self.primary_phase_id] @property def scale(self): - return self.stepSize + return self.step_size - @reportProgress("rotating EBSD data") - def rotateData(self): + @report_progress("rotating EBSD data") + def rotate_data(self): """Rotate map by 180 degrees and transform quats accordingly. """ - self.eulerAngleArray = self.eulerAngleArray[:, ::-1, ::-1] - self.bandContrastArray = self.bandContrastArray[::-1, ::-1] - self.phaseArray = self.phaseArray[::-1, ::-1] - self.buildQuatArray(force=True) # Force rebuild quat array + + self.data.euler_angle = self.data.euler_angle[:, ::-1, ::-1] + self.data.band_contrast = self.data.band_contrast[::-1, ::-1] + self.data.band_slope = self.data.band_slope[::-1, ::-1] + self.data.phase = self.data.phase[::-1, ::-1] + self.calc_quat_array() # Rotation from old coord system to new - transformQuat = Quat.fromAxisAngle(np.array([0, 0, 1]), np.pi).conjugate + transform_quat = Quat.from_axis_angle(np.array([0, 0, 1]), np.pi).conjugate # Perform vectorised multiplication - quats = Quat.multiplyManyQuats(self.quatArray.flatten(), transformQuat) - self.quatArray = np.array(quats).reshape(self.yDim, self.xDim) + quats = Quat.multiply_many_quats(self.data.orientation.flatten(), transform_quat) + self.data.orientation = np.array(quats).reshape(self.shape) yield 1. - def plotBandContrastMap(self, **kwargs): - """Plot band contrast map + def calc_euler_colour(self, map_data, phases=None, bg_colour=None): + if phases is None: + phases = self.phases + phase_ids = range(len(phases)) + else: + phase_ids = phases + phases = [self.phases[i] for i in phase_ids] - kwargs - All arguments are passed to :func:`defdap.plotting.MapPlot.create`. + if bg_colour is None: + bg_colour = np.array([0., 0., 0.]) - Returns - ------- - defdap.plotting.MapPlot + map_colours = np.tile(bg_colour, self.shape + (1,)) - """ - self.checkDataLoaded() + for phase, phase_id in zip(phases, phase_ids): + if phase.crystal_structure.name == 'cubic': + norm = np.array([2 * np.pi, np.pi / 2, np.pi / 2]) + elif phase.crystal_structure.name == 'hexagonal': + norm = np.array([np.pi, np.pi, np.pi / 3]) + else: + ValueError("Only hexagonal and cubic symGroup supported") - # Set default plot parameters then update with any input - plotParams = { - 'plotColourBar': True, - 'cmap': 'gray', - 'clabel': "Band contrast" - } - plotParams.update(kwargs) + # Apply normalisation for each phase + phase_mask = self.data.phase == phase_id + 1 + map_colours[phase_mask] = map_data[:, phase_mask].T / norm - plot = MapPlot.create(self, self.bandContrastArray, **plotParams) + return map_colours - return plot + def calc_ipf_colour(self, map_data, direction, phases=None, + bg_colour=None): + if phases is None: + phases = self.phases + phase_ids = range(len(phases)) + else: + phase_ids = phases + phases = [self.phases[i] for i in phase_ids] - def plotEulerMap(self, phases=None, **kwargs): + if bg_colour is None: + bg_colour = np.array([0., 0., 0.]) + + map_colours = np.tile(bg_colour, self.shape + (1,)) + + for phase, phase_id in zip(phases, phase_ids): + # calculate IPF colours for phase + phase_mask = self.data.phase == phase_id + 1 + map_colours[phase_mask] = Quat.calc_ipf_colours( + map_data[phase_mask], direction, phase.crystal_structure.name + ).T + + return map_colours + + def plot_euler_map(self, phases=None, bg_colour=None, **kwargs): """Plot an orientation map in Euler colouring Parameters @@ -289,37 +328,17 @@ def plotEulerMap(self, phases=None, **kwargs): defdap.plotting.MapPlot """ - self.checkDataLoaded() - # Set default plot parameters then update with any input plot_params = {} plot_params.update(kwargs) - if phases is None: - phases = self.phases - phase_ids = range(len(phases)) - else: - phase_ids = phases - phases = [self.phases[i] for i in phase_ids] - - map_colours = np.zeros(self.shape + (3,)) - - for phase, phase_id in zip(phases, phase_ids): - if phase.crystalStructure.name == 'cubic': - norm = np.array([2 * np.pi, np.pi / 2, np.pi / 2]) - elif phase.crystalStructure.name == 'hexagonal': - norm = np.array([np.pi, np.pi, np.pi / 3]) - else: - ValueError("Only hexagonal and cubic symGroup supported") - - # Apply normalisation for each phase - phase_mask = self.phaseArray == phase_id + 1 - map_colours[phase_mask] = self.eulerAngleArray[:, phase_mask].T / norm + map_colours = self.calc_euler_colour( + self.data.euler_angle, phases=phases, bg_colour=bg_colour + ) return MapPlot.create(self, map_colours, **plot_params) - def plotIPFMap(self, direction, backgroundColour=None, phases=None, - **kwargs): + def plot_ipf_map(self, direction, phases=None, bg_colour=None, **kwargs): """ Plot a map with points coloured in IPF colouring, with respect to a given sample direction. @@ -327,11 +346,11 @@ def plotIPFMap(self, direction, backgroundColour=None, phases=None, Parameters ---------- direction : np.array len 3 - Sample directiom. - backgroundColour : np.array len 3 - Colour of background (i.e. for phases not plotted). + Sample direction. phases : list of int Which phases to plot IPF data for. + bg_colour : np.array len 3 + Colour of background (i.e. for phases not plotted). kwargs Other arguments passed to :func:`defdap.plotting.MapPlot.create`. @@ -344,30 +363,14 @@ def plotIPFMap(self, direction, backgroundColour=None, phases=None, plot_params = {} plot_params.update(kwargs) - if phases is None: - phases = self.phases - phase_ids = range(len(phases)) - else: - phase_ids = phases - phases = [self.phases[i] for i in phase_ids] - - if backgroundColour is None: - backgroundColour = [0., 0., 0.] - - map_colours = np.tile(np.array(backgroundColour), self.shape + (1,)) - - for phase, phase_id in zip(phases, phase_ids): - # calculate IPF colours for phase - phase_mask = self.phaseArray == phase_id + 1 - map_colours[phase_mask] = Quat.calcIPFcolours( - self.quatArray[phase_mask], - direction, - phase.crystalStructure.name - ).T + map_colours = self.calc_ipf_colour( + self.data.orientation, direction, phases=phases, + bg_colour=bg_colour + ) return MapPlot.create(self, map_colours, **plot_params) - def plotPhaseMap(self, **kwargs): + def plot_phase_map(self, **kwargs): """Plot a phase map. Parameters @@ -381,171 +384,156 @@ def plotPhaseMap(self, **kwargs): """ # Set default plot parameters then update with any input - plotParams = { + plot_params = { 'vmin': 0, - 'vmax': self.numPhases + 'vmax': self.num_phases } - plotParams.update(kwargs) + plot_params.update(kwargs) - plot = MapPlot.create(self, self.phaseArray, **plotParams) + plot = MapPlot.create(self, self.data.phase, **plot_params) # add a legend to the plot - phaseIDs = list(range(0, self.numPhases + 1)) - phaseNames = ["Non-indexed"] + [phase.name for phase in self.phases] - plot.addLegend(phaseIDs, phaseNames, loc=2, borderaxespad=0.) + phase_ids = list(range(0, self.num_phases + 1)) + phase_names = ["Non-indexed"] + [phase.name for phase in self.phases] + plot.add_legend(phase_ids, phase_names, loc=2, borderaxespad=0.) return plot - def calcKam(self): + @report_progress("calculating KAM") + def calc_kam(self): """ Calculates Kernel Average Misorientaion (KAM) for the EBSD map, based on a 3x3 kernel. Crystal symmetric equivalences are not - considered. Stores result in self.kam. + considered. Stores result as `KAM`. """ - quatComps = np.empty((4, self.yDim, self.xDim)) + quat_comps = np.empty((4, ) + self.shape) - for i, row in enumerate(self.quatArray): + for i, row in enumerate(self.data.orientation): for j, quat in enumerate(row): - quatComps[:, i, j] = quat.quatCoef + quat_comps[:, i, j] = quat.quat_coef - self.kam = np.empty((self.yDim, self.xDim)) + kam = np.empty(self.shape) # Start with rows. Calculate misorientation with neighbouring rows. # First and last row only in one direction - self.kam[0, :] = abs(np.einsum("ij,ij->j", quatComps[:, 0, :], quatComps[:, 1, :])) - self.kam[-1, :] = abs(np.einsum("ij,ij->j", quatComps[:, -1, :], quatComps[:, -2, :])) - for i in range(1, self.yDim - 1): - self.kam[i, :] = (abs(np.einsum("ij,ij->j", quatComps[:, i, :], quatComps[:, i + 1, :])) + - abs(np.einsum("ij,ij->j", quatComps[:, i, :], quatComps[:, i - 1, :]))) / 2 - - self.kam[self.kam > 1] = 1 + kam[0] = abs(np.einsum("ij,ij->j", + quat_comps[:, 0], quat_comps[:, 1])) + kam[-1] = abs(np.einsum("ij,ij->j", + quat_comps[:, -1], quat_comps[:, -2])) + for i in range(1, self.y_dim - 1): + kam[i] = (abs(np.einsum("ij,ij->j", + quat_comps[:, i], quat_comps[:, i + 1])) + + abs(np.einsum("ij,ij->j", + quat_comps[:, i], quat_comps[:, i - 1])) + ) / 2 + kam[kam > 1] = 1 # Do the same for columns - self.kam[:, 0] += abs(np.einsum("ij,ij->j", quatComps[:, :, 0], quatComps[:, :, 1])) - self.kam[:, -1] += abs(np.einsum("ij,ij->j", quatComps[:, :, -1], quatComps[:, :, -2])) - for i in range(1, self.xDim - 1): - self.kam[:, i] += (abs(np.einsum("ij,ij->j", quatComps[:, :, i], quatComps[:, :, i + 1])) + - abs(np.einsum("ij,ij->j", quatComps[:, :, i], quatComps[:, :, i - 1]))) / 2 + kam[:, 0] += abs(np.einsum("ij,ij->j", + quat_comps[:, :, 0], quat_comps[:, :, 1])) + kam[:, -1] += abs(np.einsum("ij,ij->j", + quat_comps[:, :, -1], quat_comps[:, :, -2])) + for i in range(1, self.x_dim - 1): + kam[:, i] += (abs(np.einsum("ij,ij->j", + quat_comps[:, :, i], + quat_comps[:, :, i + 1])) + + abs(np.einsum("ij,ij->j", + quat_comps[:, :, i], + quat_comps[:, :, i - 1])) + ) / 2 + kam /= 2 + kam[kam > 1] = 1 - self.kam /= 2 - self.kam[self.kam > 1] = 1 - - def plotKamMap(self, **kwargs): - """Plot Kernel Average Misorientaion (KAM) for the EBSD map. - - Parameters - ---------- - kwargs - All arguments are passed to :func:`defdap.plotting.MapPlot.create`. - - Returns - ------- - defdap.plotting.MapPlot - - """ - # Set default plot parameters then update with any input - plotParams = { - 'plotColourBar': True, - 'clabel': "Kernel average misorientation (KAM) ($^\circ$)" - } - plotParams.update(kwargs) - - self.calcKam() - # Convert to degrees and plot - kam = 2 * np.arccos(self.kam) * 180 / np.pi - - plot = MapPlot.create(self, kam, **plotParams) - - return plot + yield 1. + return 2 * np.arccos(kam) - @reportProgress("calculating Nye tensor") - def calcNye(self): + @report_progress("calculating Nye tensor") + def calc_nye(self): """ Calculates Nye tensor and related GND density for the EBSD map. - Stores result in self.Nye and self.GND. Uses the crystal + Stores result as `Nye_tensor` and `GND`. Uses the crystal symmetry of the primary phase. """ - self.buildQuatArray() - syms = self.primaryPhase.crystalStructure.symmetries - numSyms = len(syms) + syms = self.primary_phase.crystal_structure.symmetries + num_syms = len(syms) # array to store quat components of initial and symmetric equivalents - quatComps = np.empty((numSyms, 4, self.yDim, self.xDim)) + quat_comps = np.empty((num_syms, 4) + self.shape) # populate with initial quat components - for i, row in enumerate(self.quatArray): + for i, row in enumerate(self.data.orientation): for j, quat in enumerate(row): - quatComps[0, :, i, j] = quat.quatCoef + quat_comps[0, :, i, j] = quat.quat_coef # loop of over symmetries and apply to initial quat components # (excluding first symmetry as this is the identity transformation) for i, sym in enumerate(syms[1:], start=1): # sym[i] * quat for all points (* is quaternion product) - quatComps[i, 0] = (quatComps[0, 0] * sym[0] - quatComps[0, 1] * sym[1] - - quatComps[0, 2] * sym[2] - quatComps[0, 3] * sym[3]) - quatComps[i, 1] = (quatComps[0, 0] * sym[1] + quatComps[0, 1] * sym[0] - - quatComps[0, 2] * sym[3] + quatComps[0, 3] * sym[2]) - quatComps[i, 2] = (quatComps[0, 0] * sym[2] + quatComps[0, 2] * sym[0] - - quatComps[0, 3] * sym[1] + quatComps[0, 1] * sym[3]) - quatComps[i, 3] = (quatComps[0, 0] * sym[3] + quatComps[0, 3] * sym[0] - - quatComps[0, 1] * sym[2] + quatComps[0, 2] * sym[1]) - - # swap into positve hemisphere if required - quatComps[i, :, quatComps[i, 0] < 0] *= -1 - - # Arrays to store neigbour misorientation in positive x and y direction - misOrix = np.zeros((numSyms, self.yDim, self.xDim)) - misOriy = np.zeros((numSyms, self.yDim, self.xDim)) + quat_comps[i, 0] = (quat_comps[0, 0] * sym[0] - quat_comps[0, 1] * sym[1] - + quat_comps[0, 2] * sym[2] - quat_comps[0, 3] * sym[3]) + quat_comps[i, 1] = (quat_comps[0, 0] * sym[1] + quat_comps[0, 1] * sym[0] - + quat_comps[0, 2] * sym[3] + quat_comps[0, 3] * sym[2]) + quat_comps[i, 2] = (quat_comps[0, 0] * sym[2] + quat_comps[0, 2] * sym[0] - + quat_comps[0, 3] * sym[1] + quat_comps[0, 1] * sym[3]) + quat_comps[i, 3] = (quat_comps[0, 0] * sym[3] + quat_comps[0, 3] * sym[0] - + quat_comps[0, 1] * sym[2] + quat_comps[0, 2] * sym[1]) + + # swap into positive hemisphere if required + quat_comps[i, :, quat_comps[i, 0] < 0] *= -1 + + # Arrays to store neighbour misorientation in positive x and y direction + mis_ori_x = np.zeros((num_syms,) + self.shape) + mis_ori_y = np.zeros((num_syms, ) + self.shape) # loop over symmetries calculating misorientation to initial - for i in range(numSyms): - for j in range(self.xDim - 1): - misOrix[i, :, j] = abs(np.einsum("ij,ij->j", quatComps[0, :, :, j], quatComps[i, :, :, j + 1])) + for i in range(num_syms): + for j in range(self.x_dim - 1): + mis_ori_x[i, :, j] = abs(np.einsum("ij,ij->j", quat_comps[0, :, :, j], quat_comps[i, :, :, j + 1])) - for j in range(self.yDim - 1): - misOriy[i, j, :] = abs(np.einsum("ij,ij->j", quatComps[0, :, j, :], quatComps[i, :, j + 1, :])) + for j in range(self.y_dim - 1): + mis_ori_y[i, j, :] = abs(np.einsum("ij,ij->j", quat_comps[0, :, j, :], quat_comps[i, :, j + 1, :])) - misOrix[misOrix > 1] = 1 - misOriy[misOriy > 1] = 1 + mis_ori_x[mis_ori_x > 1] = 1 + mis_ori_y[mis_ori_y > 1] = 1 # find min misorientation (max here as misorientaion is cos of this) - argmisOrix = np.argmax(misOrix, axis=0) - argmisOriy = np.argmax(misOriy, axis=0) - misOrix = np.max(misOrix, axis=0) - misOriy = np.max(misOriy, axis=0) + arg_mis_ori_x = np.argmax(mis_ori_x, axis=0) + arg_mis_ori_y = np.argmax(mis_ori_y, axis=0) + mis_ori_x = np.max(mis_ori_x, axis=0) + mis_ori_y = np.max(mis_ori_y, axis=0) # convert to misorientation in degrees - misOrix = 360 * np.arccos(misOrix) / np.pi - misOriy = 360 * np.arccos(misOriy) / np.pi + mis_ori_x = 360 * np.arccos(mis_ori_x) / np.pi + mis_ori_y = 360 * np.arccos(mis_ori_y) / np.pi # calculate relative elastic distortion tensors at each point in the two directions - betaderx = np.zeros((3, 3, self.yDim, self.xDim)) + betaderx = np.zeros((3, 3) + self.shape) betadery = betaderx - for i in range(self.xDim - 1): - for j in range(self.yDim - 1): - q0x = Quat(quatComps[0, 0, j, i], quatComps[0, 1, j, i], - quatComps[0, 2, j, i], quatComps[0, 3, j, i]) - qix = Quat(quatComps[argmisOrix[j, i], 0, j, i + 1], - quatComps[argmisOrix[j, i], 1, j, i + 1], - quatComps[argmisOrix[j, i], 2, j, i + 1], - quatComps[argmisOrix[j, i], 3, j, i + 1]) + for i in range(self.x_dim - 1): + for j in range(self.y_dim - 1): + q0x = Quat(quat_comps[0, 0, j, i], quat_comps[0, 1, j, i], + quat_comps[0, 2, j, i], quat_comps[0, 3, j, i]) + qix = Quat(quat_comps[arg_mis_ori_x[j, i], 0, j, i + 1], + quat_comps[arg_mis_ori_x[j, i], 1, j, i + 1], + quat_comps[arg_mis_ori_x[j, i], 2, j, i + 1], + quat_comps[arg_mis_ori_x[j, i], 3, j, i + 1]) misoquatx = qix.conjugate * q0x # change stepsize to meters - betaderx[:, :, j, i] = (Quat.rotMatrix(misoquatx) - np.eye(3)) / self.stepSize / 1e-6 - q0y = Quat(quatComps[0, 0, j, i], quatComps[0, 1, j, i], - quatComps[0, 2, j, i], quatComps[0, 3, j, i]) - qiy = Quat(quatComps[argmisOriy[j, i], 0, j + 1, i], - quatComps[argmisOriy[j, i], 1, j + 1, i], - quatComps[argmisOriy[j, i], 2, j + 1, i], - quatComps[argmisOriy[j, i], 3, j + 1, i]) + betaderx[:, :, j, i] = (Quat.rot_matrix(misoquatx) - np.eye(3)) / self.step_size / 1e-6 + q0y = Quat(quat_comps[0, 0, j, i], quat_comps[0, 1, j, i], + quat_comps[0, 2, j, i], quat_comps[0, 3, j, i]) + qiy = Quat(quat_comps[arg_mis_ori_y[j, i], 0, j + 1, i], + quat_comps[arg_mis_ori_y[j, i], 1, j + 1, i], + quat_comps[arg_mis_ori_y[j, i], 2, j + 1, i], + quat_comps[arg_mis_ori_y[j, i], 3, j + 1, i]) misoquaty = qiy.conjugate * q0y # change stepsize to meters - betadery[:, :, j, i] = (Quat.rotMatrix(misoquaty) - np.eye(3)) / self.stepSize / 1e-6 + betadery[:, :, j, i] = (Quat.rot_matrix(misoquaty) - np.eye(3)) / self.step_size / 1e-6 # Calculate the Nye Tensor - alpha = np.empty((3, 3, self.yDim, self.xDim)) + alpha = np.empty((3, 3) + self.shape) bavg = 1.4e-10 # Burgers vector alpha[0, 2] = (betadery[0, 0] - betaderx[0, 1]) / bavg alpha[1, 2] = (betadery[1, 0] - betaderx[1, 1]) / bavg @@ -555,12 +543,11 @@ def calcNye(self): # Calculate 3 possible L1 norms of Nye tensor for total # disloction density - alpha_total3 = np.empty((self.yDim, self.xDim)) - alpha_total5 = np.empty((self.yDim, self.xDim)) - alpha_total9 = np.empty((self.yDim, self.xDim)) - alpha_total3 = 30 / 10. *( - abs(alpha[0, 2]) + abs(alpha[1, 2]) + - abs(alpha[2, 2]) + alpha_total3 = np.empty(self.shape) + alpha_total5 = np.empty(self.shape) + alpha_total9 = np.empty(self.shape) + alpha_total3 = 30 / 10. * ( + abs(alpha[0, 2]) + abs(alpha[1, 2]) + abs(alpha[2, 2]) ) alpha_total5 = 30 / 14. * ( abs(alpha[0, 2]) + abs(alpha[1, 2]) + abs(alpha[2, 2]) + @@ -577,298 +564,238 @@ def calcNye(self): # choose from the different alpha_totals according to preference; # see Ruggles GND density paper - self.GND = alpha_total9 - self.Nye = alpha yield 1. + return alpha_total9, alpha - def plotGNDMap(self, **kwargs): - """Plots a map of geometrically necessary dislocation (GND) density - - Parameters - ---------- - kwargs - All arguments are passed to :func:`defdap.plotting.MapPlot.create`. - - Returns - ------- - defdap.plotting.MapPlot - - """ - # Set default plot parameters then update with any input - plotParams = { - 'plotColourBar': True, - 'clabel': "Geometrically necessary dislocation (GND) content" - } - plotParams.update(kwargs) - - self.calcNye() - - plot = MapPlot.create(self, np.log10(self.GND), **plotParams) - - return plot - - def checkDataLoaded(self): - """ Checks if EBSD data is loaded - - Returns - ------- - bool - True if data loaded - - """ - if self.eulerAngleArray is None: - raise Exception("Data not loaded") - return True - - @reportProgress("building quaternion array") - def buildQuatArray(self, force=False): + @report_progress("building quaternion array") + def calc_quat_array(self): """Build quaternion array - Parameters - ---------- - force : bool, optional - If true, re-build quaternion array """ - self.checkDataLoaded() - - if force or self.quatArray is None: - # create the array of quat objects - self.quatArray = Quat.createManyQuats(self.eulerAngleArray) + # create the array of quat objects + quats = Quat.create_many_quats(self.data.euler_angle) yield 1. + return quats - def filterData(self, misOriTol=5): + def filter_data(self, misori_tol=5): # Kuwahara filter print("8 quadrants") - misOriTol *= np.pi / 180 - misOriTol = np.cos(misOriTol / 2) + misori_tol *= np.pi / 180 + misori_tol = np.cos(misori_tol / 2) # store quat components in array - quatComps = np.empty((4,) + self.shape) + quat_comps = np.empty((4,) + self.shape) for idx in np.ndindex(self.shape): - quatComps[(slice(None),) + idx] = self.quatArray[idx].quatCoef + quat_comps[(slice(None),) + idx] = self.data.orientation[idx].quat_coef # misorientation in each quadrant surrounding a point - misOris = np.zeros((8,) + self.shape) + mis_oris = np.zeros((8,) + self.shape) for i in range(2, self.shape[0] - 2): for j in range(2, self.shape[1] - 2): - refQuat = quatComps[:, i, j] + ref_quat = quat_comps[:, i, j] quadrants = [ - quatComps[:, i - 2:i + 1, j - 2:j + 1], # UL - quatComps[:, i - 2:i + 1, j - 1:j + 2], # UC - quatComps[:, i - 2:i + 1, j:j + 3], # UR - quatComps[:, i - 1:i + 2, j:j + 3], # MR - quatComps[:, i:i + 3, j:j + 3], # LR - quatComps[:, i:i + 3, j - 1:j + 2], # LC - quatComps[:, i:i + 3, j - 2:j + 1], # LL - quatComps[:, i - 1:i + 2, j - 2:j + 1] # ML + quat_comps[:, i - 2:i + 1, j - 2:j + 1], # UL + quat_comps[:, i - 2:i + 1, j - 1:j + 2], # UC + quat_comps[:, i - 2:i + 1, j:j + 3], # UR + quat_comps[:, i - 1:i + 2, j:j + 3], # MR + quat_comps[:, i:i + 3, j:j + 3], # LR + quat_comps[:, i:i + 3, j - 1:j + 2], # LC + quat_comps[:, i:i + 3, j - 2:j + 1], # LL + quat_comps[:, i - 1:i + 2, j - 2:j + 1] # ML ] for k, quats in enumerate(quadrants): - misOrisQuad = np.abs( - np.einsum("ijk,i->jk", quats, refQuat) + mis_oris_quad = np.abs( + np.einsum("ijk,i->jk", quats, ref_quat) ) - misOrisQuad = misOrisQuad[misOrisQuad > misOriTol] - misOris[k, i, j] = misOrisQuad.mean() + mis_oris_quad = mis_oris_quad[mis_oris_quad > misori_tol] + mis_oris[k, i, j] = mis_oris_quad.mean() - minMisOriQuadrant = np.argmax(misOris, axis=0) - # minMisOris = np.max(misOris, axis=0) + min_mis_ori_quadrant = np.argmax(mis_oris, axis=0) + # minMisOris = np.max(mis_oris, axis=0) # minMisOris[minMisOris > 1.] = 1. # minMisOris = 2 * np.arccos(minMisOris) - quatCompsNew = np.copy(quatComps) + quat_comps_new = np.copy(quat_comps) for i in range(2, self.shape[0] - 2): for j in range(2, self.shape[1] - 2): # if minMisOris[i, j] < misOriTol: # continue - refQuat = quatComps[:, i, j] + ref_quat = quat_comps[:, i, j] quadrants = [ - quatComps[:, i - 2:i + 1, j - 2:j + 1], # UL - quatComps[:, i - 2:i + 1, j - 1:j + 2], # UC - quatComps[:, i - 2:i + 1, j:j + 3], # UR - quatComps[:, i - 1:i + 2, j:j + 3], # MR - quatComps[:, i:i + 3, j:j + 3], # LR - quatComps[:, i:i + 3, j - 1:j + 2], # LC - quatComps[:, i:i + 3, j - 2:j + 1], # LL - quatComps[:, i - 1:i + 2, j - 2:j + 1] # ML + quat_comps[:, i - 2:i + 1, j - 2:j + 1], # UL + quat_comps[:, i - 2:i + 1, j - 1:j + 2], # UC + quat_comps[:, i - 2:i + 1, j:j + 3], # UR + quat_comps[:, i - 1:i + 2, j:j + 3], # MR + quat_comps[:, i:i + 3, j:j + 3], # LR + quat_comps[:, i:i + 3, j - 1:j + 2], # LC + quat_comps[:, i:i + 3, j - 2:j + 1], # LL + quat_comps[:, i - 1:i + 2, j - 2:j + 1] # ML ] - quats = quadrants[minMisOriQuadrant[i, j]] + quats = quadrants[min_mis_ori_quadrant[i, j]] - misOrisQuad = np.abs( - np.einsum("ijk,i->jk", quats, refQuat) + mis_oris_quad = np.abs( + np.einsum("ijk,i->jk", quats, ref_quat) ) - quats = quats[:, misOrisQuad > misOriTol] + quats = quats[:, mis_oris_quad > misori_tol] avOri = np.einsum("ij->i", quats) # avOri /= np.sqrt(np.dot(avOri, avOri)) - quatCompsNew[:, i, j] = avOri + quat_comps_new[:, i, j] = avOri - quatCompsNew /= np.sqrt(np.einsum("ijk,ijk->jk", quatCompsNew, quatCompsNew)) + quat_comps_new /= np.sqrt(np.einsum("ijk,ijk->jk", quat_comps_new, quat_comps_new)) - quatArrayNew = np.empty(self.shape, dtype=Quat) + quat_array_new = np.empty(self.shape, dtype=Quat) for idx in np.ndindex(self.shape): - quatArrayNew[idx] = Quat(quatCompsNew[(slice(None),) + idx]) + quat_array_new[idx] = Quat(quat_comps_new[(slice(None),) + idx]) - self.quatArray = quatArrayNew + self.data.orientation = quat_array_new return quats - @reportProgress("finding grain boundaries") - def findBoundaries(self, boundDef=10): + @report_progress("finding grain boundaries") + def find_boundaries(self, misori_tol=10): """Find grain and phase boundaries Parameters ---------- - boundDef : float - Critical misorientation. + misori_tol : float + Critical misorientation in degrees. """ # TODO: what happens with non-indexed points # TODO: grain boundaries should be calculated per crystal structure - syms = self.primaryPhase.crystalStructure.symmetries - numSyms = len(syms) + misori_tol *= np.pi / 180 + syms = self.primary_phase.crystal_structure.symmetries + num_syms = len(syms) # array to store quat components of initial and symmetric equivalents - quatComps = np.empty((numSyms, 4, self.yDim, self.xDim)) + quat_comps = np.empty((num_syms, 4) + self.shape) # populate with initial quat components - for i, row in enumerate(self.quatArray): + for i, row in enumerate(self.data.orientation): for j, quat in enumerate(row): - quatComps[0, :, i, j] = quat.quatCoef + quat_comps[0, :, i, j] = quat.quat_coef # loop of over symmetries and apply to initial quat components # (excluding first symmetry as this is the identity transformation) for i, sym in enumerate(syms[1:], start=1): # sym[i] * quat for all points (* is quaternion product) - quatComps[i, 0] = (quatComps[0, 0] * sym[0] - quatComps[0, 1] * sym[1] - - quatComps[0, 2] * sym[2] - quatComps[0, 3] * sym[3]) - quatComps[i, 1] = (quatComps[0, 0] * sym[1] + quatComps[0, 1] * sym[0] - - quatComps[0, 2] * sym[3] + quatComps[0, 3] * sym[2]) - quatComps[i, 2] = (quatComps[0, 0] * sym[2] + quatComps[0, 2] * sym[0] - - quatComps[0, 3] * sym[1] + quatComps[0, 1] * sym[3]) - quatComps[i, 3] = (quatComps[0, 0] * sym[3] + quatComps[0, 3] * sym[0] - - quatComps[0, 1] * sym[2] + quatComps[0, 2] * sym[1]) - + quat_comps[i, 0] = ( + quat_comps[0, 0]*sym[0] - quat_comps[0, 1]*sym[1] - + quat_comps[0, 2]*sym[2] - quat_comps[0, 3]*sym[3] + ) + quat_comps[i, 1] = ( + quat_comps[0, 0]*sym[1] + quat_comps[0, 1]*sym[0] - + quat_comps[0, 2]*sym[3] + quat_comps[0, 3]*sym[2] + ) + quat_comps[i, 2] = ( + quat_comps[0, 0]*sym[2] + quat_comps[0, 2]*sym[0] - + quat_comps[0, 3]*sym[1] + quat_comps[0, 1]*sym[3] + ) + quat_comps[i, 3] = ( + quat_comps[0, 0]*sym[3] + quat_comps[0, 3]*sym[0] - + quat_comps[0, 1]*sym[2] + quat_comps[0, 2]*sym[1] + ) # swap into positive hemisphere if required - quatComps[i, :, quatComps[i, 0] < 0] *= -1 + quat_comps[i, :, quat_comps[i, 0] < 0] *= -1 # Arrays to store neighbour misorientation in positive x and y # directions - misOriX = np.ones((numSyms, self.yDim, self.xDim)) - misOriY = np.ones((numSyms, self.yDim, self.xDim)) + misori_x = np.ones((num_syms, ) + self.shape) + misori_y = np.ones((num_syms, ) + self.shape) # loop over symmetries calculating misorientation to initial - for i in range(numSyms): - for j in range(self.xDim - 1): - misOriX[i, :, j] = abs( - np.einsum("ij,ij->j", quatComps[0, :, :, j], quatComps[i, :, :, j + 1])) + for i in range(num_syms): + for j in range(self.shape[1] - 1): + misori_x[i, :, j] = abs(np.einsum( + "ij,ij->j", quat_comps[0, :, :, j], quat_comps[i, :, :, j+1] + )) - for j in range(self.yDim - 1): - misOriY[i, j, :] = abs(np.einsum("ij,ij->j", quatComps[0, :, j, :], quatComps[i, :, j + 1, :])) + for j in range(self.shape[0] - 1): + misori_y[i, j] = abs(np.einsum( + "ij,ij->j", quat_comps[0, :, j], quat_comps[i, :, j+1] + )) - misOriX[misOriX > 1] = 1 - misOriY[misOriY > 1] = 1 + misori_x[misori_x > 1] = 1 + misori_y[misori_y > 1] = 1 - # find min misorientation (max here as misorientaion is cos of this) - misOriX = np.max(misOriX, axis=0) - misOriY = np.max(misOriY, axis=0) - - # convert to misorientation in degrees - misOriX = 2 * np.arccos(misOriX) * 180 / np.pi - misOriY = 2 * np.arccos(misOriY) * 180 / np.pi - - # GRAIN boundary POINTS where misOriX or misOriY are greater - # than set value - self.boundariesX = misOriX > boundDef - self.boundariesY = misOriY > boundDef + # find max dot product and then convert to misorientation angle + misori_x = 2 * np.arccos(np.max(misori_x, axis=0)) + misori_y = 2 * np.arccos(np.max(misori_y, axis=0)) # PHASE boundary POINTS - self.phaseBoundariesX = np.not_equal( - self.phaseArray, np.roll(self.phaseArray, -1, axis=1)) - self.phaseBoundariesX[:, -1] = False - - self.phaseBoundariesY = np.not_equal( - self.phaseArray, np.roll(self.phaseArray, -1, axis=0)) - self.phaseBoundariesY[-1, :] = False - - self.phaseBoundaries = np.logical_or( - self.phaseBoundariesX, self.phaseBoundariesY) - self.phaseBoundaries = -self.phaseBoundaries.astype(int) - - # add PHASE boundary POINTS to GRAIN boundary POINTS - self.boundariesX = np.logical_or(self.boundariesX, self.phaseBoundariesX) - self.boundariesY = np.logical_or(self.boundariesY, self.phaseBoundariesY) - self.boundaries = np.logical_or(self.boundariesX, self.boundariesY) - self.boundaries = -self.boundaries.astype(int) - - _, _, self.boundaryLines = BoundarySegment.boundary_points_to_lines( - boundary_points_x=zip(*self.boundariesX.transpose().nonzero()), - boundary_points_y=zip(*self.boundariesY.transpose().nonzero()) - ) - - _, _, self.phaseBoundaryLines = BoundarySegment.boundary_points_to_lines( - boundary_points_x=zip(*self.phaseBoundariesX.transpose().nonzero()), - boundary_points_y=zip(*self.phaseBoundariesY.transpose().nonzero()) + phase_im = self.data.phase + pb_im_x = np.not_equal(phase_im, np.roll(phase_im, -1, axis=1)) + pb_im_x[:, -1] = False + pb_im_y = np.not_equal(phase_im, np.roll(phase_im, -1, axis=0)) + pb_im_y[-1] = False + + phase_boundaries = BoundarySet.from_image(self, pb_im_x, pb_im_y) + grain_boundaries = BoundarySet.from_image( + self, + (misori_x > misori_tol) | pb_im_x, + (misori_y > misori_tol) | pb_im_y ) yield 1. + return phase_boundaries, grain_boundaries - @reportProgress("constructing neighbour network") - def buildNeighbourNetwork(self): + @report_progress("constructing neighbour network") + def build_neighbour_network(self): # create network nn = nx.Graph() - nn.add_nodes_from(self.grainList) + nn.add_nodes_from(self.grains) - for i, boundaries in enumerate((self.boundariesX, self.boundariesY)): - yLocs, xLocs = np.nonzero(boundaries) - totalPoints = len(xLocs) + points_x = self.data.grain_boundaries.points_x + points_y = self.data.grain_boundaries.points_y + total_points_x = len(points_x) + total_points = total_points_x + len(points_y) - for iPoint, (x, y) in enumerate(zip(xLocs, yLocs)): - # report progress, assumes roughly equal number of x and - # y boundary points - yield 0.5 * (i + iPoint / totalPoints) + for i, points in enumerate((points_x, points_y)): + for i_point, (x, y) in enumerate(points): + # report progress + yield (i_point + i * total_points_x) / total_points - if (x == 0 or y == 0 or x == self.grains.shape[1] - 1 or - y == self.grains.shape[0] - 1): + if (x == 0 or y == 0 or x == self.shape[1] - 1 or + y == self.shape[0] - 1): # exclude boundary pixels of map continue - grainID = self.grains[y, x] - 1 - neiGrainID = self.grains[y + i, x - i + 1] - 1 - - if neiGrainID == grainID: + grain_id = self.data.grains[y, x] - 1 + nei_grain_id = self.data.grains[y + i, x - i + 1] - 1 + if nei_grain_id == grain_id: # ignore if neighbour is same as grain continue - if neiGrainID < 0 or grainID < 0: + if nei_grain_id < 0 or grain_id < 0: # ignore if not a grain (boundary points -1 and # points in small grains -2) continue - grain = self[grainID] - neiGrain = self[neiGrainID] - + grain = self[grain_id] + nei_grain = self[nei_grain_id] try: # look up boundary segment if it exists - bSeg = nn[grain][neiGrain]['boundary'] + b_seg = nn[grain][nei_grain]['boundary'] except KeyError: # neighbour relation doesn't exist so add it - bSeg = BoundarySegment(self, grain, neiGrain) - nn.add_edge(grain, neiGrain, boundary=bSeg) + b_seg = BoundarySegment(self, grain, nei_grain) + nn.add_edge(grain, nei_grain, boundary=b_seg) # add the boundary point - bSeg.addBoundaryPoint((x, y), i, grain) + b_seg.addBoundaryPoint((x, y), i, grain) - self.neighbourNetwork = nn + self.neighbour_network = nn - @reportProgress("finding phase boundaries") - def plotPhaseBoundaryMap(self, dilate=False, **kwargs): + def plot_phase_boundary_map(self, dilate=False, **kwargs): """Plot phase boundary map. Parameters @@ -884,22 +811,22 @@ def plotPhaseBoundaryMap(self, dilate=False, **kwargs): """ # Set default plot parameters then update with any input - plotParams = { + plot_params = { 'vmax': 1, - 'plotColourBar': True, + 'plot_colour_bar': True, 'cmap': 'gray' } - plotParams.update(kwargs) + plot_params.update(kwargs) - boundariesImage = -self.phaseBoundaries + boundaries_image = self.data.phase_boundaries.image.astype(int) if dilate: - boundariesImage = mph.binary_dilation(boundariesImage) + boundaries_image = mph.binary_dilation(boundaries_image) - plot = MapPlot.create(self, boundariesImage, **plotParams) + plot = MapPlot.create(self, boundaries_image, **plot_params) return plot - def plotBoundaryMap(self, **kwargs): + def plot_boundary_map(self, **kwargs): """Plot grain boundary map. Parameters @@ -913,60 +840,68 @@ def plotBoundaryMap(self, **kwargs): """ # Set default plot parameters then update with any input - plotParams = { - 'plotGBs': True, + plot_params = { + 'plot_gbs': True, 'boundaryColour': 'black' } - plotParams.update(kwargs) + plot_params.update(kwargs) - plot = MapPlot.create(self, None, **plotParams) + plot = MapPlot.create(self, None, **plot_params) return plot - @reportProgress("finding grains") - def findGrains(self, minGrainSize=10): + @report_progress("finding grains") + def find_grains(self, min_grain_size=10): """Find grains and assign IDs. Parameters ---------- - minGrainSize : int + min_grain_size : int Minimum grain area in pixels. """ # Initialise the grain map # TODO: Look at grain map compared to boundary map - # self.grains = np.copy(self.boundaries) - self.grains = np.zeros_like(self.boundaries) + grains = np.zeros(self.shape, dtype=int) + grain_list = [] - self.grainList = [] + boundary_im_x = self.data.grain_boundaries.image_x + boundary_im_y = self.data.grain_boundaries.image_y # List of points where no grain has be set yet - points_left = self.phaseArray != 0 + points_left = self.data.phase != 0 total_points = points_left.sum() found_point = 0 next_point = points_left.tobytes().find(b'\x01') # Start counter for grains - grainIndex = 1 + grain_index = 1 + group_id = Datastore.generate_id() # Loop until all points (except boundaries) have been assigned # to a grain or ignored i = 0 + coords_buffer = np.zeros((boundary_im_y.size, 2), dtype=np.intp) while found_point >= 0: # Flood fill first unknown point and return grain object - idx = np.unravel_index(next_point, self.grains.shape) - currentGrain = self.floodFill(idx[1], idx[0], grainIndex, - points_left) + seed = np.unravel_index(next_point, self.shape) - if len(currentGrain) < minGrainSize: + grain = Grain(grain_index - 1, self, group_id) + grain.data.point = flood_fill( + (seed[1], seed[0]), grain_index, points_left, grains, + boundary_im_x, boundary_im_y, coords_buffer + ) + coords_buffer = coords_buffer[len(grain.data.point):] + + if len(grain) < min_grain_size: # if grain size less than minimum, ignore grain and set # values in grain map to -2 - for coord in currentGrain.coordList: - self.grains[coord[1], coord[0]] = -2 + for point in grain.data.point: + grains[point[1], point[0]] = -2 else: # add grain to list and increment grain index - self.grainList.append(currentGrain) - grainIndex += 1 + grain_list.append(grain) + grain_index += 1 # find next search point points_left_sub = points_left.reshape(-1)[next_point + 1:] @@ -980,21 +915,35 @@ def findGrains(self, minGrainSize=10): i = 0 # Assign phase to each grain - for grain in self: - phaseVals = grain.grainData(self.phaseArray) - if np.max(phaseVals) != np.min(phaseVals): - warn(f"Grain {grain.grainID} could not be assigned a " + for grain in grain_list: + phase_vals = grain.grain_data(self.data.phase) + if np.max(phase_vals) != np.min(phase_vals): + warn(f"Grain {grain.grain_id} could not be assigned a " f"phase, phase vals not constant.") continue - phaseID = phaseVals[0] - 1 - if not (0 <= phaseID < self.numPhases): - warn(f"Grain {grain.grainID} could not be assigned a " - f"phase, invalid phase {phaseID}.") + phase_id = phase_vals[0] - 1 + if not (0 <= phase_id < self.num_phases): + warn(f"Grain {grain.grain_id} could not be assigned a " + f"phase, invalid phase {phase_id}.") continue - grain.phaseID = phaseID - grain.phase = self.phases[phaseID] + grain.phase_id = phase_id + grain.phase = self.phases[phase_id] + + ## TODO: this will get duplicated if find grains called again + self.data.add_derivative( + grain_list[0].data, self.grain_data_to_map, pass_ref=True, + in_props={ + 'type': 'list' + }, + out_props={ + 'type': 'map' + } + ) + + self._grains = grain_list + return grains - def plotGrainMap(self, **kwargs): + def plot_grain_map(self, **kwargs): """Plot a map with grains coloured. Parameters @@ -1008,126 +957,45 @@ def plotGrainMap(self, **kwargs): """ # Set default plot parameters then update with any input - plotParams = { + plot_params = { 'clabel': "Grain number" } - plotParams.update(kwargs) + plot_params.update(kwargs) - plot = MapPlot.create(self, self.grains, **plotParams) + plot = MapPlot.create(self, self.data.grains, **plot_params) return plot - def floodFill(self, x, y, grainIndex, points_left): - """Flood fill algorithm that uses the x and y boundary arrays to - fill a connected area around the seed point. The points are inserted - into a grain object and the grain map array is updated. - - Parameters - ---------- - x : int - Seed point x for flood fill - y : int - Seed point y for flood fill - grainIndex : int - Value to fill in grain map - points_left : numpy.ndarray - Boolean map of the points that have not been assigned a grain yet - - Returns - ------- - currentGrain : defdap.ebsd.Grain - New grain object with points added - """ - # create new grain - currentGrain = Grain(grainIndex - 1, self) - - # add first point to the grain - currentGrain.addPoint((x, y), self.quatArray[y, x]) - self.grains[y, x] = grainIndex - points_left[y, x] = False - edge = [(x, y)] - - while edge: - x, y = edge.pop(0) - - moves = [(x+1, y), (x-1, y), (x, y+1), (x, y-1)] - # get rid of any that go out of the map area - if x <= 0: - moves.pop(1) - elif x >= self.xDim - 1: - moves.pop(0) - if y <= 0: - moves.pop(-1) - elif y >= self.yDim - 1: - moves.pop(-2) - - for (s, t) in moves: - if self.grains[t, s] > 0: - continue - - addPoint = False - - if t == y: - # moving horizontally - if s > x: - # moving right - addPoint = not self.boundariesX[y, x] - else: - # moving left - addPoint = not self.boundariesX[t, s] - else: - # moving vertically - if t > y: - # moving down - addPoint = not self.boundariesY[y, x] - else: - # moving up - addPoint = not self.boundariesY[t, s] - - if addPoint: - currentGrain.addPoint((s, t), self.quatArray[t, s]) - self.grains[t, s] = grainIndex - points_left[t, s] = False - edge.append((s, t)) - - return currentGrain - - @reportProgress("calculating grain mean orientations") - def calcGrainAvOris(self): + @report_progress("calculating grain mean orientations") + def calc_grain_av_oris(self): """Calculate the average orientation of grains. """ - # Check that grains have been detected in the map - self.checkGrainsDetected() - numGrains = len(self) for iGrain, grain in enumerate(self): - grain.calcAverageOri() + grain.calc_average_ori() # report progress yield (iGrain + 1) / numGrains - @reportProgress("calculating grain misorientations") - def calcGrainMisOri(self, calcAxis=False): + @report_progress("calculating grain misorientations") + def calc_grain_mis_ori(self, calc_axis=False): """Calculate the misorientation within grains. Parameters ---------- - calcAxis : bool + calc_axis : bool Calculate the misorientation axis if True. """ - # Check that grains have been detected in the map - self.checkGrainsDetected() - - numGrains = len(self) - for iGrain, grain in enumerate(self): - grain.buildMisOriList(calcAxis=calcAxis) + num_grains = len(self) + for i_grain, grain in enumerate(self): + grain.build_mis_ori_list(calc_axis=calc_axis) # report progress - yield (iGrain + 1) / numGrains + yield (i_grain + 1) / num_grains - def plotMisOriMap(self, component=0, **kwargs): + def plot_mis_ori_map(self, component=0, **kwargs): """Plot misorientation map. Parameters @@ -1142,72 +1010,76 @@ def plotMisOriMap(self, component=0, **kwargs): defdap.plotting.MapPlot """ - # Check that grains have been detected in the map - self.checkGrainsDetected() - - self.misOri = np.ones([self.yDim, self.xDim]) - if component in [1, 2, 3]: + self.mis_ori = np.zeros(self.shape) # Calculate misorientation axis if not calculated - if np.any([grain.misOriAxisList is None for grain in self.grainList]): - self.calcGrainMisOri(calcAxis = True) - for grain in self.grainList: - for coord, misOriAxis in zip(grain.coordList, np.array(grain.misOriAxisList)): - self.misOri[coord[1], coord[0]] = misOriAxis[component - 1] - - misOri = self.misOri * 180 / np.pi - clabel = "Rotation around {:} axis ($^\circ$)".format( + if np.any([grain.mis_ori_axis_list is None for grain in self]): + self.calc_grain_mis_ori(calc_axis=True) + for grain in self: + for point, mis_ori_axis in zip(grain.data.point, np.array(grain.mis_ori_axis_list)): + self.mis_ori[point[1], point[0]] = mis_ori_axis[component - 1] + + mis_ori = self.mis_ori * 180 / np.pi + clabel = r"Rotation around {:} axis ($^\circ$)".format( ['X', 'Y', 'Z'][component-1] ) else: + self.mis_ori = np.ones(self.shape) # Calculate misorientation if not calculated - if np.any([grain.misOriList is None for grain in self.grainList]): - self.calcGrainMisOri(calcAxis = False) - for grain in self.grainList: - for coord, misOri in zip(grain.coordList, grain.misOriList): - self.misOri[coord[1], coord[0]] = misOri + if np.any([grain.mis_ori_list is None for grain in self]): + self.calc_grain_mis_ori(calc_axis=False) + for grain in self: + for point, mis_ori in zip(grain.data.point, grain.mis_ori_list): + self.mis_ori[point[1], point[0]] = mis_ori - misOri = np.arccos(self.misOri) * 360 / np.pi - clabel = "Grain reference orienation deviation (GROD) ($^\circ$)" + mis_ori = np.arccos(self.mis_ori) * 360 / np.pi + clabel = r"Grain reference orienation deviation (GROD) ($^\circ$)" # Set default plot parameters then update with any input - plotParams = { - 'plotColourBar': True, + plot_params = { + 'plot_colour_bar': True, 'clabel': clabel } - plotParams.update(kwargs) + plot_params.update(kwargs) - plot = MapPlot.create(self, misOri, **plotParams) + plot = MapPlot.create(self, mis_ori, **plot_params) return plot - @reportProgress("calculating grain average Schmid factors") - def calcAverageGrainSchmidFactors(self, loadVector, slipSystems=None): + @report_progress("calculating grain average Schmid factors") + def calc_average_grain_schmid_factors(self, load_vector, slip_systems=None): """ Calculates Schmid factors for all slip systems, for all grains, based on average grain orientation. Parameters ---------- - loadVector : + load_vector : Loading vector, e.g. [1, 0, 0]. - slipSystems : list, optional + slip_systems : list, optional Slip planes to calculate Schmid factor for, maximum of all planes calculated if not given. """ - # Check that grains have been detected in the map - self.checkGrainsDetected() + num_grains = len(self) + for iGrain, grain in enumerate(self): + grain.calc_average_schmid_factors(load_vector, slip_systems=slip_systems) - numGrains = len(self) - for iGrain, grain in enumerate(self.grainList): - grain.calcAverageSchmidFactors(loadVector, slipSystems=slipSystems) + # report progress + yield (iGrain + 1) / num_grains + + @report_progress("calculating RDR values") + def calc_rdr(self): + """Calculates Relative Displacent Ratio values for all grains""" + num_grains = len(self) + for iGrain, grain in enumerate(self): + grain.calc_rdr() # report progress - yield (iGrain + 1) / numGrains + yield (iGrain + 1) / num_grains - def plotAverageGrainSchmidFactorsMap(self, planes=None, directions=None, - **kwargs): + def plot_average_grain_schmid_factors_map(self, planes=None, directions=None, + **kwargs): """ Plot maximum Schmid factor map, based on average grain orientation (for all slip systems unless specified). @@ -1231,19 +1103,16 @@ def plotAverageGrainSchmidFactorsMap(self, planes=None, directions=None, 'vmin': 0, 'vmax': 0.5, 'cmap': 'gray', - 'plotColourBar': True, + 'plot_colour_bar': True, 'clabel': "Schmid factor" } plot_params.update(kwargs) - # Check that grains have been detected in the map - self.checkGrainsDetected() - - if self[0].averageSchmidFactors is None: - raise Exception("Run 'calcAverageGrainSchmidFactors' first") + if self[0].average_schmid_factors is None: + raise Exception("Run 'calc_average_grain_schmid_factors' first") grains_sf_max = [] - for grain in self.grainList: + for grain in self: current_sf = [] if planes is not None: @@ -1251,18 +1120,18 @@ def plotAverageGrainSchmidFactorsMap(self, planes=None, directions=None, if directions is not None: for direction in directions: current_sf.append( - grain.averageSchmidFactors[plane][direction] + grain.average_schmid_factors[plane][direction] ) else: - current_sf += grain.averageSchmidFactors[plane] + current_sf += grain.average_schmid_factors[plane] else: - for sf_group in grain.averageSchmidFactors: + for sf_group in grain.average_schmid_factors: current_sf += sf_group grains_sf_max.append(max(current_sf)) - plot = self.plotGrainDataMap(grainData=grains_sf_max, bg=0.5, - **plot_params) + plot = self.plot_grain_data_map(grain_data=grains_sf_max, bg=0.5, + **plot_params) return plot @@ -1274,132 +1143,171 @@ class Grain(base.Grain): Attributes ---------- - ebsdMap : defdap.ebsd.Map + ebsd_map : defdap.ebsd.Map EBSD map this grain is a member of. - ownerMap : defdap.ebsd.Map + owner_map : defdap.ebsd.Map EBSD map this grain is a member of. - phaseID : int + phase_id : int phase : defdap.crystal.Phase - quatList : list - List of quats. - misOriList : list + data : defdap.utils.Datastore + Must contain after creating: + point : list of tuples + (x, y) + Generated data: + GROD : numpy.ndarray + Grain reference orientation distribution magnitude + GROD_axis : numpy.ndarray + Grain reference orientation distribution direction + Derived data: + Map data to list data from the map the grain is part of + + + mis_ori_list : list MisOri at each point in grain. - misOriAxisList : list + mis_ori_axis_list : list MisOri axes at each point in grain. - refOri : defdap.quat.Quat + ref_ori : defdap.quat.Quat Average ori of grain - averageMisOri - Average misOri of grain. - averageSchmidFactors : list + average_mis_ori + Average mis_ori of grain. + average_schmid_factors : list List of list Schmid factors (grouped by slip plane). - slipTraceAngles : list + slip_trace_angles : list Slip trace angles in screen plane. - slipTraceInclinations : list + slip_trace_inclinations : list Angle between slip plane and screen plane. """ - def __init__(self, grainID, ebsdMap): + def __init__(self, grain_id, ebsdMap, group_id): # Call base class constructor - super(Grain, self).__init__(grainID, ebsdMap) - - self.ebsdMap = self.ownerMap # ebsd map this grain is a member of - self.quatList = [] # list of quats - self.misOriList = None # list of misOri at each point in grain - self.misOriAxisList = None # list of misOri axes at each point in grain - self.refOri = None # (quat) average ori of grain - self.averageMisOri = None # average misOri of grain - - self.averageSchmidFactors = None # list of list Schmid factors (grouped by slip plane) - self.slipTraceAngles = None # list of slip trace angles - self.slipTraceInclinations = None - - @property - def plotDefault(self): - return lambda *args, **kwargs: self.plotUnitCell( - *args, **kwargs + super(Grain, self).__init__(grain_id, ebsdMap, group_id) + + self.ebsd_map = self.owner_map # ebsd map this grain is a member of + self.mis_ori_list = None # list of mis_ori at each point in grain + self.mis_ori_axis_list = None # list of mis_ori axes at each point in grain + self.ref_ori = None # (quat) average ori of grain + self.average_mis_ori = None # average mis_ori of grain + + self.average_schmid_factors = None # list of list Schmid factors (grouped by slip plane) + self.slip_trace_angles = None # list of slip trace angles + self.slip_trace_inclinations = None + + self.plot_default = self.plot_unit_cell + + self.data.add_generator( + ('GROD', 'GROD_axis'), self.calc_grod, + type='list', + metadatas=({ + 'unit': 'rad', + 'order': 0, + 'plot_params': { + 'plot_colour_bar': True, + 'clabel': 'GROD', + } + }, { + 'unit': '', + 'order': 1, + 'default_component': 0, + 'plot_params': { + 'plot_colour_bar': True, + 'clabel': 'GROD axis', + } + }) ) @property - def crystalSym(self): + def crystal_sym(self): """Temporary""" - return self.phase.crystalStructure.name - - def addPoint(self, coord, quat): - """Append a coordinate and a quat to a grain. + return self.phase.crystal_structure.name - Parameters - ---------- - coord : tuple - (x,y) coordinate to append - quat : defdap.quat.Quat - Quaternion to append. - - """ - self.coordList.append(coord) - self.quatList.append(quat) - - def calcAverageOri(self): + def calc_average_ori(self): """Calculate the average orientation of a grain. """ - quatCompsSym = Quat.calcSymEqvs(self.quatList, self.crystalSym) + quat_comps_sym = Quat.calc_sym_eqvs(self.data.orientation, self.crystal_sym) - self.refOri = Quat.calcAverageOri(quatCompsSym) + self.ref_ori = Quat.calc_average_ori(quat_comps_sym) - def buildMisOriList(self, calcAxis=False): + def build_mis_ori_list(self, calc_axis=False): """Calculate the misorientation within given grain. Parameters ---------- - calcAxis : bool + calc_axis : bool Calculate the misorientation axis if True. """ - quatCompsSym = Quat.calcSymEqvs(self.quatList, self.crystalSym) + quat_comps_sym = Quat.calc_sym_eqvs(self.data.orientation, self.crystal_sym) - if self.refOri is None: - self.refOri = Quat.calcAverageOri(quatCompsSym) + if self.ref_ori is None: + self.ref_ori = Quat.calc_average_ori(quat_comps_sym) - misOriArray, minQuatComps = Quat.calcMisOri(quatCompsSym, self.refOri) + mis_ori_array, min_quat_comps = Quat.calcMisOri(quat_comps_sym, self.ref_ori) - self.averageMisOri = misOriArray.mean() - self.misOriList = list(misOriArray) + self.average_mis_ori = mis_ori_array.mean() + self.mis_ori_list = list(mis_ori_array) - if calcAxis: - # Now for axis calulation - refOriInv = self.refOri.conjugate + if calc_axis: + # Now for axis calculation + ref_ori_inv = self.ref_ori.conjugate - misOriAxis = np.empty((3, minQuatComps.shape[1])) - Dq = np.empty((4, minQuatComps.shape[1])) + mis_ori_axis = np.empty((3, min_quat_comps.shape[1])) + dq = np.empty((4, min_quat_comps.shape[1])) - # refOriInv * minQuat for all points (* is quaternion product) - # change to minQuat * refOriInv - Dq[0, :] = (refOriInv[0] * minQuatComps[0, :] - refOriInv[1] * minQuatComps[1, :] - - refOriInv[2] * minQuatComps[2, :] - refOriInv[3] * minQuatComps[3, :]) + # ref_ori_inv * minQuat for all points (* is quaternion product) + # change to minQuat * ref_ori_inv + dq[0, :] = (ref_ori_inv[0] * min_quat_comps[0, :] - ref_ori_inv[1] * min_quat_comps[1, :] - + ref_ori_inv[2] * min_quat_comps[2, :] - ref_ori_inv[3] * min_quat_comps[3, :]) - Dq[1, :] = (refOriInv[1] * minQuatComps[0, :] + refOriInv[0] * minQuatComps[1, :] + - refOriInv[3] * minQuatComps[2, :] - refOriInv[2] * minQuatComps[3, :]) + dq[1, :] = (ref_ori_inv[1] * min_quat_comps[0, :] + ref_ori_inv[0] * min_quat_comps[1, :] + + ref_ori_inv[3] * min_quat_comps[2, :] - ref_ori_inv[2] * min_quat_comps[3, :]) - Dq[2, :] = (refOriInv[2] * minQuatComps[0, :] + refOriInv[0] * minQuatComps[2, :] + - refOriInv[1] * minQuatComps[3, :] - refOriInv[3] * minQuatComps[1, :]) + dq[2, :] = (ref_ori_inv[2] * min_quat_comps[0, :] + ref_ori_inv[0] * min_quat_comps[2, :] + + ref_ori_inv[1] * min_quat_comps[3, :] - ref_ori_inv[3] * min_quat_comps[1, :]) - Dq[3, :] = (refOriInv[3] * minQuatComps[0, :] + refOriInv[0] * minQuatComps[3, :] + - refOriInv[2] * minQuatComps[1, :] - refOriInv[1] * minQuatComps[2, :]) + dq[3, :] = (ref_ori_inv[3] * min_quat_comps[0, :] + ref_ori_inv[0] * min_quat_comps[3, :] + + ref_ori_inv[2] * min_quat_comps[1, :] - ref_ori_inv[1] * min_quat_comps[2, :]) - Dq[:, Dq[0] < 0] = -Dq[:, Dq[0] < 0] + dq[:, dq[0] < 0] = -dq[:, dq[0] < 0] # numpy broadcasting taking care of different array sizes - misOriAxis[:, :] = (2 * Dq[1:4, :] * np.arccos(Dq[0, :])) / np.sqrt(1 - np.power(Dq[0, :], 2)) + mis_ori_axis[:, :] = (2 * dq[1:4, :] * np.arccos(dq[0, :])) / np.sqrt(1 - np.power(dq[0, :], 2)) # hack it back into a list. Need to change self.*List to be arrays, it was a bad decision to # make them lists in the beginning - self.misOriAxisList = [] - for row in misOriAxis.transpose(): - self.misOriAxisList.append(row) - - def plotRefOri(self, direction=np.array([0, 0, 1]), **kwargs): + self.mis_ori_axis_list = [] + for row in mis_ori_axis.transpose(): + self.mis_ori_axis_list.append(row) + + def calc_grod(self): + quat_comps = Quat.calc_sym_eqvs(self.data.orientation, self.crystal_sym) + + if self.ref_ori is None: + self.ref_ori = Quat.calc_average_ori(quat_comps) + + misori, quat_comps = Quat.calcMisOri(quat_comps, self.ref_ori) + misori = 2 * np.arccos(misori) + + ref_ori_inv = self.ref_ori.conjugate + dq = np.empty((4, len(self))) + # ref_ori_inv * quat_comps for all points + # change to quat_comps * ref_ori_inv + dq[0] = (ref_ori_inv[0]*quat_comps[0] - ref_ori_inv[1]*quat_comps[1] - + ref_ori_inv[2]*quat_comps[2] - ref_ori_inv[3]*quat_comps[3]) + dq[1] = (ref_ori_inv[1]*quat_comps[0] + ref_ori_inv[0]*quat_comps[1] + + ref_ori_inv[3]*quat_comps[2] - ref_ori_inv[2]*quat_comps[3]) + dq[2] = (ref_ori_inv[2]*quat_comps[0] + ref_ori_inv[0]*quat_comps[2] + + ref_ori_inv[1]*quat_comps[3] - ref_ori_inv[3]*quat_comps[1]) + dq[3] = (ref_ori_inv[3]*quat_comps[0] + ref_ori_inv[0]*quat_comps[3] + + ref_ori_inv[2]*quat_comps[1] - ref_ori_inv[1]*quat_comps[2]) + dq[:, dq[0] < 0] *= -1 + misori_axis = (2 * dq[1:4] * np.arccos(dq[0])) / np.sqrt(1 - dq[0]**2) + + return misori, misori_axis + + def plot_ref_ori(self, direction=np.array([0, 0, 1]), **kwargs): """Plot the average grain orientation on an IPF. Parameters @@ -1407,19 +1315,19 @@ def plotRefOri(self, direction=np.array([0, 0, 1]), **kwargs): direction : numpy.ndarray Sample direction for IPF. kwargs - All other arguments are passed to :func:`defdap.quat.Quat.plotIPF`. + All other arguments are passed to :func:`defdap.quat.Quat.plot_ipf`. Returns ------- defdap.plotting.PolePlot """ - plotParams = {'marker': '+'} - plotParams.update(kwargs) - return Quat.plotIPF([self.refOri], direction, self.crystalSym, - **plotParams) + plot_params = {'marker': '+'} + plot_params.update(kwargs) + return Quat.plot_ipf([self.ref_ori], direction, self.crystal_sym, + **plot_params) - def plotOriSpread(self, direction=np.array([0, 0, 1]), **kwargs): + def plot_ori_spread(self, direction=np.array([0, 0, 1]), **kwargs): """Plot all orientations within a given grain, on an IPF. Parameters @@ -1427,19 +1335,19 @@ def plotOriSpread(self, direction=np.array([0, 0, 1]), **kwargs): direction : numpy.ndarray Sample direction for IPF. kwargs - All other arguments are passed to :func:`defdap.quat.Quat.plotIPF`. + All other arguments are passed to :func:`defdap.quat.Quat.plot_ipf`. Returns ------- defdap.plotting.PolePlot """ - plotParams = {'marker': '.'} - plotParams.update(kwargs) - return Quat.plotIPF(self.quatList, direction, self.crystalSym, - **plotParams) + plot_params = {'marker': '.'} + plot_params.update(kwargs) + return Quat.plot_ipf(self.data.orientation, direction, self.crystal_sym, + **plot_params) - def plotUnitCell(self, fig=None, ax=None, plot=None, **kwargs): + def plot_unit_cell(self, fig=None, ax=None, plot=None, **kwargs): """Plot an unit cell of the average grain orientation. Parameters @@ -1451,16 +1359,16 @@ def plotUnitCell(self, fig=None, ax=None, plot=None, **kwargs): plot : defdap.plotting.PolePlot defdap plot to plot the figure to. kwargs - All other arguments are passed to :func:`defdap.quat.Quat.plotUnitCell`. + All other arguments are passed to :func:`defdap.quat.Quat.plot_unit_cell`. """ - crystalStructure = self.ebsdMap.phases[self.phaseID].crystalStructure - plot = Quat.plotUnitCell(self.refOri, fig=fig, ax=ax, plot=plot, - crystalStructure=crystalStructure, **kwargs) + crystal_structure = self.ebsd_map.phases[self.phase_id].crystal_structure + plot = Quat.plot_unit_cell(self.ref_ori, fig=fig, ax=ax, plot=plot, + crystal_structure=crystal_structure, **kwargs) return plot - def plotMisOri(self, component=0, **kwargs): + def plot_mis_ori(self, component=0, **kwargs): """Plot misorientation map for a given grain. Parameters @@ -1468,7 +1376,7 @@ def plotMisOri(self, component=0, **kwargs): component : int, {0, 1, 2, 3} 0 gives misorientation, 1, 2, 3 gives rotation about x, y, z. kwargs - All other arguments are passed to :func:`defdap.ebsd.plotGrainData`. + All other arguments are passed to :func:`defdap.ebsd.plot_grain_data`. Returns ------- @@ -1478,152 +1386,253 @@ def plotMisOri(self, component=0, **kwargs): component = int(component) # Set default plot parameters then update with any input - plotParams = { - 'plotColourBar': True + plot_params = { + 'plot_colour_bar': True } if component == 0: - if self.misOriList is None: self.buildMisOriList() - plotParams['clabel'] = "Grain reference orientation " \ - "deviation (GROD) ($^\circ$)" - plotData = np.rad2deg(2 * np.arccos(self.misOriList)) + if self.mis_ori_list is None: self.build_mis_ori_list() + plot_params['clabel'] = r"Grain reference orientation " \ + r"deviation (GROD) ($^\circ$)" + plot_data = np.rad2deg(2 * np.arccos(self.mis_ori_list)) elif 0 < component < 4: - if self.misOriAxisList is None: self.buildMisOriList(calcAxis=True) - plotParams['clabel'] = "Rotation around {:} ($^\circ$)".format( + if self.mis_ori_axis_list is None: self.build_mis_ori_list(calc_axis=True) + plot_params['clabel'] = r"Rotation around {:} ($^\circ$)".format( ['X', 'Y', 'Z'][component-1] ) - plotData = np.rad2deg(np.array(self.misOriAxisList)[:, component-1]) + plot_data = np.rad2deg(np.array(self.mis_ori_axis_list)[:, component - 1]) else: raise ValueError("Component must between 0 and 3") - plotParams.update(kwargs) + plot_params.update(kwargs) - plot = self.plotGrainData(grainData=plotData, **plotParams) + plot = self.plot_grain_data(grain_data=plot_data, **plot_params) return plot # define load axis as unit vector - def calcAverageSchmidFactors(self, loadVector, slipSystems=None): + def calc_average_schmid_factors(self, load_vector, slip_systems=None): """Calculate Schmid factors for grain, using average orientation. Parameters ---------- - loadVector : numpy.ndarray + load_vector : numpy.ndarray Loading vector, i.e. [1, 0, 0] - slipSystems : list, optional + slip_systems : list, optional Slip planes to calculate Schmid factor for. Maximum for all planes used if not set. """ - if slipSystems is None: - slipSystems = self.phase.slipSystems - if self.refOri is None: - self.calcAverageOri() + if slip_systems is None: + slip_systems = self.phase.slip_systems + if self.ref_ori is None: + self.calc_average_ori() # orientation of grain - grainAvOri = self.refOri + grain_av_ori = self.ref_ori # Transform the load vector into crystal coordinates - loadVectorCrystal = grainAvOri.transformVector(loadVector) + load_vector_crystal = grain_av_ori.transform_vector(load_vector) - self.averageSchmidFactors = [] + self.average_schmid_factors = [] # flatten list of lists - # slipSystems = chain.from_iterable(slipSystems) + # slip_systems = chain.from_iterable(slip_systems) # Loop over groups of slip systems with same slip plane - for i, slipSystemGroup in enumerate(slipSystems): - self.averageSchmidFactors.append([]) + for i, slip_system_group in enumerate(slip_systems): + self.average_schmid_factors.append([]) # Then loop over individual slip systems - for slipSystem in slipSystemGroup: - schmidFactor = abs(np.dot(loadVectorCrystal, slipSystem.slipPlane) * - np.dot(loadVectorCrystal, slipSystem.slipDir)) - self.averageSchmidFactors[i].append(schmidFactor) + for slip_system in slip_system_group: + schmidFactor = abs(np.dot(load_vector_crystal, slip_system.slip_plane) * + np.dot(load_vector_crystal, slip_system.slip_dir)) + self.average_schmid_factors[i].append(schmidFactor) return + def calc_rdr(self): + """Calculate Relative Displacement Ratio values.""" + self.rdr = [] + + # Loop over groups of slip systems with same slip plane + for i, slip_system_group in enumerate(self.phase.slip_systems): + self.rdr.append([]) + # Then loop over individual slip systems + for slip_system in slip_system_group: + slip_dir_sample = self.ref_ori.conjugate.transform_vector(slip_system.slip_dir) + self.rdr[i].append(-slip_dir_sample[0] / slip_dir_sample[1]) + @property - def slipTraces(self): + def slip_traces(self): """Returns list of slip trace angles. Returns ------- list - Slip trace angles based on grain orientation in calcSlipTraces. + Slip trace angles based on grain orientation in calc_slip_traces. """ - if self.slipTraceAngles is None: - self.calcSlipTraces() + if self.slip_trace_angles is None: + self.calc_slip_traces() - return self.slipTraceAngles + return self.slip_trace_angles - def printSlipTraces(self): + def print_slip_traces(self): """Print a list of slip planes (with colours) and slip directions """ - self.calcSlipTraces() + self.calc_slip_traces() - if self.averageSchmidFactors is None: - raise Exception("Run 'calcAverageGrainSchmidFactors' on the EBSD map first") + if self.average_schmid_factors is None: + raise Exception("Run 'calc_average_grain_schmid_factors' on the EBSD map first") - for ssGroup, colour, sfGroup, slipTrace in zip( - self.phase.slipSystems, - self.phase.slipTraceColours, - self.averageSchmidFactors, - self.slipTraces + for ss_group, colour, sf_group, slip_trace in zip( + self.phase.slip_systems, + self.phase.slip_trace_colours, + self.average_schmid_factors, + self.slip_traces ): - print('{0}\tColour: {1}\tAngle: {2:.2f}'.format(ssGroup[0].slipPlaneLabel, colour, slipTrace * 180 / np.pi)) - for ss, sf in zip(ssGroup, sfGroup): - print(' {0} SF: {1:.3f}'.format(ss.slipDirLabel, sf)) + print('{0}\tColour: {1}\tAngle: {2:.2f}'.format(ss_group[0].slip_plane_label, colour, slip_trace * 180 / np.pi)) + for ss, sf in zip(ss_group, sf_group): + print(' {0} SF: {1:.3f}'.format(ss.slip_dir_label, sf)) - def calcSlipTraces(self, slipSystems=None): + def calc_slip_traces(self, slip_systems=None): """Calculates list of slip trace angles based on grain orientation. Parameters ------- - slipSystems : defdap.crystal.SlipSystem, optional + slip_systems : defdap.crystal.SlipSystem, optional """ - if slipSystems is None: - slipSystems = self.phase.slipSystems - if self.refOri is None: - self.calcAverageOri() + if slip_systems is None: + slip_systems = self.phase.slip_systems + if self.ref_ori is None: + self.calc_average_ori() - screenPlaneNorm = np.array((0, 0, 1)) # in sample orientation frame + screen_plane_norm = np.array((0, 0, 1)) # in sample orientation frame - grainAvOri = self.refOri # orientation of grain + grain_av_ori = self.ref_ori # orientation of grain - screenPlaneNormCrystal = grainAvOri.transformVector(screenPlaneNorm) + screen_plane_norm_crystal = grain_av_ori.transform_vector(screen_plane_norm) - self.slipTraceAngles = [] - self.slipTraceInclinations = [] + self.slip_trace_angles = [] + self.slip_trace_inclinations = [] # Loop over each group of slip systems - for slipSystemGroup in slipSystems: + for slip_system_group in slip_systems: # Take slip plane from first in group - slipPlaneNorm = slipSystemGroup[0].slipPlane - # planeLabel = slipSystemGroup[0].slipPlaneLabel + slip_plane_norm = slip_system_group[0].slip_plane + # planeLabel = slip_system_group[0].slip_plane_label # Calculate intersection of slip plane with plane of screen - intersectionCrystal = np.cross(screenPlaneNormCrystal, slipPlaneNorm) + intersection_crystal = np.cross(screen_plane_norm_crystal, slip_plane_norm) # Calculate angle between slip plane and screen plane - inclination = np.arccos(np.dot(screenPlaneNormCrystal, slipPlaneNorm)) + inclination = np.arccos(np.dot(screen_plane_norm_crystal, slip_plane_norm)) if inclination > np.pi / 2: inclination = np.pi - inclination # print("{} inclination: {:.1f}".format(planeLabel, inclination * 180 / np.pi)) # Transform intersection back into sample coordinates and normalise - intersection = grainAvOri.conjugate.transformVector(intersectionCrystal) + intersection = grain_av_ori.conjugate.transform_vector(intersection_crystal) intersection = intersection / np.sqrt(np.dot(intersection, intersection)) # Calculate trace angle. Starting vertical and proceeding # counter clockwise if intersection[0] > 0: intersection *= -1 - traceAngle = np.arccos(np.dot(intersection, np.array([0, 1.0, 0]))) + trace_angle = np.arccos(np.dot(intersection, np.array([0, 1.0, 0]))) # Append to list - self.slipTraceAngles.append(traceAngle) - self.slipTraceInclinations.append(inclination) + self.slip_trace_angles.append(trace_angle) + self.slip_trace_inclinations.append(inclination) + + +class BoundarySet(object): + # boundaries : numpy.ndarray + # Map of boundaries. -1 for a boundary, 0 otherwise. + # phaseBoundaries : numpy.ndarray + # Map of phase boundaries. -1 for boundary, 0 otherwise. + def __init__(self, ebsd_map, points_x, points_y): + self.ebsd_map = ebsd_map + self.points_x = set(points_x) + self.points_y = set(points_y) + + @classmethod + def from_image(cls, ebsd_map, image_x, image_y): + return cls( + ebsd_map, + zip(*image_x.transpose().nonzero()), + zip(*image_y.transpose().nonzero()) + ) + + @classmethod + def from_boundary_segments(cls, b_segs): + points_x = [] + points_y = [] + for b_seg in b_segs: + points_x += b_seg.boundary_points_x + points_y += b_seg.boundary_points_y + + return cls(b_segs[0].ebsdMap, points_x, points_y) + + @property + def points(self): + return self.points_x.union(self.points_y) + + def _image(self, points): + image = np.zeros(self.ebsd_map.shape, dtype=bool) + image[tuple(zip(*points))[::-1]] = True + return image + + @property + def image_x(self): + return self._image(self.points_x) + + @property + def image_y(self): + return self._image(self.points_y) + + @property + def image(self): + return self._image(self.points) + + @property + def lines(self): + _, _, lines = self.boundary_points_to_lines( + boundary_points_x=self.points_x, + boundary_points_y=self.points_y + ) + return lines + + @staticmethod + def boundary_points_to_lines(*, boundary_points_x=None, + boundary_points_y=None): + boundary_data = {} + if boundary_points_x is not None: + boundary_data['x'] = boundary_points_x + if boundary_points_y is not None: + boundary_data['y'] = boundary_points_y + if not boundary_data: + raise ValueError("No boundaries provided.") + + deltas = { + 'x': (0.5, -0.5, 0.5, 0.5), + 'y': (-0.5, 0.5, 0.5, 0.5) + } + all_lines = [] + for mode, points in boundary_data.items(): + lines = [] + for i, j in points: + lines.append(( + (i + deltas[mode][0], j + deltas[mode][1]), + (i + deltas[mode][2], j + deltas[mode][3]) + )) + all_lines.append(lines) + + if len(all_lines) == 2: + all_lines.append(all_lines[0] + all_lines[1]) + return tuple(all_lines) + else: + return all_lines[0] class BoundarySegment(object): @@ -1635,12 +1644,12 @@ def __init__(self, ebsdMap, grain1, grain2): # list of boundary points (x, y) for horizontal (X) and # vertical (Y) boundaries - self.boundaryPointsX = [] - self.boundaryPointsY = [] + self.boundary_points_x = [] + self.boundary_points_y = [] # Boolean value for each point above, True if boundary point is # in grain1 and False if in grain2 - self.boundaryPointOwnersX = [] - self.boundaryPointOwnersY = [] + self.boundary_point_owners_x = [] + self.boundary_point_owners_y = [] def __eq__(self, right): if type(self) is not type(right): @@ -1652,114 +1661,83 @@ def __eq__(self, right): self.grain2 is right.grain1)) def __len__(self): - return len(self.boundaryPointsX) + len(self.boundaryPointsY) + return len(self.boundary_points_x) + len(self.boundary_points_y) - def addBoundaryPoint(self, point, kind, ownerGrain): + def addBoundaryPoint(self, point, kind, owner_grain): if kind == 0: - self.boundaryPointsX.append(point) - self.boundaryPointOwnersX.append(ownerGrain is self.grain1) + self.boundary_points_x.append(point) + self.boundary_point_owners_x.append(owner_grain is self.grain1) elif kind == 1: - self.boundaryPointsY.append(point) - self.boundaryPointOwnersY.append(ownerGrain is self.grain1) + self.boundary_points_y.append(point) + self.boundary_point_owners_y.append(owner_grain is self.grain1) else: raise ValueError("Boundary point kind is 0 for x and 1 for y") - def boundaryPointPairs(self, kind): + def boundary_point_pairs(self, kind): """Return pairs of points either side of the boundary. The first point is always in grain1 """ if kind == 0: - boundaryPoints = self.boundaryPointsX - boundaryPointOwners = self.boundaryPointOwnersX + boundary_points = self.boundary_points_x + boundary_point_owners = self.boundary_point_owners_x delta = (1, 0) else: - boundaryPoints = self.boundaryPointsY - boundaryPointOwners = self.boundaryPointOwnersY + boundary_points = self.boundary_points_y + boundary_point_owners = self.boundary_point_owners_y delta = (0, 1) - boundaryPointPairs = [] - for point, owner in zip(boundaryPoints, boundaryPointOwners): - otherPoint = (point[0] + delta[0], point[1] + delta[1]) + boundary_point_pairs = [] + for point, owner in zip(boundary_points, boundary_point_owners): + other_point = (point[0] + delta[0], point[1] + delta[1]) if owner: - boundaryPointPairs.append((point, otherPoint)) + boundary_point_pairs.append((point, other_point)) else: - boundaryPointPairs.append((otherPoint, point)) + boundary_point_pairs.append((other_point, point)) - return boundaryPointPairs + return boundary_point_pairs @property - def boundaryPointPairsX(self): + def boundary_point_pairs_x(self): """Return pairs of points either side of the boundary. The first point is always in grain1 """ - return self.boundaryPointPairs(0) + return self.boundary_point_pairs(0) @property - def boundaryPointPairsY(self): + def boundary_point_pairs_y(self): """Return pairs of points either side of the boundary. The first point is always in grain1 """ - return self.boundaryPointPairs(1) + return self.boundary_point_pairs(1) @property - def boundaryLines(self): + def boundary_lines(self): """Return line points along this boundary segment""" - _, _, lines = self.boundary_points_to_lines( - boundary_points_x=self.boundaryPointsX, - boundary_points_y=self.boundaryPointsY + _, _, lines = BoundarySet.boundary_points_to_lines( + boundary_points_x=self.boundary_points_x, + boundary_points_y=self.boundary_points_y ) return lines def misorientation(self): - misOri, minSymm = self.grain1.refOri.misOri( - self.grain2.refOri, self.ebsdMap.crystalSym, returnQuat=2 + mis_ori, minSymm = self.grain1.ref_ori.mis_ori( + self.grain2.ref_ori, self.ebsdMap.crystal_sym, return_quat=2 ) - misOri = 2 * np.arccos(misOri) - misOriAxis = self.grain1.refOri.misOriAxis(minSymm) + mis_ori = 2 * np.arccos(mis_ori) + mis_ori_axis = self.grain1.ref_ori.mis_ori_axis(minSymm) # should this be a unit vector already? - misOriAxis /= np.sqrt(np.dot(misOriAxis, misOriAxis)) + mis_ori_axis /= np.sqrt(np.dot(mis_ori_axis, mis_ori_axis)) - return misOri, misOriAxis + return mis_ori, mis_ori_axis # compVector = np.array([1., 1., 1.]) # deviation = np.arccos( - # np.dot(misOriAxis, np.array([1., 1., 1.])) / - # (np.sqrt(np.dot(misOriAxis, misOriAxis) * np.dot(compVector, + # np.dot(mis_ori_axis, np.array([1., 1., 1.])) / + # (np.sqrt(np.dot(mis_ori_axis, mis_ori_axis) * np.dot(compVector, # compVector)))) # print(deviation * 180 / np.pi) - @staticmethod - def boundary_points_to_lines(*, boundary_points_x=None, - boundary_points_y=None): - boundary_data = {} - if boundary_points_x is not None: - boundary_data['x'] = boundary_points_x - if boundary_points_y is not None: - boundary_data['y'] = boundary_points_y - if not boundary_data: - raise ValueError("No boundaries provided.") - - deltas = { - 'x': (0.5, -0.5, 0.5, 0.5), - 'y': (-0.5, 0.5, 0.5, 0.5) - } - all_lines = [] - for mode, points in boundary_data.items(): - lines = [] - for i, j in points: - lines.append(( - (i + deltas[mode][0], j + deltas[mode][1]), - (i + deltas[mode][2], j + deltas[mode][3]) - )) - all_lines.append(lines) - - if len(all_lines) == 2: - all_lines.append(all_lines[0] + all_lines[1]) - return tuple(all_lines) - else: - return all_lines[0] - class Linker(object): """Class for linking multiple EBSD maps of the same region for analysis of deformation. @@ -1789,20 +1767,20 @@ def __init__(self, ebsd_maps): self.plots = None def set_origin(self, **kwargs): - """Interacive tool to set origin of each EBSD map. + """Interactive tool to set origin of each EBSD map. Parameters ---------- kwargs - Keyword arguments passed to :func:`defdap.ebsd.Map.plotDefault` + Keyword arguments passed to :func:`defdap.ebsd.Map.plot_default` """ self.plots = [] for ebsd_map in self.ebsd_maps: - plot = ebsd_map.plotDefault(makeInteractive=True, **kwargs) - plot.addEventHandler('button_press_event', self.click_set_origin) - plot.addPoints([ebsd_map.origin[0]], [ebsd_map.origin[1]], - c='w', s=60, marker='x') + plot = ebsd_map.plot_default(make_interactive=True, **kwargs) + plot.add_event_handler('button_press_event', self.click_set_origin) + plot.add_points([ebsd_map.origin[0]], [ebsd_map.origin[1]], + c='w', s=60, marker='x') self.plots.append(plot) def click_set_origin(self, event, plot): @@ -1821,8 +1799,8 @@ def click_set_origin(self, event, plot): return origin = (int(event.xdata), int(event.ydata)) - plot.callingMap.origin = origin - plot.addPoints([origin[0]], [origin[1]], updateLayer=0) + plot.calling_map.origin = origin + plot.add_points([origin[0]], [origin[1]], update_layer=0) print(f"Origin set to ({origin[0]}, {origin[1]})") def start_linking(self): @@ -1831,11 +1809,11 @@ def start_linking(self): """ self.plots = [] for ebsd_map in self.ebsd_maps: - plot = ebsd_map.locateGrainID(clickEvent=self.click_grain_guess) + plot = ebsd_map.locate_grain(click_event=self.click_grain_guess) # Add make link button to axes - plot.addButton('Make link', self.make_link, - color='0.85', hovercolor='0.95') + plot.add_button('Make link', self.make_link, + color='0.85', hovercolor='0.95') self.plots.append(plot) @@ -1860,7 +1838,7 @@ def click_grain_guess(self, event, plot): # clicked on 'master' map so highlight and guess grain on others # set current grain in 'master' ebsd map - self.ebsd_maps[0].clickGrainID(event, plot, False) + self.ebsd_maps[0].click_grain_id(event, plot, False) # guess at grain in other maps for ebsd_map, plot in zip(self.ebsd_maps[1:], self.plots[1:]): @@ -1870,21 +1848,23 @@ def click_grain_guess(self, event, plot): y0m = curr_ebsd_map.origin[1] x0 = ebsd_map.origin[0] y0 = ebsd_map.origin[1] - scaling = curr_ebsd_map.stepSize / ebsd_map.stepSize + scaling = curr_ebsd_map.step_size / ebsd_map.step_size x = int((event.xdata - x0m) * scaling + x0) y = int((event.ydata - y0m) * scaling + y0) - ebsd_map.currGrainId = int(ebsd_map.grains[y, x]) - 1 - print(ebsd_map.currGrainId) + grain_id = int(ebsd_map.data.grains[y, x]) - 1 + grain = self[grain_id] + ebsd_map.sel_grain = grain + print(grain_id) # update the grain highlights layer in the plot - plot.addGrainHighlights([ebsd_map.currGrainId], - alpha=ebsd_map.highlightAlpha) + plot.add_grain_highlights([grain_id], + alpha=ebsd_map.highlight_alpha) else: # clicked on other map so correct guessed selected grain - curr_ebsd_map.clickGrainID(event, plot, False) + curr_ebsd_map.click_grain_id(event, plot, False) def make_link(self, event, plot): """Make a link between the EBSD maps after clicking. @@ -1894,10 +1874,10 @@ def make_link(self, event, plot): curr_link = [] for i, ebsd_map in enumerate(self.ebsd_maps): - if ebsd_map.currGrainId is not None: - curr_link.append(ebsd_map.currGrainId) + if ebsd_map.sel_grain is not None: + curr_link.append(ebsd_map.sel_grain.grain_id) else: - raise Exception(f"No grain setected in map {i + 1}.") + raise Exception(f"No grain selected in map {i + 1}.") curr_link = tuple(curr_link) if curr_link not in self.links: @@ -1919,8 +1899,8 @@ def set_ref_ori_from_master(self): """ for i, ebsd_map in enumerate(self.ebsd_maps[1:], start=1): for link in self.links: - ebsd_map.grainList[link[i]].refOri = copy.deepcopy( - self.ebsd_maps[0].grainList[link[0]].refOri + ebsd_map[link[i]].ref_ori = copy.deepcopy( + self.ebsd_maps[0][link[0]].ref_ori ) def update_misori(self, calc_axis=False): @@ -1932,6 +1912,6 @@ def update_misori(self, calc_axis=False): Calculate the misorientation axis if True. """ - for i, ebsdMap in enumerate(self.ebsd_maps[1:], start=1): + for i, ebsd_map in enumerate(self.ebsd_maps[1:], start=1): for link in self.links: - ebsdMap.grainList[link[i]].buildMisOriList(calcAxis=calc_axis) + ebsd_map[link[i]].build_mis_ori_list(calc_axis=calc_axis) diff --git a/defdap/experiment.py b/defdap/experiment.py new file mode 100644 index 0000000..5642aa0 --- /dev/null +++ b/defdap/experiment.py @@ -0,0 +1,353 @@ +# Copyright 2025 Mechanics of Microstructures Group +# at The University of Manchester +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import numpy as np +from skimage import transform as tf +from skimage import morphology as mph + + +class Experiment(object): + def __init__(self): + self.frame_relations = {} + self.increments = [] + + def __getitem__(self, key): + return self.increments[key] + + def add_increment(self, **kwargs): + inc = Increment(self, **kwargs) + self.increments.append(inc) + return inc + + def iter_over_maps(self, map_name): + for i, inc in enumerate(self.increments): + map_obj = inc.maps.get(map_name) + if map_obj is None: + continue + yield i, map_obj + + def link_frames(self, frame_1, frame_2, transform_props): + self.frame_relations[(frame_1, frame_2)] = transform_props + + def get_frame_transform(self, frame_1, frame_2): + transform_lookup = { + 'piecewise_affine': tf.PiecewiseAffineTransform, + 'projective': tf.ProjectiveTransform, + 'polynomial': tf.PolynomialTransform, + 'affine': tf.AffineTransform, + } + + forward = (frame_1, frame_2) in self.frame_relations + reverse = (frame_2, frame_1) in self.frame_relations + if forward and reverse: + raise ValueError('Why are frame relations in both senses stored?') + if not (forward or reverse): + raise ValueError('Frames are not linked.') + + frames = (frame_1, frame_2) if forward else (frame_2, frame_1) + transform_props = self.frame_relations[frames] + calc_inverse = transform_props['type'] == 'polynomial' + transform = transform_lookup[transform_props['type']]() + + if reverse and calc_inverse: + frames = frames[::-1] + + transform.estimate( + np.array(frames[0].homog_points), + np.array(frames[1].homog_points), + **{k: v for k, v in transform_props.items() if k != 'type'} + ) + + if reverse and not calc_inverse: + transform = transform.inverse + + return transform + + def warp_image(self, map_data, frame_1, frame_2, crop=True, **kwargs): + """Warps a map to the DIC frame. + + Parameters + ---------- + map_data : numpy.ndarray + Data to warp. + crop : bool, optional + Crop to size of DIC map if true. + kwargs + All other arguments passed to :func:`skimage.transform.warp`. + + Returns + ---------- + numpy.ndarray + Map (i.e. EBSD map data) warped to the DIC frame. + + """ + transform = self.get_frame_transform(frame_2, frame_1) + + if not crop and isinstance(transform, tf.AffineTransform): + # copy transform and change translation to give an extra + # 5% border to show the entire image after rotation/shearing + input_shape = np.array(map_data.shape) + transform = tf.AffineTransform(matrix=np.copy(transform.params)) + transform.params[0:2, 2] = -0.05 * input_shape + output_shape = input_shape * 1.4 / transform.scale + kwargs['output_shape'] = output_shape.astype(int) + + return tf.warp(map_data, transform, **kwargs) + + def warp_lines(self, lines, frame_1, frame_2): + """Warp a set of lines to the DIC reference frame. + + Parameters + ---------- + lines : list of tuples + Lines to warp. Each line is represented as a tuple of start + and end coordinates (x, y). + + Returns + ------- + list of tuples + List of warped lines with same representation as input. + + """ + # Transform + transform = self.get_frame_transform(frame_1, frame_2) + lines = transform(np.array(lines).reshape(-1, 2)).reshape(-1, 2, 2) + # Round to nearest + lines = np.round(lines - 0.5) + 0.5 + lines = [(tuple(line[0]), tuple(line[1])) for line in lines] + return lines + + def warp_points(self, points_img, frame_1, frame_2, **kwargs): + input_shape = np.array(points_img.shape) + points_img = self.warp_image(points_img, frame_1, frame_2, crop=False, + **kwargs) + + points_img = mph.skeletonize(points_img > 0.1) + mph.remove_small_objects(points_img, min_size=10, connectivity=2, + out=points_img) + + # remove 5% border if required + transform = self.get_frame_transform(frame_2, frame_1) + if isinstance(transform, tf.AffineTransform): + # the crop is defined in EBSD coords so need to transform it + crop = np.matmul( + np.linalg.inv(transform.params[0:2, 0:2]), + transform.params[0:2, 2] + 0.05*input_shape + ) + crop = crop.round().astype(int) + points_img = points_img[crop[1]:crop[1] + kwargs['output_shape'][0], + crop[0]:crop[0] + kwargs['output_shape'][1]] + + return zip(*points_img.transpose().nonzero()) + + +class Increment(object): + # def __init__(self, experiment, **kwargs): + def __init__(self, experiment, **kwargs): + + self.maps = {} + # ex: (name, map, frame) + # default behaviour for no frame, different frame for + # each EBSD map, initial increment frame for DIC maps + + self.experiment = experiment + self.metadata = kwargs + + def add_map(self, name, map_obj): + self.maps[name] = map_obj + + +class Frame(object): + def __init__(self): + # self.maps = [] + self.homog_points = [] + + def set_homog_points(self, points): + """ + + Parameters + ---------- + points : numpy.ndarray, optional + Array of (x,y) homologous points to set explicitly. + """ + self.homog_points = points + + def set_homog_point(self, map_obj, map_name=None, **kwargs): + """ + Interactive tool to set homologous points. Right-click on a point + then click 'save point' to append to the homologous points list. + + Parameters + ---------- + map_name : str, optional + Map data to plot for selecting points. + points : numpy.ndarray, optional + Array of (x,y) homologous points to set explicitly. + kwargs : dict, optional + Keyword arguments passed to :func:`defdap.base.Map.plotHomog` + + """ + if map_name is None: + map_name = map_obj.homog_map_name + + binning = map_obj.data.get_metadata(map_name, 'binning', 1) + plot = map_obj.plot_map(map_name, make_interactive=True, **kwargs) + + # Plot stored homog points if there are any + if len(self.homog_points) > 0: + homog_points = np.array(self.homog_points) * binning + plot.add_points(homog_points[:, 0], homog_points[:, 1], c='y', s=60) + else: + # add empty points layer to update later + plot.add_points([None], [None], c='y', s=60) + + # add empty points layer for current selected point + plot.add_points([None], [None], c='w', s=60, marker='x') + + plot.add_event_handler('button_press_event', self.homog_click) + plot.add_event_handler('key_press_event', self.homog_key) + plot.add_button("Save point", + lambda e, p: self.homog_click_save(e, p, binning), + color="0.85", hovercolor="blue") + + return plot + + @staticmethod + def homog_click(event, plot): + """Event handler for capturing position when clicking on a map. + + Parameters + ---------- + event : + Click event. + plot : defdap.plotting.MapPlot + Plot to monitor. + + """ + # check if click was on the map + if event.inaxes is not plot.ax: + return + + # right mouse click or shift + left mouse click + # shift click doesn't work in osx backend + if event.button == 3 or (event.button == 1 and event.key == 'shift'): + plot.add_points([int(event.xdata)], [int(event.ydata)], update_layer=1) + + @staticmethod + def homog_key(event, plot): + """Event handler for moving position using keyboard after clicking on + a map. + + Parameters + ---------- + event : + Keypress event. + plot : defdap.plotting.MapPlot + Plot to monitor. + + """ + arrow_keys = ['left', 'right', 'up', 'down'] + keys = event.key.split('+') + key = keys[-1] + if key not in arrow_keys: + return + + # get the selected point + sel_point = plot.img_layers[plot.points_layer_ids[1]].get_offsets()[0] + if sel_point[0] is None or sel_point[1] is None: + return + + move = 10 if len(keys) == 2 and keys[0] == 'shift' else 1 + if key == arrow_keys[0]: + sel_point[0] -= move + elif key == arrow_keys[1]: + sel_point[0] += move + elif key == arrow_keys[2]: + sel_point[1] -= move + elif key == arrow_keys[3]: + sel_point[1] += move + + plot.add_points([sel_point[0]], [sel_point[1]], update_layer=1) + + def homog_click_save(self, event, plot, binning): + """Append the selected point on the map to homogPoints. + + Parameters + ---------- + event : + Button click event. + plot : defdap.plotting.MapPlot + Plot to monitor. + binning : int, optional + Binning applied to image, if applicable. + + """ + # get the selected point + sel_point = plot.img_layers[plot.points_layer_ids[1]].get_offsets()[0] + if any(np.isnan(sel_point)) or sel_point[0] is None or sel_point[1] is None: + return + + # remove selected point from plot + plot.add_points([None], [None], update_layer=1) + + # then scale and add to homog points list + sel_point = tuple((sel_point / binning).round().astype(int).tolist()) + self.homog_points.append(sel_point) + + # update the plotted homog points + homog_points = np.array(self.homog_points) * binning + plot.add_points(homog_points[:, 0], homog_points[:, 1], update_layer=0) + + def update_homog_points(self, homog_idx, new_point=None, delta=None): + """ + Update a homog point by either over writing it with a new point or + incrementing the current values. + + Parameters + ---------- + homog_idx : int + ID (place in list) of point to update or -1 for all. + new_point : tuple, optional + (x, y) coordinates of new point. + delta : tuple, optional + Increments to current point (dx, dy). + + """ + if type(homog_idx) is not int: + raise Exception("homog_idx must be an integer.") + if homog_idx >= len(self.homog_points): + raise Exception("homog_idx is out of range.") + + # Update all points + if homog_idx < 0: + for i in range(len(self.homog_points)): + self.update_homog_points(homog_idx=i, delta=delta) + return + + # Update a single point + # overwrite point + if new_point is not None: + if type(new_point) is not tuple and len(new_point) != 2: + raise Exception("newPoint must be a 2 component tuple") + # increment current point + elif delta is not None: + if type(delta) is not tuple and len(delta) != 2: + raise Exception("delta must be a 2 component tuple") + new_point = list(self.homog_points[homog_idx]) + new_point[0] += delta[0] + new_point[1] += delta[1] + new_point = tuple(new_point) + + self.homog_points[homog_idx] = new_point diff --git a/defdap/file_readers.py b/defdap/file_readers.py index 4cc2315..123fd9b 100644 --- a/defdap/file_readers.py +++ b/defdap/file_readers.py @@ -1,4 +1,4 @@ -# Copyright 2021 Mechanics of Microstructures Group +# Copyright 2025 Mechanics of Microstructures Group # at The University of Manchester # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -14,7 +14,9 @@ # limitations under the License. import numpy as np +from numpy.lib.recfunctions import structured_to_unstructured import pandas as pd +from abc import ABC, abstractmethod import pathlib import re @@ -22,141 +24,148 @@ from defdap.crystal import Phase from defdap.quat import Quat +from defdap.utils import Datastore -class EBSDDataLoader(object): +class EBSDDataLoader(ABC): """Class containing methods for loading and checking EBSD data """ def __init__(self) -> None: - self.loadedMetadata = { - 'xDim': 0, - 'yDim': 0, - 'stepSize': 0., - 'acquisitionRotation': Quat(1.0, 0.0, 0.0, 0.0), - 'phases': [] + # required metadata + self.loaded_metadata = { + 'shape': (0, 0), + 'step_size': 0., + 'acquisition_rotation': Quat(1.0, 0.0, 0.0, 0.0), + 'phases': [], + 'edx': {'Count': 0}, } - self.loadedData = { - 'phase': None, - 'eulerAngle': None, - 'bandContrast': None - } - self.dataFormat = None + # required data + self.loaded_data = Datastore() + self.loaded_data.add( + 'phase', None, unit='', type='map', order=0, + comment='1-based, 0 is non-indexed points', + plot_params={ + 'vmin': 0, + } + ) + self.loaded_data.add( + 'euler_angle', None, unit='rad', type='map', order=1, + default_component='all_euler' + ) + self.data_format = None @staticmethod - def getLoader(dataType: str) -> 'Type[EBSDDataLoader]': - if dataType is None: - dataType = "OxfordBinary" - - if dataType == "OxfordBinary": - return OxfordBinaryLoader() - elif dataType == "OxfordText": - return OxfordTextLoader() - elif dataType == "PythonDict": - return PythonDictLoader() - else: - raise ValueError(f"No loader for EBSD data of type {dataType}.") + def get_loader(data_type: str, file_name: pathlib.Path) -> 'Type[EBSDDataLoader]': + if data_type is None: + data_type = { + '.crc': 'oxfordbinary', + '.cpr': 'oxfordbinary', + '.ctf': 'oxfordtext', + '.ang': 'edaxang', + }.get(file_name.suffix, 'oxfordbinary') + + data_type = data_type.lower() + try: + loader = { + 'oxfordbinary': OxfordBinaryLoader, + 'oxfordtext': OxfordTextLoader, + 'edaxang': EdaxAngLoader, + 'pythondict': PythonDictLoader, + }[data_type] + except KeyError: + raise ValueError(f"No loader for EBSD data of type {data_type}.") + return loader() - def checkMetadata(self) -> None: + def check_metadata(self) -> None: """ Checks that the number of phases from metadata matches the amount of phases loaded. """ - for phase in self.loadedMetadata['phases']: + for phase in self.loaded_metadata['phases']: assert type(phase) is Phase - def checkData(self) -> None: - mapShape = (self.loadedMetadata['yDim'], self.loadedMetadata['xDim']) + def check_data(self) -> None: + shape = self.loaded_metadata['shape'] + + assert self.loaded_data.phase.shape == shape + assert self.loaded_data.euler_angle.shape == (3,) + shape + # assert self.loaded_data['bandContrast'].shape == mapShape - assert self.loadedData['phase'].shape == mapShape - assert self.loadedData['eulerAngle'].shape == (3,) + mapShape - assert self.loadedData['bandContrast'].shape == mapShape + @abstractmethod + def load(self, file_name: pathlib.Path) -> None: + pass class OxfordTextLoader(EBSDDataLoader): - def load( - self, - fileName: str, - fileDir: str = "" - ) -> None: + def load(self, file_name: pathlib.Path) -> None: """ Read an Oxford Instruments .ctf file, which is a HKL single orientation file. Parameters ---------- - fileName - File name. - fileDir - Path to file. - - Returns - ------- - dict, dict - EBSD metadata and EBSD data. + file_name + Path to file """ # open data file and read in metadata - fileName = "{}.ctf".format(fileName) - filePath = pathlib.Path(fileDir) / pathlib.Path(fileName) - if not filePath.is_file(): - raise FileNotFoundError("Cannot open file {}".format(filePath)) - - def parsePhase() -> Phase: - lineSplit = line.split('\t') - dims = lineSplit[0].split(';') + if not file_name.is_file(): + raise FileNotFoundError(f"Cannot open file {file_name}") + + def parse_phase() -> Phase: + line_split = line.split('\t') + dims = line_split[0].split(';') dims = tuple(round(float(s), 3) for s in dims) - angles = lineSplit[1].split(';') + angles = line_split[1].split(';') angles = tuple(round(float(s), 3) * np.pi / 180 for s in angles) - latticeParams = dims + angles + lattice_params = dims + angles phase = Phase( - lineSplit[2], - int(lineSplit[3]), - int(lineSplit[4]), - latticeParams + line_split[2], + int(line_split[3]), + int(line_split[4]), + lattice_params ) return phase # default values for acquisition rotation in case missing in in file - acqEulers = [0., 0., 0.] - with open(str(filePath), 'r') as ctfFile: - for i, line in enumerate(ctfFile): + acq_eulers = [0., 0., 0.] + with open(str(file_name), 'r') as ctf_file: + for i, line in enumerate(ctf_file): if 'XCells' in line: - xDim = int(line.split()[-1]) - self.loadedMetadata['xDim'] = xDim + x_dim = int(line.split()[-1]) elif 'YCells' in line: - yDim = int(line.split()[-1]) - self.loadedMetadata['yDim'] = yDim + y_dim = int(line.split()[-1]) elif 'XStep' in line: - self.loadedMetadata['stepSize'] = float(line.split()[-1]) + self.loaded_metadata['step_size'] = float(line.split()[-1]) elif 'AcqE1' in line: - acqEulers[0] = float(line.split()[-1]) + acq_eulers[0] = float(line.split()[-1]) elif 'AcqE2' in line: - acqEulers[1] = float(line.split()[-1]) + acq_eulers[1] = float(line.split()[-1]) elif 'AcqE3' in line: - acqEulers[2] = float(line.split()[-1]) + acq_eulers[2] = float(line.split()[-1]) elif 'Phases' in line: - numPhases = int(line.split()[-1]) - for j in range(numPhases): - line = next(ctfFile) - self.loadedMetadata['phases'].append(parsePhase()) + num_phases = int(line.split()[-1]) + self.loaded_data['phase', 'plot_params']['vmax'] = num_phases + for j in range(num_phases): + line = next(ctf_file) + self.loaded_metadata['phases'].append(parse_phase()) # phases are last in the header, so read the column # headings then break out the loop - headerText = next(ctfFile) - numHeaderLines = i + j + 3 + header_text = next(ctf_file) + num_header_lines = i + j + 3 break - self.loadedMetadata['acquisitionRotation'] = Quat.fromEulerAngles( - *(np.array(acqEulers) * np.pi / 180) + shape = (y_dim, x_dim) + self.loaded_metadata['shape'] = shape + self.loaded_metadata['acquisition_rotation'] = Quat.from_euler_angles( + *(np.array(acq_eulers) * np.pi / 180) ) - # TODO: Load EDX data from .ctf file, if it's accesible - self.loadedMetadata['EDX Windows'] = {'Count': int(0)} - - self.checkMetadata() + self.check_metadata() # Construct data format from table header - fieldLookup = { + field_lookup = { 'Phase': ('phase', 'uint8'), 'X': ('x', 'float32'), 'Y': ('y', 'float32'), @@ -170,165 +179,308 @@ def parsePhase() -> Phase: 'BS': ('BS', 'uint8'), # Band Slope } - keepColNames = ('phase', 'ph1', 'phi', 'ph2', 'BC', 'BS', 'MAD') - dataFormat = [] - loadCols = [] + keep_col_names = ('phase', 'ph1', 'phi', 'ph2', 'BC', 'BS', 'MAD') + data_format = [] + load_cols = [] try: - for i, colTitle in enumerate(headerText.split()): - if fieldLookup[colTitle][0] in keepColNames: - dataFormat.append(fieldLookup[colTitle]) - loadCols.append(i) + for i, col_title in enumerate(header_text.split()): + if field_lookup[col_title][0] in keep_col_names: + data_format.append(field_lookup[col_title]) + load_cols.append(i) except KeyError: raise TypeError("Unknown data in EBSD file.") - self.dataFormat = np.dtype(dataFormat) + self.data_format = np.dtype(data_format) # now read the data from file - binData = np.loadtxt( - str(filePath), self.dataFormat, usecols=loadCols, - skiprows=numHeaderLines + data = np.loadtxt( + str(file_name), dtype=self.data_format, usecols=load_cols, + skiprows=num_header_lines ) - self.loadedData['bandContrast'] = np.reshape( - binData['BC'], (yDim, xDim) + self.loaded_data.add( + 'band_contrast', data['BC'].reshape(shape), + unit='', type='map', order=0, + plot_params={ + 'plot_colour_bar': True, + 'cmap': 'gray', + 'clabel': 'Band contrast', + } + + ) + self.loaded_data.add( + 'band_slope', data['BS'].reshape(shape), + unit='', type='map', order=0, + plot_params={ + 'plot_colour_bar': True, + 'cmap': 'gray', + 'clabel': 'Band slope', + } ) - self.loadedData['bandSlope'] = np.reshape( - binData['BS'], (yDim, xDim) + self.loaded_data.add( + 'mean_angular_deviation', data['MAD'].reshape(shape), + unit='', type='map', order=0, + plot_params={ + 'plot_colour_bar': True, + 'clabel': 'Mean angular deviation', + } + ) + self.loaded_data.phase = data['phase'].reshape(shape) + + euler_angle = structured_to_unstructured( + data[['ph1', 'phi', 'ph2']].reshape(shape)).transpose((2, 0, 1)) + euler_angle *= np.pi / 180 + self.loaded_data.euler_angle = euler_angle + + self.check_data() + + +class EdaxAngLoader(EBSDDataLoader): + def load(self, file_name: pathlib.Path) -> None: + """ Read an EDAX .ang file. + + Parameters + ---------- + file_name + Path to file + + """ + # open data file and read in metadata + if not file_name.is_file(): + raise FileNotFoundError(f"Cannot open file {file_name}") + + i_phase = 1 + # parse header lines (starting with #) + with open(str(file_name), 'r') as ang_file: + while True: + line = ang_file.readline() + + if not line.startswith('#'): + # end of header + break + # remove # + line = line[1:].strip() + + if line.startswith('Phase'): + if int(line.split()[1]) != i_phase: + raise ValueError('Phases not sequential in file?') + + phase_lines = read_until_string( + ang_file, '#', exact=True, + line_process=lambda l: l[1:].strip() + ) + self.loaded_metadata['phases'].append( + EdaxAngLoader.parse_phase(phase_lines) + ) + i_phase += 1 + + elif line.startswith('GRID'): + if line.split()[-1] != 'SqrGrid': + raise ValueError('Only square grids supported') + elif line.startswith('XSTEP'): + self.loaded_metadata['step_size'] = float(line.split()[-1]) + elif line.startswith('NCOLS_ODD'): + xdim = int(line.split()[-1]) + elif line.startswith('NROWS'): + ydim = int(line.split()[-1]) + + shape = (ydim, xdim) + self.loaded_metadata['shape'] = shape + + self.check_metadata() + + # Construct fixed data format + self.data_format = np.dtype([ + ('ph1', 'float32'), + ('phi', 'float32'), + ('ph2', 'float32'), + # ('x', 'float32'), + # ('y', 'float32'), + ('IQ', 'float32'), + ('CI', 'float32'), + ('phase', 'uint8'), + # ('SE_signal', 'float32'), + ('FF', 'float32'), + ]) + load_cols = (0, 1, 2, 5, 6, 7, 8, 9) + + # now read the data from file + data = np.loadtxt( + str(file_name), dtype=self.data_format, comments='#', + usecols=load_cols ) - self.loadedData['meanAngularDeviation'] = np.reshape( - binData['MAD'], (yDim, xDim) + + self.loaded_data.add( + 'image_quality', data['IQ'].reshape(shape), + unit='', type='map', order=0, + plot_params={ + 'plot_colour_bar': True, + 'clabel': 'Image quality', + } ) - self.loadedData['phase'] = np.reshape( - binData['phase'], (yDim, xDim) + self.loaded_data.add( + 'confidence_index', data['CI'].reshape(shape), + unit='', type='map', order=0, + plot_params={ + 'plot_colour_bar': True, + 'clabel': 'Confidence index', + } ) - eulerAngles = np.reshape( - binData[['ph1', 'phi', 'ph2']], (yDim, xDim) + self.loaded_data.add( + 'fit_factor', data['FF'].reshape(shape), + unit='', type='map', order=0, + plot_params={ + 'plot_colour_bar': True, + 'clabel': 'Fit factor', + } ) - # flatten the structures so that the Euler angles are stored - # into a normal array - eulerAngles = np.array(eulerAngles.tolist()).transpose((2, 0, 1)) - self.loadedData['eulerAngle'] = eulerAngles * np.pi / 180. + self.loaded_data.phase = data['phase'].reshape(shape) + 1 + self.loaded_data['phase', 'plot_params']['vmax'] = len(self.loaded_metadata['phases']) + + # flatten the structured dtype + euler_angle = structured_to_unstructured( + data[['ph1', 'phi', 'ph2']].reshape(shape)).transpose((2, 0, 1)) + euler_angle[0] -= np.pi / 2 + euler_angle[0, euler_angle[0] < 0.] += 2 * np.pi + self.loaded_data.euler_angle = euler_angle - self.checkData() + self.check_data() + + @staticmethod + def parse_phase(lines) -> Phase: + for line in lines: + line = line.split() + + if line[0] == 'MaterialName': + name = line[1] + if line[0] == 'Symmetry': + point_group = line[1] + if point_group in ('43', 'm3m'): + # cubic high + laue_group = 11 + # can't determine but set to BCC for now + space_group = 229 + elif point_group == '6/mmm': + # hex high + laue_group = 9 + space_group = None + else: + raise ValueError(f'Unknown crystal symmetry {point_group}') + elif line[0] == 'LatticeConstants': + dims = line[1:4] + dims = tuple(round(float(s), 3) for s in dims) + angles = line[4:7] + angles = tuple(round(float(s), 3) * np.pi / 180 + for s in angles) + lattice_params = dims + angles + + return Phase(name, laue_group, space_group, lattice_params) class OxfordBinaryLoader(EBSDDataLoader): - def load( - self, - fileName: str, - fileDir: str = "" - ) -> None: + def load(self, file_name: pathlib.Path) -> None: """Read Oxford Instruments .cpr/.crc file pair. Parameters ---------- - fileName - File name. - fileDir - Path to file. - - Returns - ------- - dict, dict - EBSD metadata and EBSD data. + file_name + Path to file """ - self.loadOxfordCPR(fileName, fileDir=fileDir) - self.loadOxfordCRC(fileName, fileDir=fileDir) + self.load_oxford_cpr(file_name) + self.load_oxford_crc(file_name) - def loadOxfordCPR(self, fileName: str, fileDir: str = "") -> None: + def load_oxford_cpr(self, file_name: pathlib.Path) -> None: """ Read an Oxford Instruments .cpr file, which is a metadata file describing EBSD data. Parameters ---------- - fileName - File name. - fileDir - Path to file. + file_name + Path to file """ - commentChar = ';' + comment_char = ';' - fileName = "{}.cpr".format(fileName) - filePath = pathlib.Path(fileDir) / pathlib.Path(fileName) - if not filePath.is_file(): - raise FileNotFoundError("Cannot open file {}".format(filePath)) + file_name = file_name.with_suffix('.cpr') + if not file_name.is_file(): + raise FileNotFoundError("Cannot open file {}".format(file_name)) # CPR file is split into groups, load each group into a # hierarchical dict metadata = dict() - groupPat = re.compile("\[(.+)\]") + group_pat = re.compile(r"\[(.+)\]") - def parseLine(line: str, groupDict: Dict) -> None: + def parse_line(line: str, group_dict: Dict) -> None: try: key, val = line.strip().split('=') - groupDict[key] = val + group_dict[key] = val except ValueError: pass - with open(str(filePath), 'r') as cprFile: + with open(str(file_name), 'r') as cpr_file: while True: - line = cprFile.readline() + line = cpr_file.readline() if not line: # End of file break - if line.strip() == '' or line.strip()[0] == commentChar: + if line.strip() == '' or line.strip()[0] == comment_char: # Skip comment or empty line continue - groupName = groupPat.match(line.strip()).group(1) - groupDict = dict() - readUntilString(cprFile, '[', commentChar=commentChar, - lineProcess=lambda l: parseLine(l, groupDict)) - metadata[groupName] = groupDict + group_name = group_pat.match(line.strip()).group(1) + group_dict = dict() + read_until_string(cpr_file, '[', comment_char=comment_char, + line_process=lambda l: parse_line(l, group_dict)) + metadata[group_name] = group_dict # Create phase objects and move metadata to object metadata dict - self.loadedMetadata['xDim'] = int(metadata['Job']['xCells']) - self.loadedMetadata['yDim'] = int(metadata['Job']['yCells']) - self.loadedMetadata['stepSize'] = float(metadata['Job']['GridDistX']) - self.loadedMetadata['acquisitionRotation'] = Quat.fromEulerAngles( + x_dim = int(metadata['Job']['xCells']) + y_dim = int(metadata['Job']['yCells']) + self.loaded_metadata['shape'] = (y_dim, x_dim) + self.loaded_metadata['step_size'] = float(metadata['Job']['GridDistX']) + self.loaded_metadata['acquisition_rotation'] = Quat.from_euler_angles( float(metadata['Acquisition Surface']['Euler1']) * np.pi / 180., float(metadata['Acquisition Surface']['Euler2']) * np.pi / 180., float(metadata['Acquisition Surface']['Euler3']) * np.pi / 180. ) - numPhases = int(metadata['Phases']['Count']) - - for i in range(numPhases): - phaseMetadata = metadata['Phase{:}'.format(i + 1)] - self.loadedMetadata['phases'].append(Phase( - phaseMetadata['StructureName'], - int(phaseMetadata['LaueGroup']), - int(phaseMetadata['SpaceGroup']), + num_phases = int(metadata['Phases']['Count']) + + for i in range(num_phases): + phase_metadata = metadata['Phase{:}'.format(i + 1)] + self.loaded_metadata['phases'].append(Phase( + phase_metadata['StructureName'], + int(phase_metadata['LaueGroup']), + int(phase_metadata.get('SpaceGroup', 0)), ( - round(float(phaseMetadata['a']), 3), - round(float(phaseMetadata['b']), 3), - round(float(phaseMetadata['c']), 3), - round(float(phaseMetadata['alpha']), 3) * np.pi / 180, - round(float(phaseMetadata['beta']), 3) * np.pi / 180, - round(float(phaseMetadata['gamma']), 3) * np.pi / 180 + round(float(phase_metadata['a']), 3), + round(float(phase_metadata['b']), 3), + round(float(phase_metadata['c']), 3), + round(float(phase_metadata['alpha']), 3) * np.pi / 180, + round(float(phase_metadata['beta']), 3) * np.pi / 180, + round(float(phase_metadata['gamma']), 3) * np.pi / 180 ) )) - + self.loaded_data['phase', 'plot_params']['vmax'] = num_phases + # Deal with EDX data edx_fields = {} if 'EDX Windows' in metadata: - self.loadedMetadata['EDX Windows'] = metadata['EDX Windows'] - edx_fields = {} - for i in range(1, int(self.loadedMetadata['EDX Windows']['Count']) + 1): - name = self.loadedMetadata['EDX Windows'][f"Window{i}"] + self.loaded_metadata['edx'] = metadata['EDX Windows'] + count = int(self.loaded_metadata['edx']['Count']) + self.loaded_metadata['edx']['Count'] = count + for i in range(1, count + 1): + name = self.loaded_metadata['edx'][f"Window{i}"] edx_fields[100+i] = (f'EDX {name}', 'float32') - else: - self.loadedMetadata['EDX Windows'] = {'Count': int(0)} - self.checkMetadata() + self.check_metadata() # Construct binary data format from listed fields unknown_field_count = 0 - dataFormat = [('phase', 'uint8')] - fieldLookup = { + data_format = [('phase', 'uint8')] + field_lookup = { 3: ('ph1', 'float32'), 4: ('phi', 'float32'), 5: ('ph2', 'float32'), @@ -339,271 +491,446 @@ def parseLine(line: str, groupDict: Dict) -> None: 11: ('AFI', 'uint8'), # Advanced Fit index. legacy 12: ('IB6', 'float32') # ? } - fieldLookup.update(edx_fields) + field_lookup.update(edx_fields) try: for i in range(int(metadata['Fields']['Count'])): - fieldID = int(metadata['Fields']['Field{:}'.format(i + 1)]) - dataFormat.append(fieldLookup[fieldID]) + field_id = int(metadata['Fields']['Field{:}'.format(i + 1)]) + data_format.append(field_lookup[field_id]) except KeyError: - print(f'\nUnknown field in file with key {fieldID}. ' - f'Assumming float32 data.') + print(f'\nUnknown field in file with key {field_id}. ' + f'Assuming float32 data.') unknown_field_count += 1 - dataFormat.append((f'unknown_{unknown_field_count}', 'float32')) + data_format.append((f'unknown_{unknown_field_count}', 'float32')) - self.dataFormat = np.dtype(dataFormat) + self.data_format = np.dtype(data_format) - def loadOxfordCRC(self, fileName: str, fileDir: str = "") -> None: + def load_oxford_crc(self, file_name: pathlib.Path) -> None: """Read binary EBSD data from an Oxford Instruments .crc file Parameters ---------- - fileName - File name. - fileDir - Path to file. + file_name + Path to file """ - xDim = self.loadedMetadata['xDim'] - yDim = self.loadedMetadata['yDim'] + shape = self.loaded_metadata['shape'] - fileName = "{}.crc".format(fileName) - filePath = pathlib.Path(fileDir) / pathlib.Path(fileName) - if not filePath.is_file(): - raise FileNotFoundError("Cannot open file {}".format(filePath)) + file_name = file_name.with_suffix('.crc') + if not file_name.is_file(): + raise FileNotFoundError("Cannot open file {}".format(file_name)) # load binary data from file - binData = np.fromfile(str(filePath), self.dataFormat, count=-1) - - self.loadedData['bandContrast'] = np.reshape( - binData['BC'], (yDim, xDim) - ) - self.loadedData['bandSlope'] = np.reshape( - binData['BS'], (yDim, xDim) + data = np.fromfile(str(file_name), self.data_format, count=-1) + + self.loaded_data.add( + 'band_contrast', data['BC'].reshape(shape), + unit='', type='map', order=0, + plot_params={ + 'plot_colour_bar': True, + 'cmap': 'gray', + 'clabel': 'Band contrast', + } ) - self.loadedData['meanAngularDeviation'] = np.reshape( - binData['MAD'], (yDim, xDim) + self.loaded_data.add( + 'band_slope', data['BS'].reshape(shape), + unit='', type='map', order=0, + plot_params={ + 'plot_colour_bar': True, + 'cmap': 'gray', + 'clabel': 'Band slope', + } ) - self.loadedData['phase'] = np.reshape( - binData['phase'], (yDim, xDim) + self.loaded_data.add( + 'mean_angular_deviation', + data['MAD'].reshape(shape), + unit='', type='map', order=0, + plot_params={ + 'plot_colour_bar': True, + 'clabel': 'Mean angular deviation', + } ) - eulerAngles = np.reshape( - binData[['ph1', 'phi', 'ph2']], (yDim, xDim) - ) - - # Load EDX data into a dict - if int(self.loadedMetadata['EDX Windows']['Count']) > 0: - EDXFields = [key for key in binData.dtype.fields.keys() if key.startswith('EDX')] - self.loadedData['EDXDict'] = dict( - [(field[4:], np.reshape(binData[field], (yDim, xDim))) for field in EDXFields] - ) - - # flatten the structures so that the Euler angles are stored - # into a normal array - eulerAngles = np.array(eulerAngles.tolist()).transpose((2, 0, 1)) - self.loadedData['eulerAngle'] = eulerAngles + self.loaded_data.phase = data['phase'].reshape(shape) + + # flatten the structured dtype + self.loaded_data.euler_angle = structured_to_unstructured( + data[['ph1', 'phi', 'ph2']].reshape(shape)).transpose((2, 0, 1)) + + if self.loaded_metadata['edx']['Count'] > 0: + EDXFields = [key for key in data.dtype.fields.keys() if key.startswith('EDX')] + for field in EDXFields: + self.loaded_data.add( + field, + data[field].reshape(shape), + unit='counts', type='map', order=0, + plot_params={ + 'plot_colour_bar': True, + 'clabel': field + ' counts', + } + ) - self.checkData() + self.check_data() class PythonDictLoader(EBSDDataLoader): - def load(self, dataDict: Dict[str, Any]) -> None: + def load(self, data_dict: Dict[str, Any]) -> None: """Construct EBSD data from a python dictionary. Parameters ---------- - dataDict + data_dict Dictionary with keys: - 'stepSize' + 'step_size' 'phases' 'phase' - 'eulerAngle' - 'bandContrast' + 'euler_angle' + 'band_contrast' """ - self.loadedMetadata['xDim'] = dataDict['phase'].shape[1] - self.loadedMetadata['yDim'] = dataDict['phase'].shape[0] - self.loadedMetadata['stepSize'] = dataDict['stepSize'] - assert type(dataDict['phases']) is list - self.loadedMetadata['phases'] = dataDict['phases'] - self.loadedMetadata['EDX Windows'] = {'Count': int(0)} - - self.checkMetadata() - - self.loadedData['phase'] = dataDict['phase'] - self.loadedData['eulerAngle'] = dataDict['eulerAngle'] - self.loadedData['bandContrast'] = dataDict['bandContrast'] - - self.checkData() + self.loaded_metadata['shape'] = data_dict['phase'].shape + self.loaded_metadata['step_size'] = data_dict['step_size'] + assert type(data_dict['phases']) is list + self.loaded_metadata['phases'] = data_dict['phases'] + self.check_metadata() + + self.loaded_data.add( + 'band_contrast', data_dict['band_contrast'], + unit='', type='map', order=0 + ) + self.loaded_data.phase = data_dict['phase'] + self.loaded_data['phase', 'plot_params']['vmax'] = len(self.loaded_metadata['phases']) + self.loaded_data.euler_angle = data_dict['euler_angle'] + self.check_data() -class DICDataLoader(object): +class DICDataLoader(ABC): """Class containing methods for loading and checking HRDIC data """ - def __init__(self) -> None: - self.loadedMetadata = { - 'format': "", - 'version': "", - 'binning': "", - 'xDim': 0, - 'yDim': 0 - } - self.loadedData = { - 'xc': None, - 'yc': None, - 'xd': None, - 'yd': None + def __init__(self, file_type : str = '') -> None: + self.file_type = file_type + self.loaded_metadata = { + 'format': '', + 'version': '', + 'binning': '', + 'shape': (0, 0), } + # required data + self.loaded_data = Datastore() + self.loaded_data.add( + 'coordinate', None, unit='px', type='map', order=1, + default_component='magnitude', + plot_params={ + 'plot_colour_bar': True, + 'clabel': 'Coordinate', + } + ) + self.loaded_data.add( + 'displacement', None, unit='px', type='map', order=1, + default_component='magnitude', + plot_params={ + 'plot_colour_bar': True, + 'clabel': 'Displacement', + } + ) + + @staticmethod + def get_loader(data_type: str) -> 'Type[DICDataLoader]': + if data_type is None: + data_type = "Davis" + + data_type = data_type.lower().split('-') + data_subtype = '' if len(data_type) == 1 else data_type[1] + data_type = data_type[0] + try: + loader = { + 'davis': DavisLoader, + 'openpiv': OpenPivTextLoader, #Backwards compatability + 'openpivtext': OpenPivTextLoader, + 'openpivbinary': OpenPivBinaryLoader + }[data_type] + except KeyError: + raise ValueError(f"No loader for DIC data of type {data_type}.") + return loader(file_type=data_subtype) def checkMetadata(self) -> None: return - def checkData(self) -> None: + def check_data(self) -> None: """ Calculate size of map from loaded data and check it matches values from metadata. """ - coords = self.loadedData['xc'] - xdim = int( - (coords.max() - coords.min()) / min(abs(np.diff(coords))) + 1 - ) + # check binning + binning = self.loaded_metadata['binning'] + binning_x = min(abs(np.diff(self.loaded_data.coordinate[0].flat))) + binning_y = max(abs(np.diff(self.loaded_data.coordinate[1].flat))) + if not (binning_x == binning_y == binning): + raise ValueError( + f'Binning of data and header do not match `{binning_x}`, ' + f'`{binning_y}`, `{binning}`' + ) - coords = self.loadedData['yc'] - ydim = int( - (coords.max() - coords.min()) / max(abs(np.diff(coords))) + 1 - ) + # check shape + coord = self.loaded_data.coordinate + shape = (coord.max(axis=(1, 2)) - coord.min(axis=(1, 2))) / binning + 1 + shape = tuple(shape[::-1].astype(int)) + if shape != self.loaded_metadata['shape']: + raise ValueError( + f'Dimensions of data and header do not match `{shape}, ' + f'`{self.loaded_metadata["shape"]}`' + ) - assert xdim == self.loadedMetadata['xDim'], "Dimensions of data and header do not match" - assert ydim == self.loadedMetadata['yDim'], "Dimensions of data and header do not match" + @abstractmethod + def load(self, file_name: pathlib.Path) -> None: + pass - def loadDavisMetadata(self, - fileName: str, - fileDir: str = "" - ) -> Dict[str, Any]: - """ Load DaVis metadata from Davis .txt file. + +class DavisLoader(DICDataLoader): + def load(self, file_name: pathlib.Path) -> None: + """ Load from Davis .txt file. Parameters ---------- - fileName - File name. - fileDir - Path to file. - - Returns - ------- - dict - Davis metadata. + file_name + Path to file """ - filePath = pathlib.Path(fileDir) / pathlib.Path(fileName) - if not filePath.is_file(): - raise FileNotFoundError("Cannot open file {}".format(filePath)) + if not file_name.is_file(): + raise FileNotFoundError("Cannot open file {}".format(file_name)) - with open(str(filePath), 'r') as f: + with open(str(file_name), 'r') as f: header = f.readline() metadata = header.split() # Software name and version - self.loadedMetadata['format'] = metadata[0].strip('#') - self.loadedMetadata['version'] = metadata[1] + self.loaded_metadata['format'] = metadata[0].strip('#') + self.loaded_metadata['version'] = metadata[1] # Sub-window width in pixels - self.loadedMetadata['binning'] = int(metadata[3]) - # size of map along x and y (from header) - self.loadedMetadata['xDim'] = int(metadata[5]) - self.loadedMetadata['yDim'] = int(metadata[4]) + self.loaded_metadata['binning'] = int(metadata[3]) + # shape of map (from header) + self.loaded_metadata['shape'] = (int(metadata[4]), int(metadata[5])) self.checkMetadata() - return self.loadedMetadata + data = pd.read_table(str(file_name), delimiter='\t', skiprows=1, + header=None).values + data = data.reshape(self.loaded_metadata['shape'] + (-1,)) + data = data.transpose((2, 0, 1)) + + self.loaded_data.coordinate = data[:2] + self.loaded_data.displacement = data[2:] + + self.check_data() - def loadDavisData( - self, - fileName: str, - fileDir: str = "" - ) -> Dict[str, Any]: - """Load displacement data from Davis .txt file containing x and - y coordinates and x and y displacements for each coordinate. + @staticmethod + def load_davis_image_data(file_name: pathlib.Path) -> np.ndarray: + """ A .txt file from DaVis containing a 2D image Parameters ---------- - fileName - File name. - fileDir - Path to file. + file_name + Path to file Returns ------- - dict - Coordinates and displacements. + np.ndarray + Array of data. """ - filePath = pathlib.Path(fileDir) / pathlib.Path(fileName) - if not filePath.is_file(): - raise FileNotFoundError("Cannot open file {}".format(filePath)) + if not file_name.is_file(): + raise FileNotFoundError("Cannot open file {}".format(file_name)) - data = pd.read_table(str(filePath), delimiter='\t', skiprows=1, + data = pd.read_table(str(file_name), delimiter='\t', skiprows=1, header=None) - # x and y coordinates - self.loadedData['xc'] = data.values[:, 0] - self.loadedData['yc'] = data.values[:, 1] - # x and y displacement - self.loadedData['xd'] = data.values[:, 2] - self.loadedData['yd'] = data.values[:, 3] - self.checkData() + return np.array(data) - return self.loadedData - @staticmethod - def loadDavisImageData(fileName: str, fileDir: str = "") -> np.ndarray: - """ A .txt file from DaVis containing a 2D image +class OpenPivTextLoader(DICDataLoader): + def load(self, file_name: pathlib.Path) -> None: + """ Load from Open PIV .txt file. Parameters ---------- - fileName - File name. - fileDir - Path to file. + file_name + Path to file - Returns - ------- - np.ndarray - Array of data. + """ + if not file_name.is_file(): + raise FileNotFoundError(f"Cannot open file {file_name}") + + with open(str(file_name), 'r') as f: + header = f.readline()[1:].split() + data = np.loadtxt(f) + col = { + 'x': 0, + 'y': 1, + 'u': 2, + 'v': 3, + } + + # Software name and version + self.loaded_metadata['format'] = 'OpenPIV' + self.loaded_metadata['version'] = 'n/a' + + # Sub-window width in pixels + binning_x = int(np.min(np.abs(np.diff(data[:, col['x']])))) + binning_y = int(np.max(np.abs(np.diff(data[:, col['y']])))) + assert binning_x == binning_y + binning = binning_x + self.loaded_metadata['binning'] = binning + + # shape of map (from header) + shape = data[:, [col['y'], col['x']]].max(axis=0) + binning / 2 + shape = tuple((shape / binning).astype(int).tolist()) + self.loaded_metadata['shape'] = shape + + self.checkMetadata() + + # if y descending, flip + if np.all(np.diff(data[:, col['y']].reshape(shape)[:,0])) > 0: + data = data.reshape(shape + (-1,))[::-1].transpose((2, 0, 1)) + + self.loaded_data.coordinate = data[[col['x'], col['y']]] + self.loaded_data.displacement = data[[col['u'], col['v']]] + + self.check_data() + +class OpenPivBinaryLoader(DICDataLoader): + def load(self, file_name: pathlib.Path) -> None: + """ Load from Open PIV .npz file. + + Parameters + ---------- + file_name + Path to file """ - filePath = pathlib.Path(fileDir) / pathlib.Path(fileName) - if not filePath.is_file(): - raise FileNotFoundError("Cannot open file {}".format(filePath)) + if not file_name.is_file(): + raise FileNotFoundError(f"Cannot open file {file_name}") - data = pd.read_table(str(filePath), delimiter='\t', skiprows=1, - header=None) - - # x and y coordinates - loadedData = np.array(data) + data = np.load(file_name) + + # Software name and version + self.loaded_metadata['format'] = data['format'] + self.loaded_metadata['version'] = data['version'] + + # Load binning and shape + self.loaded_metadata['binning'] = data['binning'] + self.loaded_metadata['shape'] = tuple(data['shape']) + + self.checkMetadata() + + # if y descending, flip + if np.all(np.diff(data['y'][:,0])) > 0: + self.loaded_data.coordinate = np.array([data['x'][::-1], data['y'][::-1]]) + self.loaded_data.displacement = np.array([data['u'][::-1], data['v'][::-1]]) + else: + self.loaded_data.coordinate = np.array([data['x'], data['y']]) + self.loaded_data.displacement = np.array([data['u'], data['v']]) + + self.check_data() + + +class PyValeLoader(DICDataLoader): + def load(self, file_name: pathlib.Path) -> None: + """ Load from PyVale csv or binary file. + + Parameters + ---------- + file_name + Path to file + + """ + if not file_name.is_file(): + raise FileNotFoundError(f"Cannot open file {file_name}") + + int_type = 'int32' + double_type = 'double' + data_format = np.dtype([ + ('x', int_type), + ('y', int_type), + ('u', double_type), + ('v', double_type), + ('displacement_mag', double_type), + ('converged', 'uint8'), + ('cost', double_type), + ('ftol', double_type), + ('xtol', double_type), + ('num_iterations', int_type), + ]) + + if self.file_type == 'csv': + with open(str(file_name), 'r') as f: + header = f.readline()[1:].split() + data = np.loadtxt(f, delimiter=',', dtype=data_format) + elif self.file_type == 'binary': + data = np.fromfile(str(file_name), data_format, count=-1) + else: + raise ValueError(f"Unknown pyvale file type {self.file_type}") + + # Software name and version + self.loaded_metadata['format'] = 'PyVale' + self.loaded_metadata['version'] = 'n/a' + + # Sub-window width in pixels + binning_x = int(np.min(np.abs(np.diff(data['x'])))) + binning_y = int(np.max(np.abs(np.diff(data['y'])))) + assert binning_x == binning_y + binning = binning_x + self.loaded_metadata['binning'] = binning + + # shape of map (from data) + yx_array = structured_to_unstructured(data[['y', 'x']]) + yx_min = yx_array.min(axis=0) + yx_max = yx_array.max(axis=0) + shape = yx_max - yx_min + assert np.allclose(shape % binning, 0.) + shape = tuple((shape // binning + 1).tolist()) + self.loaded_metadata['shape'] = shape + + self.checkMetadata() + + index_array = (yx_array - yx_min) // binning + disp_dense = np.zeros(shape + (2,)) + disp_dense[index_array[:, 0], index_array[:, 1]] = ( + structured_to_unstructured(data[['u', 'v']])) + disp_dense = disp_dense.transpose((2, 0, 1)) + + coord_dense = np.array(np.meshgrid( + *(np.arange(mn, mx+binning, binning) + for mn, mx in zip(yx_min[::-1], yx_max[::-1])) + )) + + self.loaded_data.coordinate = coord_dense + self.loaded_data.displacement = disp_dense - return loadedData + self.check_data() -def readUntilString( +def read_until_string( file: TextIO, - termString: str, - commentChar: str = '*', - lineProcess: Optional[Callable[[str], Any]] = None + term_string: str, + comment_char: str = '*', + line_process: Optional[Callable[[str], Any]] = None, + exact: bool = False ) -> List[Any]: """Read lines in a file until a line starting with the `termString` - is encounted. The file position is returned before the line starting + is encountered. The file position is returned before the line starting with the `termString` when found. Comment and empty lines are ignored. Parameters ---------- file An open python text file object. - termString + term_string String to terminate reading. - commentChar + comment_char Character at start of a comment line to ignore. - lineProcess + line_process Function to apply to each line when loaded. + exact + A line must exactly match `termString` to stop. Returns ------- @@ -613,15 +940,17 @@ def readUntilString( """ lines = [] while True: - currPos = file.tell() # save position in file + curr_pos = file.tell() # save position in file line = file.readline() - if not line or line.strip().startswith(termString): - file.seek(currPos) # return to before prev line + if (not line + or (exact and line.strip() == term_string) + or (not exact and line.strip().startswith(term_string))): + file.seek(curr_pos) # return to before prev line break - if line.strip() == '' or line.strip()[0] == commentChar: + if line.strip() == '' or line.strip()[0] == comment_char: # Skip comment or empty line continue - if lineProcess is not None: - line = lineProcess(line) + if line_process is not None: + line = line_process(line) lines.append(line) return lines diff --git a/defdap/file_writers.py b/defdap/file_writers.py index c1a46b5..d7c85a6 100644 --- a/defdap/file_writers.py +++ b/defdap/file_writers.py @@ -1,4 +1,4 @@ -# Copyright 2021 Mechanics of Microstructures Group +# Copyright 2025 Mechanics of Microstructures Group # at The University of Manchester # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -73,9 +73,9 @@ def write(self, file_name: str, file_dir: str = "") -> None: # convert quats to Euler angles out_euler_array = np.zeros(shape + (3,)) for idx in np.ndindex(shape): - out_euler_array[idx] = self.data['quat'][idx].eulerAngles() + out_euler_array[idx] = self.data['quat'][idx].euler_angles() out_euler_array *= 180 / np.pi - acq_rot = self.metadata['acquisition_rotation'].eulerAngles() + acq_rot = self.metadata['acquisition_rotation'].euler_angles() acq_rot *= 180 / np.pi # create coordinate grids @@ -102,12 +102,12 @@ def write(self, file_name: str, file_dir: str = "") -> None: "Euler angles refer to Sample Coordinate system (CS0)!\n") ctf_file.write(f"Phases\t{len(self.metadata['phases'])}\n") for phase in self.metadata['phases']: - dims = "{:.3f};{:.3f};{:.3f}".format(*phase.latticeParams[:3]) - angles = (f * 180 / np.pi for f in phase.latticeParams[3:]) + dims = "{:.3f};{:.3f};{:.3f}".format(*phase.lattice_params[:3]) + angles = (f * 180 / np.pi for f in phase.lattice_params[3:]) angles = "{:.3f};{:.3f};{:.3f}".format(*angles) ctf_file.write(f"{dims}\t{angles}\t{phase.name}" - f"\t{phase.laueGroup}\t0\t\t\t\n") + f"\t{phase.laue_group}\t0\t\t\t\n") ctf_file.write("Phase\tX\tY\tBands\tError\tEuler1\tEuler2" "\tEuler3\tMAD\tBC\tBS\n") diff --git a/defdap/hrdic.py b/defdap/hrdic.py index 792bd31..00fd0eb 100755 --- a/defdap/hrdic.py +++ b/defdap/hrdic.py @@ -1,4 +1,4 @@ -# Copyright 2021 Mechanics of Microstructures Group +# Copyright 2025 Mechanics of Microstructures Group # at The University of Manchester # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,26 +13,29 @@ # See the License for the specific language governing permissions and # limitations under the License. +from pathlib import Path + import numpy as np from matplotlib.pyplot import imread import inspect from skimage import transform as tf -from skimage import morphology as mph +from skimage import measure from scipy.stats import mode from scipy.ndimage import binary_dilation import peakutils -from defdap.file_readers import DICDataLoader +from defdap._accelerated import flood_fill_dic +from defdap.utils import Datastore +from defdap.file_readers import DICDataLoader, DavisLoader from defdap import base -from defdap.quat import Quat from defdap import defaults from defdap.plotting import MapPlot, GrainPlot from defdap.inspector import GrainInspector -from defdap.utils import reportProgress +from defdap.utils import report_progress class Map(base.Map): @@ -52,73 +55,51 @@ class Map(base.Map): Size of map along x (from header). ydim : int Size of map along y (from header). - xc : numpy.ndarray - X coordinates. - yc : numpy.ndarray - Y coordinates. - xd : numpy.ndarray - X displacement. - yd : numpy.ndarray - Y displacement. + shape : tuple + Size of map (after cropping, like *Dim). corrVal : numpy.ndarray Correlation value. - ebsdMap : defdap.ebsd.Map + ebsd_map : defdap.ebsd.Map EBSD map linked to DIC map. - ebsdTransform : various - Transform from EBSD to DIC coordinates. - ebsdTransformInv : various - Transform from DIC to EBSD coordinates. - ebsdGrainIds : list - EBSD grain IDs corresponding to DIC map grain IDs. - patternImPath : str - Path to BSE image of map. - plotHomog : - Map to use for defining homologous points (defaults to plotMaxShear). - highlightAlpha : float + highlight_alpha : float Alpha (transparency) of grain highlight. bseScale : float Size of a pixel in the correlated images. - patScale : float - Size of pixel in loaded pattern relative to pixel size of dic data i.e 1 means they - are the same size and 2 means the pixels in the pattern are half the size of the dic data. path : str File path. fname : str File name. - xDim : int - Size of map along x (after cropping). - yDim : int - Size of map along y (after cropping). - self.x_map : numpy.ndarray - Map of u displacement component along x. - self.y_map : numpy.ndarray - Map of v displacement component along x. - f11, f22, f12, f21 ; numpy.ndarray - Components of the deformation gradient, where 1=x and 2=y. - e11, e22, e12 : numpy.ndarray - Components of the green strain , where 1=x and 2=y. - eMaxShear : numpy.ndarray - Max shear component np.sqrt(((e11 - e22) / 2.)**2 + e12**2). - cropDists : numpy.ndarray + crop_dists : numpy.ndarray Crop distances (default all zeros). + data : defdap.utils.Datastore + Must contain after loading data (maps): + coordinate : numpy.ndarray + X and Y coordinates + displacement : numpy.ndarray + X and Y displacements + Generated data: + f : numpy.ndarray + Components of the deformation gradient (0=x, 1=y). + e : numpy.ndarray + Components of the green strain (0=x, 1=y). + max_shear : numpy.ndarray + Max shear component np.sqrt(((e11 - e22) / 2.)**2 + e12**2). + Derived data: + Grain list data to map data from all grains + """ - def __init__(self, path, fname, dataType=None): + MAPNAME = 'hrdic' + + def __init__(self, *args, **kwargs): """Initialise class and import DIC data from file. Parameters ---------- - path : str - Path to file. - fname : str - Name of file including extension. - dataType : str - Type of data file. + *args, **kwarg + Passed to base constructor """ - # Call base class constructor - super(Map, self).__init__() - # Initialise variables self.format = None # Software name self.version = None # Software version @@ -126,227 +107,225 @@ def __init__(self, path, fname, dataType=None): self.xdim = None # size of map along x (from header) self.ydim = None # size of map along y (from header) - self.xc = None # x coordinates - self.yc = None # y coordinates - self.xd = None # x displacement - self.yd = None # y displacement - - self.corrVal = None # correlation value - - self.ebsdMap = None # EBSD map linked to DIC map - self.ebsdTransform = None # Transform from EBSD to DIC coordinates - self.ebsdTransformInv = None # Transform from DIC to EBSD coordinates - self.ebsdGrainIds = None - self.patternImPath = None # Path to BSE image of map - self.plotHomog = self.plotMaxShear # Use max shear map for defining homologous points - self.highlightAlpha = 0.6 - self.bseScale = None # size of a pixel in the correlated images - self.patScale = None # size of pixel in loaded - # pattern relative to pixel size of dic data i.e 1 means they - # are the same size and 2 means the pixels in the pattern are - # half the size of the dic data. - self.path = path # file path - self.fname = fname # file name - - self.loadData(path, fname, dataType=dataType) - - # *dim are full size of data. *Dim are size after cropping - self.xDim = self.xdim - self.yDim = self.ydim - - self.x_map = self._map(self.xd) # u displacement component along x - self.y_map = self._map(self.yd) # v displacement component along x - xDispGrad = self._grad(self.x_map) #d/dy is first term, d/dx is second - yDispGrad = self._grad(self.y_map) + # Call base class constructor + super(Map, self).__init__(*args, **kwargs) - # Deformation gradient - self.f11 = xDispGrad[1] + 1 - self.f22 = yDispGrad[0] + 1 - self.f12 = xDispGrad[0] - self.f21 = yDispGrad[1] + self.corr_val = None # correlation value + + self.ebsd_map = None # EBSD map linked to DIC map + self.highlight_alpha = 0.6 + self.bse_scale = None # size of pixels in pattern images + self.bse_scale = None # size of pixels in pattern images + self.crop_dists = np.array(((0, 0), (0, 0)), dtype=int) + + self.data.add_generator( + 'mask', self.calc_mask, unit='', type='map', order=0, + cropped=True, apply_mask=False + ) + # Deformation gradient + f = np.gradient(self.data.displacement, self.binning, axis=(1, 2)) + f = np.array(f).transpose((1, 0, 2, 3))[:, ::-1] + f[0, 0] += 1 + f[1, 1] += 1 + self.data.add( + 'f', f, unit='', type='map', order=2, default_component=(0, 0), + plot_params={ + 'plot_colour_bar': True, + 'clabel': 'Deformation gradient', + }, + apply_mask=True + ) # Green strain - self.e11 = xDispGrad[1] + \ - 0.5*(xDispGrad[1]*xDispGrad[1] + yDispGrad[1]*yDispGrad[1]) - self.e22 = yDispGrad[0] + \ - 0.5*(xDispGrad[0]*xDispGrad[0] + yDispGrad[0]*yDispGrad[0]) - self.e12 = 0.5*(xDispGrad[0] + yDispGrad[1] + - xDispGrad[1]*xDispGrad[0] + yDispGrad[1]*yDispGrad[0]) + e = 0.5 * (np.einsum('ki...,kj...->ij...', f, f)) + e[0, 0] -= 0.5 + e[1, 1] -= 0.5 + self.data.add( + 'e', e, unit='', type='map', order=2, default_component=(0, 0), + plot_params={ + 'plot_colour_bar': True, + 'clabel': 'Green strain', + }, + apply_mask=True + ) # max shear component - self.eMaxShear = np.sqrt(((self.e11 - self.e22) / 2.)**2 + self.e12**2) + max_shear = np.sqrt(((e[0, 0] - e[1, 1]) / 2.) ** 2 + e[0, 1] ** 2) + self.data.add( + 'max_shear', max_shear, unit='', type='map', order=0, + plot_params={ + 'plot_colour_bar': True, + 'clabel': 'Effective shear strain', + }, + apply_mask=True + ) + # pattern image + self.data.add_generator( + 'pattern', self.load_pattern, unit='', type='map', order=0, + save=False, apply_mask=False, + plot_params={ + 'cmap': 'gray' + } + ) + self.data.add_generator( + 'grains', self.find_grains, unit='', type='map', order=0, + cropped=True, apply_mask=False + ) - self.component = {'f11': self.f11, 'f12': self.f12, 'f21': self.f21, 'f22': self.f22, - 'e11': self.e11, 'e12': self.e12, 'e22': self.e22, - 'eMaxShear': self.eMaxShear, - 'x_map': self.x_map, 'y_map': self.y_map} + self.plot_default = lambda *args, **kwargs: self.plot_map( + map_name='max_shear', plot_gbs=True, *args, **kwargs + ) + self.homog_map_name = 'max_shear' - # crop distances (default all zeros) - self.cropDists = np.array(((0, 0), (0, 0)), dtype=int) + @property + def original_shape(self): + return self.ydim, self.xdim - self.plotDefault = lambda *args, **kwargs: self.plotMaxShear(plotGBs=True, *args, **kwargs) - @property - def crystalSym(self): - return self.ebsdMap.crystalSym + def crystal_sym(self): + return self.ebsd_map.crystal_sym - @reportProgress("loading HRDIC data") - def loadData(self, fileDir, fileName, dataType=None): + @report_progress("loading HRDIC data") + def load_data(self, file_name, data_type=None): """Load DIC data from file. Parameters ---------- - fileDir : str - Path to file. - fileName : str + file_name : pathlib.Path Name of file including extension. - dataType : str, {'DavisText'} + data_type : str, {'Davis', 'OpenPIV'} Type of data file. """ - dataType = "DavisText" if dataType is None else dataType - - dataLoader = DICDataLoader() - if dataType == "DavisText": - metadataDict = dataLoader.loadDavisMetadata(fileName, fileDir) - dataDict = dataLoader.loadDavisData(fileName, fileDir) - else: - raise Exception("No loader found for this DIC data.") + data_loader = DICDataLoader.get_loader(data_type) + data_loader.load(file_name) - self.format = metadataDict['format'] # Software name - self.version = metadataDict['version'] # Software version - self.binning = metadataDict['binning'] # Sub-window width in pixels - self.xdim = metadataDict['xDim'] # size of map along x (from header) - self.ydim = metadataDict['yDim'] # size of map along y (from header) + metadata_dict = data_loader.loaded_metadata + self.format = metadata_dict['format'] # Software name + self.version = metadata_dict['version'] # Software version + self.binning = metadata_dict['binning'] # Sub-window width in pixels + # *dim are full size of data. shape (old *Dim) are size after cropping + # *dim are full size of data. shape (old *Dim) are size after cropping + self.shape = metadata_dict['shape'] + self.xdim = metadata_dict['shape'][1] # size of map along x (from header) + self.ydim = metadata_dict['shape'][0] # size of map along y (from header) - self.xc = dataDict['xc'] # x coordinates - self.yc = dataDict['yc'] # y coordinates - self.xd = dataDict['xd'] # x displacement - self.yd = dataDict['yd'] # y displacement + self.data.update(data_loader.loaded_data) # write final status - yield "Loaded {0} {1} data (dimensions: {2} x {3} pixels, " \ - "sub-window size: {4} x {4} pixels)".format( - self.format, self.version, self.xdim, self.ydim, self.binning - ) - - def loadCorrValData(self, fileDir, fileName, dataType=None): + yield (f"Loaded {self.format} {self.version} data " + f"(dimensions: {self.xdim} x {self.ydim} pixels, " + f"sub-window size: {self.binning} x {self.binning} pixels)") + + def load_corr_val_data(self, file_name, data_type=None): """Load correlation value for DIC data Parameters ---------- - fileDir : str + file_name : pathlib.Path or str Path to file. - fileName : str - Name of file including extension. - dataType : str, {'DavisImage'} + data_type : str, {'DavisImage'} Type of data file. """ - dataType = "DavisImage" if dataType is None else dataType + data_type = "DavisImage" if data_type is None else data_type - dataLoader = DICDataLoader() - if dataType == "DavisImage": - loadedData = dataLoader.loadDavisImageData(fileName, fileDir) + data_loader = DavisLoader() + if data_type == "DavisImage": + loaded_data = data_loader.load_davis_image_data(Path(file_name)) else: raise Exception("No loader found for this DIC data.") - self.corrVal = loadedData + self.corr_val = loaded_data - assert self.xdim == self.corrVal.shape[1], \ + assert self.xdim == self.corr_val.shape[1], \ "Dimensions of imported data and dic data do not match" - assert self.ydim == self.corrVal.shape[0], \ + assert self.ydim == self.corr_val.shape[0], \ "Dimensions of imported data and dic data do not match" - def _map(self, data_col): - data_map = np.reshape(np.array(data_col), (self.ydim, self.xdim)) - return data_map - - def _grad(self, data_map): - grad_step = min(abs((np.diff(self.xc)))) - data_grad = np.gradient(data_map, grad_step, grad_step) - return data_grad - - def retrieveName(self): + def retrieve_name(self): """Gets the first name assigned to the a map, as a string """ for fi in reversed(inspect.stack()): - names = [var_name for var_name, var_val in fi.frame.f_locals.items() if var_val is self] + names = [key for key, val in fi.frame.f_locals.items() if val is self] if len(names) > 0: return names[0] - def setScale(self, micrometrePerPixel): + def set_scale(self, scale): """Sets the scale of the map. Parameters ---------- - micrometrePerPixel : float + scale : float Length of pixel in original BSE image in micrometres. """ - self.bseScale = micrometrePerPixel + self.bse_scale = scale @property def scale(self): """Returns the number of micrometers per pixel in the DIC map. """ - if self.bseScale is None: - raise ValueError("Map scale not set. Set with setScale()") + if self.bse_scale is None: + # raise ValueError("Map scale not set. Set with setScale()") + return None - return self.bseScale * self.binning + return self.bse_scale * self.binning - def printStatsTable(self, percentiles, components): + def print_stats_table(self, percentiles, components): """Print out a statistics table for a DIC map Parameters ---------- - percentiles : list(float) + percentiles : list of float list of percentiles to print i.e. 0, 50, 99. - components : list(str) - list of map components to print i.e. e11, f11, eMaxShear, x_map. + components : list of str + list of map components to print i.e. e, f, max_shear. """ # Check that components are valid - if set(components).issubset(self.component) is False: - strFormat = ('{}, ') * (len(self.component) - 1) + ('{}') - raise Exception("Components must be: " + strFormat.format(*self.component)) + if not set(components).issubset(self.data): + str_format = '{}, ' * (len(self.data) - 1) + '{}' + raise Exception("Components must be: " + str_format.format(*self.data)) # Print map info print('\033[1m', end=''), # START BOLD print("{0} (dimensions: {1} x {2} pixels, sub-window size: {3} " "x {3} pixels, number of points: {4})\n".format( - self.retrieveName(), self.xDim, self.yDim, - self.binning, self.xDim * self.yDim + self.retrieve_name(), self.x_dim, self.y_dim, + self.binning, self.x_dim * self.y_dim )) # Print header - strFormat = ('{:10} ') + (len(percentiles)) * '{:12}' - print(strFormat.format(*(['Component'] + percentiles))) + str_format = '{:10} ' + '{:12}' * len(percentiles) + print(str_format.format('Component', *percentiles)) print('\033[0m', end='') # END BOLD # Print table - strFormat = ('{:10} ') + (len(percentiles)) * '{:12.4f}' + str_format = '{:10} ' + '{:12.4f}' * len(percentiles) for c in components: - # Get the values and print in table - per = [np.nanpercentile(self.crop(self.component[c]), p) for p in percentiles] - print(strFormat.format(*([c] + per))) + # Iterate over tensor components (i.e. e11, e22, e12) + for i in np.ndindex(self.data[c].shape[:len(np.shape(self.data[c]))-2]): + per = [np.nanpercentile(self.data[c][i], p) for p in percentiles] + print(str_format.format(c+''.join([str(t+1) for t in i]), *per)) - def setCrop(self, xMin=None, xMax=None, yMin=None, yMax=None, updateHomogPoints=False): + def set_crop(self, *, left=None, right=None, top=None, bottom=None, + update_homog_points=False): """Set a crop for the DIC map. Parameters ---------- - xMin : int - Distance to crop from left in pixels. - xMax : int - Distance to crop from right in pixels. - yMin : int - Distance to crop from top in pixels. - yMax : int - Distance to crop from bottom in pixels. - updateHomogPoints : bool, optional + left : int + Distance to crop from left in pixels (formally `xMin`) + right : int + Distance to crop from right in pixels (formally `xMax`) + top : int + Distance to crop from top in pixels (formally `yMin`) + bottom : int + Distance to crop from bottom in pixels (formally `yMax`) + update_homog_points : bool, optional If true, change homologous points to reflect crop. """ @@ -355,126 +334,76 @@ def setCrop(self, xMin=None, xMax=None, yMin=None, yMax=None, updateHomogPoints= dy = 0 # update crop distances - if xMin is not None: - if updateHomogPoints: - dx = self.cropDists[0, 0] - int(xMin) - self.cropDists[0, 0] = int(xMin) - if xMax is not None: - self.cropDists[0, 1] = int(xMax) - if yMin is not None: - if updateHomogPoints: - dy = self.cropDists[1, 0] - int(yMin) - self.cropDists[1, 0] = int(yMin) - if yMax is not None: - self.cropDists[1, 1] = int(yMax) + if left is not None: + left = int(left) + dx = self.crop_dists[0, 0] - left + self.crop_dists[0, 0] = left + if right is not None: + self.crop_dists[0, 1] = int(right) + if top is not None: + top = int(top) + dy = self.crop_dists[1, 0] - top + self.crop_dists[1, 0] = top + if bottom is not None: + self.crop_dists[1, 1] = int(bottom) # update homogo points if required - if updateHomogPoints and (dx != 0 or dy != 0): - self.updateHomogPoint(homogID=-1, delta=(dx, dy)) + if update_homog_points and (dx != 0 or dy != 0): + self.frame.update_homog_points(homog_idx=-1, delta=(dx, dy)) # set new cropped dimensions - self.xDim = self.xdim - self.cropDists[0, 0] - self.cropDists[0, 1] - self.yDim = self.ydim - self.cropDists[1, 0] - self.cropDists[1, 1] + x_dim = self.xdim - self.crop_dists[0, 0] - self.crop_dists[0, 1] + y_dim = self.ydim - self.crop_dists[1, 0] - self.crop_dists[1, 1] + self.shape = (y_dim, x_dim) - def crop(self, mapData, binned=True): + def crop(self, map_data, binning=None): """ Crop given data using crop parameters stored in map i.e. cropped_data = DicMap.crop(DicMap.data_to_crop). Parameters ---------- - mapData : numpy.ndarray + map_data : numpy.ndarray Bap data to crop. - binned : bool + binning : int True if mapData is binned i.e. binned BSE pattern. """ - if binned: - multiplier = 1 - else: - multiplier = self.patScale - - minY = int(self.cropDists[1, 0] * multiplier) - maxY = int((self.ydim - self.cropDists[1, 1]) * multiplier) - - minX = int(self.cropDists[0, 0] * multiplier) - maxX = int((self.xdim - self.cropDists[0, 1]) * multiplier) + binning = 1 if binning is None else binning - return mapData[minY:maxY, minX:maxX] + min_y = int(self.crop_dists[1, 0] * binning) + max_y = int((self.ydim - self.crop_dists[1, 1]) * binning) - def setHomogPoint(self, points=None, display=None, **kwargs): - """Set homologous points. Uses interactive GUI if points is None. - - Parameters - ---------- + min_x = int(self.crop_dists[0, 0] * binning) + max_x = int((self.xdim - self.crop_dists[0, 1]) * binning) - points : list, optional - homologous points to set. - display : string, optional - Use max shear map if set to 'maxshear' or pattern if set to 'pattern'. + return map_data[..., min_y:max_y, min_x:max_x] - """ - if points is not None: - self.homogPoints = points - - if points is None: - if display is None: - display = "maxshear" - - # Set plot dafault to display selected image - display = display.lower().replace(" ", "") - if display == "bse" or display == "pattern": - self.plotHomog = self.plotPattern - binSize = self.patScale - else: - self.plotHomog = self.plotMaxShear - binSize = 1 - - # Call set homog points from base class setting the bin size - super(type(self), self).setHomogPoint(binSize=binSize, points=points, **kwargs) - - def linkEbsdMap(self, ebsdMap, transformType="affine", **kwargs): + def link_ebsd_map(self, ebsd_map, transform_type="affine", **kwargs): """Calculates the transformation required to align EBSD dataset to DIC. Parameters ---------- - ebsdMap : defdap.ebsd.Map + ebsd_map : defdap.ebsd.Map EBSD map object to link. - transformType : str, optional + transform_type : str, optional affine, piecewiseAffine or polynomial. kwargs All arguments are passed to `estimate` method of the transform. """ - self.ebsdMap = ebsdMap - calc_inv = False - if transformType.lower() == "piecewiseaffine": - self.ebsdTransform = tf.PiecewiseAffineTransform() - elif transformType.lower() == "projective": - self.ebsdTransform = tf.ProjectiveTransform() - elif transformType.lower() == "polynomial": - calc_inv = True - self.ebsdTransform = tf.PolynomialTransform() - self.ebsdTransformInv = tf.PolynomialTransform() - else: - # default to using affine - self.ebsdTransform = tf.AffineTransform() - - # calculate transform from EBSD to DIC frame - self.ebsdTransform.estimate( - np.array(self.homogPoints), - np.array(self.ebsdMap.homogPoints), - **kwargs + self.ebsd_map = ebsd_map + kwargs.update({'type': transform_type.lower()}) + self.experiment.link_frames(self.frame, ebsd_map.frame, kwargs) + self.data.add_derivative( + self.ebsd_map.data, + lambda boundaries: BoundarySet.from_ebsd_boundaries( + self, boundaries + ), + in_props={ + 'type': 'boundaries' + } ) - # Calculate inverse if required - if calc_inv: - self.ebsdTransformInv.estimate( - np.array(self.ebsdMap.homogPoints), - np.array(self.homogPoints), - **kwargs - ) - else: - self.ebsdTransformInv = self.ebsdTransform.inverse - def checkEbsdLinked(self): + def check_ebsd_linked(self): """Check if an EBSD map has been linked. Returns @@ -488,23 +417,19 @@ def checkEbsdLinked(self): If EBSD map not linked. """ - if self.ebsdMap is None: + if self.ebsd_map is None: raise Exception("No EBSD map linked.") return True - def warpToDicFrame(self, mapData, cropImage=True, order=1, preserve_range=False): + def warp_to_dic_frame(self, map_data, **kwargs): """Warps a map to the DIC frame. Parameters ---------- - mapData : numpy.ndarray + map_data : numpy.ndarray Data to warp. - cropImage : bool, optional - Crop to size of DIC map if true. - order : int, optional - Order of interpolation (0: Nearest-neighbor, 1: Bi-linear...). - preserve_range: bool, optional - Keep the original range of values. + kwargs + All other arguments passed to :func:`defdap.experiment.Experiment.warp_map`. Returns ---------- @@ -513,292 +438,111 @@ def warpToDicFrame(self, mapData, cropImage=True, order=1, preserve_range=False) """ # Check a EBSD map is linked - self.checkEbsdLinked() - - if (cropImage or type(self.ebsdTransform) is not tf.AffineTransform): - # crop to size of DIC map - outputShape = (self.yDim, self.xDim) - # warp the map - warpedMap = tf.warp( - mapData, self.ebsdTransform, - output_shape=outputShape, - order=order, preserve_range=preserve_range - ) - else: - # copy ebsd transform and change translation to give an extra - # 5% border to show the entire image after rotation/shearing - tempEbsdTransform = tf.AffineTransform(matrix=np.copy(self.ebsdTransform.params)) - tempEbsdTransform.params[0:2, 2] = -0.05 * np.array(mapData.shape) - - # output the entire warped image with 5% border (add some - # extra to fix a bug) - outputShape = np.array(mapData.shape) * 1.4 / tempEbsdTransform.scale - - # warp the map - warpedMap = tf.warp( - mapData, tempEbsdTransform, - output_shape=outputShape.astype(int), - order=order, preserve_range=preserve_range - ) - - return warpedMap - - def warp_lines_to_dic_frame(self, lines): - """Warp a set of lines to the DIC reference frame. - - Parameters - ---------- - lines : list of tuples - Lines to warp. Each line is represented as a tuple of start - and end coordinates (x, y). - - Returns - ------- - list of tuples - List of warped lines with same representation as input. - - """ - # Flatten to coord list - lines = np.array(lines).reshape(-1, 2) - # Transform & reshape back - lines = self.ebsdTransformInv(lines).reshape(-1, 2, 2) - # Round to nearest - lines = np.round(lines - 0.5) + 0.5 - lines = [(tuple(l[0]), tuple(l[1])) for l in lines] - - return lines - - @property - def boundaries(self): - """Returns EBSD map grain boundaries warped to DIC frame. - - """ - # Check a EBSD map is linked - self.checkEbsdLinked() - - # image is returned cropped if a piecewise transform is being used - boundaries = self.ebsdMap.boundaries - boundaries = self.warpToDicFrame( - -boundaries.astype(float), cropImage=False - ) - boundaries = boundaries > 0.1 - boundaries = mph.skeletonize(boundaries) - boundaries = mph.remove_small_objects( - boundaries, min_size=10, connectivity=2 + self.check_ebsd_linked() + return self.experiment.warp_image( + map_data, self.ebsd_map.frame, self.frame, output_shape=self.shape, + **kwargs ) - # crop image if it is a simple affine transform - if type(self.ebsdTransform) is tf.AffineTransform: - # need to apply the translation of ebsd transform and - # remove 5% border - crop = np.copy(self.ebsdTransform.params[0:2, 2]) - crop += 0.05 * np.array(self.ebsdMap.boundaries.shape) - # the crop is defined in EBSD coords so need to transform it - transformMatrix = np.copy(self.ebsdTransform.params[0:2, 0:2]) - crop = np.matmul(np.linalg.inv(transformMatrix), crop) - crop = crop.round().astype(int) - - boundaries = boundaries[crop[1]:crop[1] + self.yDim, - crop[0]:crop[0] + self.xDim] - - return -boundaries.astype(int) - - @property - def boundaryLines(self): - return self.warp_lines_to_dic_frame(self.ebsdMap.boundaryLines) - - @property - def phaseBoundaryLines(self): - return self.warp_lines_to_dic_frame(self.ebsdMap.phaseBoundaryLines) - - def generateThresholdMask(self, mask, dilation=0, preview=True): + def calc_mask(self, mask=None, dilation=0): """ - Generate a dilated mask, based on a boolean array and previews the appication of - this mask to the max shear map. + Generate a dilated mask, based on a boolean array. Parameters ---------- - mask: numpy.array(bool) - A boolean array where points to be removed are True + mask: numpy.array(bool) or None + A boolean array where points to be removed are True. Set to None to disable masking. dilation: int, optional Number of pixels to dilate the mask by. Useful to remove anomalous points around masked values. No dilation applied if not specified. - preview: bool - If true, show the mask and preview the masked effective shear strain map. Examples ---------- - To remove data points in dicMap where eMaxShear is above 0.8, use: + + To disable masking: - >>> mask = dicMap.eMaxShear > 0.8 + >>> mask = None + + To remove data points in dic_map where `max_shear` is above 0.8, use: + + >>> mask = dic_map.data.max_shear > 0.8 - To remove data points in dicMap where e11 is above 1 or less than -1, use: + To remove data points in dic_map where e11 is above 1 or less than -1, use: - >>> mask = (dicMap.e11 > 1) | (dicMap.e11 < -1) + >>> mask = (dic_map.data.e[0, 0] > 1) | (dic_map.data.e[0, 0] < -1) - To remove data points in dicMap where corrVal is less than 0.4, use: + To remove data points in dic_map where corrVal is less than 0.4, use: - >>> mask = dicMap.corrVal < 0.4 + >>> mask = dic_map.corr_val < 0.4 Note: correlation value data needs to be loaded seperately from the DIC map, - see :func:`defdap.hrdic.loadCorrValData` + see :func:`defdap.hrdic.load_corr_val_data` """ - self.mask = mask + if mask is None: + self.data.mask = None + return mask + + if not isinstance(mask, np.ndarray) or mask.shape != self.shape: + raise ValueError('The mask must be a numpy array the same shape as ' + 'the cropped map.') if dilation != 0: - self.mask = binary_dilation(self.mask, iterations=dilation) - - numRemoved = np.sum(self.mask) - numTotal = self.xdim * self.ydim - numRemovedCrop = np.sum(self.crop(self.mask)) - numTotalCrop = self.xDim * self.yDim - - print('Filtering will remove {0} \ {1} ({2:.3f} %) datapoints in map' - .format(numRemoved, numTotal, (numRemoved / numTotal) * 100)) - print( - 'Filtering will remove {0} \ {1} ({2:.3f} %) datapoints in cropped map' - .format(numRemovedCrop, numTotalCrop, - (numRemovedCrop / numTotalCrop * 100))) - - if preview == True: - plot1 = MapPlot.create(self, self.crop(self.mask), cmap='binary') - plot1.setTitle('Removed datapoints in black') - plot2 = MapPlot.create(self, - self.crop( - np.where(self.mask == True, np.nan, - self.eMaxShear)), - plotColourBar='True', - clabel="Effective shear strain") - plot2.setTitle('Effective shear strain preview') - print( - 'Use applyThresholdMask function to apply this filtering to data') - - def applyThresholdMask(self): - """ Apply mask to all DIC map data by setting masked values to nan. + mask = binary_dilation(mask, iterations=dilation) - """ - self.eMaxShear = np.where(self.mask == True, np.nan, self.eMaxShear) - - self.e11 = np.where(self.mask == True, np.nan, self.e11) - self.e12 = np.where(self.mask == True, np.nan, self.e12) - self.e22 = np.where(self.mask == True, np.nan, self.e22) - - self.f11 = np.where(self.mask == True, np.nan, self.f11) - self.f12 = np.where(self.mask == True, np.nan, self.f12) - self.f22 = np.where(self.mask == True, np.nan, self.f22) + num_removed = np.sum(mask) + num_total = self.shape[0] * self.shape[1] + frac_removed = num_removed / num_total * 100 + print(f'Masking will mask {num_removed} out of {num_total} ' + f'({frac_removed:.2f} %) datapoints in cropped map.') + + self.data.mask = mask - self.x_map = np.where(self.mask == True, np.nan, self.x_map) - self.y_map = np.where(self.mask == True, np.nan, self.y_map) + return mask - self.component = {'f11': self.f11, 'f12': self.f12, 'f21': self.f21, - 'f22': self.f22, - 'e11': self.e11, 'e12': self.e12, 'e22': self.e22, - 'eMaxShear': self.eMaxShear, - 'x_map': self.x_map, 'y_map': self.y_map} + def mask(self, map_data): + """ Values set to False in mask will be set to nan in map. + """ + if self.data.mask is None: + return map_data + else: + return np.ma.array(map_data, + mask=np.broadcast_to(self.data.mask, np.shape(map_data))) - def setPatternPath(self, filePath, windowSize): + def set_pattern(self, img_path, window_size): """Set the path to the image of the pattern. Parameters ---------- - filePath : str + path : str Path to image. - windowSize : float + window_size : int Size of pixel in pattern image relative to pixel size of DIC data i.e 1 means they are the same size and 2 means the pixels in the pattern are half the size of the dic data. """ - self.patternImPath = self.path + filePath - self.patScale = windowSize - - def plotPattern(self, **kwargs): - """Plot BSE image of Map. For use with setting homog points. - - Parameters - ---------- - kwargs - All arguments are passed to :func:`defdap.plotting.MapPlot.create`. - - Returns - ------- - defdap.plotting.MapPlot - - """ - # Set default plot parameters then update with any input - plotParams = { - 'cmap': 'gray' - } - try: - plotParams['scale'] = self.scale / self.patScale * 1e-6 - except(ValueError): - pass - plotParams.update(kwargs) - - # Check image path is set - if self.patternImPath is None: - raise Exception("First set path to pattern image.") - - bseImage = imread(self.patternImPath) - bseImage = self.crop(bseImage, binned=False) - - plot = MapPlot.create(self, bseImage, **plotParams) - - return plot - - def plotMap(self, component, **kwargs): - """Plot a map from the DIC data. - - Parameters - ---------- - component - Map component to plot i.e. e11, f11, eMaxShear. - kwargs - All arguments are passed to :func:`defdap.plotting.MapPlot.create`. - - Returns - ------- - defdap.plotting.MapPlot - Plot containing map. - - """ - # Set default plot parameters then update with any input - plotParams = { - 'plotColourBar': True, - 'clabel': component - } - plotParams.update(kwargs) - - plot = MapPlot.create(self, self.crop(self.component[component]), **plotParams) - - return plot - - def plotMaxShear(self, **kwargs): - """Plot a map of maximum shear strain. - - Parameters - ---------- - kwargs - All arguments are passed to :func:`defdap.hrdic.plotMap`. - - Returns - ------- - defdap.plotting.MapPlot - Plot containing map. - - """ - - params = { - 'clabel': 'Effective Shear Strain' - } - params.update(kwargs) - - plot = self.plotMap('eMaxShear', **params) - - return plot + path = self.file_name.parent / img_path + self.data['pattern', 'path'] = path + self.data['pattern', 'binning'] = window_size + + def load_pattern(self): + print('Loading img') + path = self.data.get_metadata('pattern', 'path') + binning = self.data.get_metadata('pattern', 'binning', 1) + if path is None: + raise FileNotFoundError("First set path to pattern image.") + + img = imread(path) + exp_shape = tuple(v * binning for v in self.original_shape) + if img.shape != exp_shape: + raise ValueError( + f'Incorrect size of pattern image. For binning of {binning} ' + f'expected size {exp_shape[::-1]} but got {img.shape[::-1]}' + ) + return img - def plotGrainAvMaxShear(self, **kwargs): + def plot_grain_av_max_shear(self, **kwargs): """Plot grain map with grains filled with average value of max shear. This uses the max shear values stored in grain objects, to plot other data use :func:`~defdap.hrdic.Map.plotGrainAv`. @@ -806,108 +550,112 @@ def plotGrainAvMaxShear(self, **kwargs): Parameters ---------- kwargs - All arguments are passed to :func:`defdap.base.Map.plotGrainDataMap`. + All arguments are passed to :func:`defdap.base.Map.plot_grain_data_map`. """ # Set default plot parameters then update with any input - plotParams = { + plot_params = { 'clabel': "Effective shear strain" } - plotParams.update(kwargs) + plot_params.update(kwargs) - plot = self.plotGrainDataMap( - mapData=self.crop(self.eMaxShear), **plotParams + plot = self.plot_grain_data_map( + map_data=self.data.max_shear, **plot_params ) return plot - @reportProgress("finding grains") - def findGrains(self, algorithm=None, minGrainSize=10): + @report_progress("finding grains") + def find_grains(self, algorithm=None, min_grain_size=10): """Finds grains in the DIC map. Parameters ---------- algorithm : str {'warp', 'floodfill'} Use floodfill or warp algorithm. - minGrainSize : int + min_grain_size : int Minimum grain area in pixels for floodfill algorithm. """ # Check a EBSD map is linked - self.checkEbsdLinked() + self.check_ebsd_linked() if algorithm is None: algorithm = defaults['hrdic_grain_finding_method'] + algorithm = algorithm.lower() + + grain_list = [] + group_id = Datastore.generate_id() if algorithm == 'warp': # Warp EBSD grain map to DIC frame - self.grains = self.warpToDicFrame(self.ebsdMap.grains, cropImage=True, - order=0, preserve_range=True) + grains = self.warp_to_dic_frame( + self.ebsd_map.data.grains, order=0, preserve_range=True + ) # Find all unique values (these are the EBSD grain IDs in the DIC area, sorted) - self.ebsdGrainIds = np.array([int(i) for i in np.unique(self.grains) if i>0]) - - # Make a new list of sequential IDs of same length as number of grains - dicGrainIds = np.arange(1, len(self.ebsdGrainIds)+1) + ebsd_grain_ids = np.unique(grains) + neg_vals = ebsd_grain_ids[ebsd_grain_ids <= 0] + ebsd_grain_ids = ebsd_grain_ids[ebsd_grain_ids > 0] # Map the EBSD IDs to the DIC IDs (keep the same mapping for values <= 0) - negVals = np.array([i for i in np.unique(self.grains) if i<=0]) - old = np.concatenate((negVals, self.ebsdGrainIds)) - new = np.concatenate((negVals, dicGrainIds)) - index = np.digitize(self.grains.ravel(), old, right=True) - self.grains = new[index].reshape(self.grains.shape) + old = np.concatenate((neg_vals, ebsd_grain_ids)) + new = np.concatenate((neg_vals, np.arange(1, len(ebsd_grain_ids) + 1))) + index = np.digitize(grains.ravel(), old, right=True) + grains = new[index].reshape(self.shape) + grainprops = measure.regionprops(grains) + props_dict = {prop.label: prop for prop in grainprops} - self.grainList = [] - for i, (dicGrainId, ebsdGrainId) in enumerate(zip(dicGrainIds, self.ebsdGrainIds)): - yield i / len(dicGrainIds) # Report progress + for dic_grain_id, ebsd_grain_id in enumerate(ebsd_grain_ids): + yield dic_grain_id / len(ebsd_grain_ids) # Make grain object - currentGrain = Grain(grainID=dicGrainId, dicMap=self) + grain = Grain(dic_grain_id, self, group_id) # Find (x,y) coordinates and corresponding max shears of grain - coords = np.argwhere(self.grains == dicGrainId) # (y,x) - currentGrain.coordList = np.flip(coords, axis=1) # (x,y) - currentGrain.maxShearList = self.eMaxShear[coords[:,0]+ self.cropDists[1, 0], - coords[:,1]+ self.cropDists[0, 0]] + coords = props_dict[dic_grain_id + 1].coords # (y, x) + grain.data.point = np.flip(coords, axis=1) # (x, y) # Assign EBSD grain ID to DIC grain and increment grain list - currentGrain.ebsdGrainId = ebsdGrainId - 1 - currentGrain.ebsdGrain = self.ebsdMap.grainList[ebsdGrainId - 1] - currentGrain.ebsdMap = self.ebsdMap - self.grainList.append(currentGrain) + grain.ebsd_grain = self.ebsd_map[ebsd_grain_id - 1] + grain.ebsd_map = self.ebsd_map + grain_list.append(grain) elif algorithm == 'floodfill': # Initialise the grain map - self.grains = np.copy(self.boundaries) - - self.grainList = [] + grains = -np.copy(self.data.grain_boundaries.image.astype(int)) # List of points where no grain has been set yet - points_left = self.grains == 0 + points_left = grains == 0 + coords_buffer = np.zeros((points_left.size, 2), dtype=np.intp) total_points = points_left.sum() found_point = 0 next_point = points_left.tobytes().find(b'\x01') # Start counter for grains - grainIndex = 1 - + grain_index = 1 # Loop until all points (except boundaries) have been assigned # to a grain or ignored i = 0 while found_point >= 0: # Flood fill first unknown point and return grain object - idx = np.unravel_index(next_point, self.grains.shape) - currentGrain = self.floodFill(idx[1], idx[0], grainIndex, - points_left) + seed = np.unravel_index(next_point, self.shape) + + grain = Grain(grain_index - 1, self, group_id) + grain.data.point = flood_fill_dic( + (seed[1], seed[0]), grain_index, points_left, + grains, coords_buffer + ) + coords_buffer = coords_buffer[len(grain.data.point):] - if len(currentGrain) < minGrainSize: + if len(grain) < min_grain_size: # if grain size less than minimum, ignore grain and set # values in grain map to -2 - for coord in currentGrain.coordList: - self.grains[coord[1], coord[0]] = -2 + for point in grain.data.point: + grains[point[1], point[0]] = -2 else: # add grain to list and increment grain index - self.grainList.append(currentGrain) - grainIndex += 1 + grain_list.append(grain) + grain_index += 1 # find next search point points_left_sub = points_left.reshape(-1)[next_point + 1:] @@ -922,113 +670,55 @@ def findGrains(self, algorithm=None, minGrainSize=10): # Now link grains to those in ebsd Map # Warp DIC grain map to EBSD frame - dicGrains = self.grains - warpedDicGrains = tf.warp( - np.ascontiguousarray(dicGrains.astype(float)), - self.ebsdTransformInv, - output_shape=(self.ebsdMap.yDim, self.ebsdMap.xDim), - order=0 + warped_dic_grains = self.experiment.warp_image( + grains.astype(float), self.frame, self.ebsd_map.frame, + output_shape=self.ebsd_map.shape, order=0 ).astype(int) - - # Initialise list to store ID of corresponding grain in EBSD map. - # Also stored in grain objects - self.ebsdGrainIds = [] - - for i in range(len(self)): + for i, grain in enumerate(grain_list): # Find grain by masking the native ebsd grain image with # selected grain from the warped dic grain image. The modal # value is the EBSD grain label. - modeId, _ = mode(self.ebsdMap.grains[warpedDicGrains == i + 1], keepdims=False) - ebsd_grain_idx = modeId - 1 - self.ebsdGrainIds.append(ebsd_grain_idx) - self[i].ebsdGrainId = ebsd_grain_idx - self[i].ebsdGrain = self.ebsdMap[ebsd_grain_idx] - self[i].ebsdMap = self.ebsdMap + mode_id, _ = mode( + self.ebsd_map.data.grains[warped_dic_grains == i+1], + keepdims=False + ) + grain.ebsd_grain = self.ebsd_map[mode_id - 1] + grain.ebsd_map = self.ebsd_map else: raise ValueError(f"Unknown grain finding algorithm '{algorithm}'.") - def floodFill(self, x, y, grainIndex, points_left): - """Flood fill algorithm that uses the combined x and y boundary array - to fill a connected area around the seed point. The points are inserted - into a grain object and the grain map array is updated. - - Parameters - ---------- - x : int - Seed point x for flood fill - y : int - Seed point y for flood fill - grainIndex : int - Value to fill in grain map - points_left : numpy.ndarray - Boolean map of the points that have not been assigned a grain yet + ## TODO: this will get duplicated if find grains called again + self.data.add_derivative( + grain_list[0].data, self.grain_data_to_map, pass_ref=True, + in_props={ + 'type': 'list' + }, + out_props={ + 'type': 'map' + } + ) - Returns - ------- - currentGrain : defdap.hrdic.Grain - New grain object with points added + self._grains = grain_list + return grains - """ - # create new grain - currentGrain = Grain(grainIndex - 1, self) - - # add first point to the grain - currentGrain.addPoint((x, y), self.eMaxShear[y + self.cropDists[1, 0], - x + self.cropDists[0, 0]]) - self.grains[y, x] = grainIndex - points_left[y, x] = False - edge = [(x, y)] - - while edge: - x, y = edge.pop(0) - - moves = [(x+1, y), (x-1, y), (x, y+1), (x, y-1)] - # get rid of any that go out of the map area - if x <= 0: - moves.pop(1) - elif x >= self.xDim - 1: - moves.pop(0) - if y <= 0: - moves.pop(-1) - elif y >= self.yDim - 1: - moves.pop(-2) - - for (s, t) in moves: - addPoint = False - - if self.grains[t, s] == 0: - addPoint = True - edge.append((s, t)) - - elif self.grains[t, s] == -1 and (s > x or t > y): - addPoint = True - - if addPoint: - currentGrain.addPoint( - (s, t), - self.eMaxShear[t + self.cropDists[1, 0], - s + self.cropDists[0, 0]] - ) - self.grains[t, s] = grainIndex - points_left[t, s] = False - - return currentGrain - - def runGrainInspector(self, vmax=0.1, corrAngle=0): + def grain_inspector(self, vmax=0.1, correction_angle=0, rdr_line_length=3): """Run the grain inspector interactive tool. Parameters ---------- vmax : float Maximum value of the colour map. - corrAngle: float + correction_angle: float Correction angle in degrees to subtract from measured angles to account for small rotation between DIC and EBSD frames. Approximately the rotation component of affine transform. + rdr_line_length: int + Length of lines perpendicular to slip trace used to calculate RDR. """ - GrainInspector(currMap=self, vmax=vmax, corrAngle=corrAngle) + GrainInspector(selected_dic_map=self, vmax=vmax, correction_angle=correction_angle, + rdr_line_length=rdr_line_length) class Grain(base.Grain): @@ -1044,67 +734,44 @@ class Grain(base.Grain): DIC map this grain is a member of maxShearList : list List of maximum shear values for grain. - ebsdGrain : defdap.ebsd.Grain + ebsd_grain : defdap.ebsd.Grain EBSD grain ID that this DIC grain corresponds to. - ebsdMap : defdap.ebsd.Map + ebsd_map : defdap.ebsd.Map EBSD map that this DIC grain belongs to. - pointsList : numpy.ndarray + points_list : numpy.ndarray Start and end points for lines drawn using defdap.inspector.GrainInspector. - groupsList : + groups_list : Groups, angles and slip systems detected for lines drawn using defdap.inspector.GrainInspector. + data : defdap.utils.Datastore + Must contain after creating: + point : list of tuples + (x, y) in cropped map + Generated data: + + Derived data: + Map data to list data from the map the grain is part of + """ - def __init__(self, grainID, dicMap): + def __init__(self, grain_id, dicMap, group_id): # Call base class constructor - super(Grain, self).__init__(grainID, dicMap) + super(Grain, self).__init__(grain_id, dicMap, group_id) - self.dicMap = self.ownerMap # DIC map this grain is a member of - self.maxShearList = [] - self.ebsdGrain = None - self.ebsdMap = None + self.dic_map = self.owner_map # DIC map this grain is a member of + self.ebsd_grain = None + self.ebsd_map = None - self.pointsList = [] # Lines drawn for STA - self.groupsList = [] # Unique angles drawn for STA + self.points_list = [] # Lines drawn for STA + self.groups_list = [] # Unique angles drawn for STA - @property - def plotDefault(self): - return lambda *args, **kwargs: self.plotMaxShear( - plotColourBar=True, plotScaleBar=True, plotSlipTraces=True, - plotSlipBands=True, *args, **kwargs + self.plot_default = lambda *args, **kwargs: self.plot_map( + 'max_shear', plot_colour_bar=True, plot_scale_bar=True, + plot_slip_traces=True, plot_slip_bands=True, *args, **kwargs ) - # coord is a tuple (x, y) - def addPoint(self, coord, maxShear): - self.coordList.append(coord) - self.maxShearList.append(maxShear) - - def plotMaxShear(self, **kwargs): - """Plot a maximum shear map for a grain. - - Parameters - ---------- - kwargs - All arguments are passed to :func:`defdap.base.plotGrainData`. - - Returns - ------- - defdap.plotting.GrainPlot - - """ - # Set default plot parameters then update with any input - plotParams = { - 'plotColourBar': True, - 'clabel': "Effective shear strain" - } - plotParams.update(kwargs) - - plot = self.plotGrainData(grainData=self.maxShearList, **plotParams) - - return plot - @property - def refOri(self): + def ref_ori(self): """Returns average grain orientation. Returns @@ -1112,10 +779,10 @@ def refOri(self): defdap.quat.Quat """ - return self.ebsdGrain.refOri + return self.ebsd_grain.ref_ori @property - def slipTraces(self): + def slip_traces(self): """Returns list of slip trace angles based on EBSD grain orientation. Returns @@ -1123,24 +790,24 @@ def slipTraces(self): list """ - return self.ebsdGrain.slipTraces + return self.ebsd_grain.slip_traces - def calcSlipTraces(self, slipSystems=None): + def calc_slip_traces(self, slip_systems=None): """Calculates list of slip trace angles based on EBSD grain orientation. Parameters ------- - slipSystems : defdap.crystal.SlipSystem, optional + slip_systems : defdap.crystal.SlipSystem, optional """ - self.ebsdGrain.calcSlipTraces(slipSystems=slipSystems) + self.ebsd_grain.calc_slip_traces(slip_systems=slip_systems) - def calcSlipBands(self, grainMapData, thres=None, min_dist=None): + def calc_slip_bands(self, grain_map_data, thres=None, min_dist=None): """Use Radon transform to detect slip band angles. Parameters ---------- - grainMapData : numpy.ndarray + grain_map_data : numpy.ndarray Data to find bands in. thres : float, optional Normalised threshold for peaks. @@ -1157,35 +824,71 @@ def calcSlipBands(self, grainMapData, thres=None, min_dist=None): thres = 0.3 if min_dist is None: min_dist = 30 - grainMapData = np.nan_to_num(grainMapData) + grain_map_data = np.nan_to_num(grain_map_data) - if grainMapData.min() < 0: + if grain_map_data.min() < 0: print("Negative values in data, taking absolute value.") - # grainMapData = grainMapData**2 - grainMapData = np.abs(grainMapData) - suppGMD = np.zeros(grainMapData.shape) #array to hold shape / support of grain - suppGMD[grainMapData!=0]=1 - sin_map = tf.radon(grainMapData, circle=False) + # grain_map_data = grain_map_data**2 + grain_map_data = np.abs(grain_map_data) + # array to hold shape / support of grain + supp_gmd = np.zeros(grain_map_data.shape) + supp_gmd[grain_map_data != 0]=1 + sin_map = tf.radon(grain_map_data, circle=False) #profile = np.max(sin_map, axis=0) # old method - supp_map = tf.radon(suppGMD, circle=False) + supp_map = tf.radon(supp_gmd, circle=False) supp_1 = np.zeros(supp_map.shape) supp_1[supp_map>0]=1 - mindiam = np.min(np.sum(supp_1, axis=0), axis=0) # minimum diameter of grain + # minimum diameter of grain + mindiam = np.min(np.sum(supp_1, axis=0), axis=0) crop_map = np.zeros(sin_map.shape) - # only consider radon rays that cut grain with mindiam*2/3 or more, and scale by length of the cut - crop_map[supp_map>mindiam*2/3] = sin_map[supp_map>mindiam*2/3]/supp_map[supp_map>mindiam*2/3] + # only consider radon rays that cut grain with mindiam*2/3 or more, + # and scale by length of the cut + selection = supp_map > mindiam * 2 / 3 + crop_map[selection] = sin_map[selection] / supp_map[selection] supp_crop = np.zeros(crop_map.shape) supp_crop[crop_map>0] = 1 - profile = np.sum(crop_map**4, axis=0) / np.sum(supp_crop, axis=0) # raise to power to accentuate local peaks + + # raise to power to accentuate local peaks + profile = np.sum(crop_map**4, axis=0) / np.sum(supp_crop, axis=0) x = np.arange(180) - # indexes = peakutils.indexes(profile, thres=thres, min_dist=min_dist, thres_abs=False) indexes = peakutils.indexes(profile, thres=thres, min_dist=min_dist) peaks = x[indexes] # peaks = peakutils.interpolate(x, profile, ind=indexes) print("Number of bands detected: {:}".format(len(peaks))) - slipBandAngles = peaks - slipBandAngles = slipBandAngles * np.pi / 180 - return slipBandAngles + slip_band_angles = peaks + slip_band_angles = slip_band_angles * np.pi / 180 + return slip_band_angles + + +class BoundarySet(object): + def __init__(self, dic_map, points, lines): + self.dic_map = dic_map + self.points = set(points) + self.lines = lines + + @classmethod + def from_ebsd_boundaries(cls, dic_map, ebsd_boundaries): + if len(ebsd_boundaries.points) == 0: + return cls(dic_map, [], []) + + points = dic_map.experiment.warp_points( + ebsd_boundaries.image.astype(float), + dic_map.ebsd_map.frame, dic_map.frame, + output_shape=dic_map.shape + ) + lines = dic_map.experiment.warp_lines( + ebsd_boundaries.lines, dic_map.ebsd_map.frame, dic_map.frame + ) + return cls(dic_map, points, lines) + + def _image(self, points): + image = np.zeros(self.dic_map.shape, dtype=bool) + image[tuple(zip(*points))[::-1]] = True + return image + + @property + def image(self): + return self._image(self.points) diff --git a/defdap/inspector.py b/defdap/inspector.py index 3377890..2acdeb3 100644 --- a/defdap/inspector.py +++ b/defdap/inspector.py @@ -1,4 +1,4 @@ -# Copyright 2021 Mechanics of Microstructures Group +# Copyright 2025 Mechanics of Microstructures Group # at The University of Manchester # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -14,17 +14,16 @@ # limitations under the License. import numpy as np - -import ast - -from typing import List - from scipy.stats import linregress +from skimage.draw import line as skimage_line +import ast import pandas as pd from defdap.plotting import Plot, GrainPlot from defdap import hrdic +from typing import List + class GrainInspector: """ @@ -32,74 +31,92 @@ class GrainInspector: and relative displacement ratio analysis. """ - def __init__(self, - currMap: 'hrdic.Map', - vmax: float, - corrAngle: float): - # Initialise some values - self.grainID = 0 - self.currMap = currMap - self.currEBSDMap = self.currMap.ebsdMap - self.currDICGrain = self.currMap[self.grainID] - self.currEBSDGrain = self.currDICGrain.ebsdGrain - self.vmax = vmax - self.corrAngle = corrAngle - self.filename = str(self.currMap.retrieveName()) + '_RDR.txt' - - # Draw the figure - self.draw() - def draw(self): - """ Draw the main window, buttons, text boxes and axes. + def __init__(self, + selected_dic_map: 'hrdic.Map', + vmax: float, + correction_angle: float = 0, + rdr_line_length: int = 3): + """ + Parameters + ---------- + selected_dic_map + DIC map to run grain inspector on. + vmax + Maximum effective shear strain in colour scale. + correction_angle + Angle (in degrees) to subtract from drawn line angle. + rdr_line_length + Length on lines perpendicular to slip trace (can be any odd number above default 3). """ + # Initialise some values + self.grain_id = 0 + self.selected_dic_map = selected_dic_map + self.selected_ebsd_map = self.selected_dic_map.ebsd_map + self.selected_dic_grain = self.selected_dic_map[self.grain_id] + self.selected_ebsd_grain = self.selected_dic_grain.ebsd_grain + self.vmax = vmax + self.correction_angle = correction_angle + self.rdr_line_length = rdr_line_length + self.filename = str(self.selected_dic_map.retrieve_name()) + '_RDR.txt' + # Plot window - self.plot = Plot(ax=None, makeInteractive=True, figsize=(14,8), title='Grain Inspector') - - ######## Buttons - self.plot.addButton( - 'Save\nLine', self.saveLine, (0.73, 0.48, 0.05, 0.04)) - self.plot.addButton( - 'Previous\nGrain', lambda e, p: self.gotoGrain(self.grainID-1, p), (0.73, 0.94, 0.05, 0.04)) - self.plot.addButton( - 'Next\nGrain', lambda e, p: self.gotoGrain(self.grainID+1, p), (0.79, 0.94, 0.05, 0.04)) - self.plot.addButton( - 'Run\nAll STA', self.batchRunSTA, (0.85, 0.07, 0.11, 0.04)) - self.plot.addButton( - 'Clear\nAll Lines', self.clearAllLines, (0.89, 0.48, 0.05, 0.04)) - self.plot.addButton( - 'Load\nFile', self.loadFile, (0.85, 0.02, 0.05, 0.04)) - self.plot.addButton( - 'Save\nFile', self.saveFile, (0.91, 0.02, 0.05, 0.04)) - + self.plot = Plot(ax=None, make_interactive=True, figsize=(13, 8), title='Grain Inspector') + div_frac = 0.7 + + # Remove key bindings for figure to suppress errors + self.plot.fig.canvas.mpl_disconnect(self.plot.fig.canvas.manager.key_press_handler_id) + + # Buttons + self.plot.add_button( + 'Save\nLine', self.save_line, (div_frac, 0.48, 0.05, 0.04)) + self.plot.add_button( + 'Previous\nGrain', lambda e, p: self.goto_grain(self.grain_id - 1, p), (div_frac, 0.94, 0.05, 0.04)) + self.plot.add_button( + 'Next\nGrain', lambda e, p: self.goto_grain(self.grain_id + 1, p), (div_frac + 0.06, 0.94, 0.05, 0.04)) + self.plot.add_button( + 'Run All STA', self.batch_run_sta, (0.85, 0.07, 0.11, 0.04)) + self.plot.add_button( + 'Clear\nAll Lines', self.clear_all_lines, (div_frac + 0.2, 0.48, 0.05, 0.04)) + self.plot.add_button( + 'Load\nFile', self.load_file, (0.85, 0.02, 0.05, 0.04)) + self.plot.add_button( + 'Save\nFile', self.save_file, (0.91, 0.02, 0.05, 0.04)) # Text boxes - self.plot.addTextBox(label='', loc=(0.7, 0.02, 0.13, 0.04), - changeHandler=self.updateFilename, initial = self.filename) - self.plot.addTextBox(label='Go to \ngrain ID:', loc=(0.9, 0.94, 0.05, 0.04), - submitHandler=self.gotoGrain) - self.plot.addTextBox(label='Remove\nID:', loc=(0.83, 0.48, 0.05, 0.04), - submitHandler=self.removeLine) - self.RDRGroupBox = self.plot.addTextBox(label='Run RDR only\non group:', loc=(0.78, 0.07, 0.05, 0.04), - submitHandler=self.runRDRGroup) + self.plot.add_text_box(label='', loc=(0.7, 0.02, 0.13, 0.04), + change_handler=self.update_filename, initial=self.filename) + self.plot.add_text_box(label='Go to \ngrain ID:', loc=(div_frac + 0.17, 0.94, 0.05, 0.04), + submit_handler=self.goto_grain) + self.plot.add_text_box(label='Remove\nID:', loc=(div_frac + 0.1, 0.48, 0.05, 0.04), + submit_handler=self.remove_line) + self.rdr_group_text_box = self.plot.add_text_box(label='Run RDR only\non group:', loc=(0.78, 0.07, 0.05, 0.04), + submit_handler=self.run_rdr_group) # Axes - self.maxShearAx = self.plot.addAxes((0.05, 0.4, 0.65, 0.55)) - self.slipTraceAx = self.plot.addAxes((0.2, 0.05, 0.6, 0.3)) - self.unitCellAx = self.plot.addAxes((0.05, 0.055, 0.15, 0.3), proj='3d') - self.grainInfoAx = self.plot.addAxes((0.73, 0.86, 0.25, 0.06)) - self.lineInfoAx = self.plot.addAxes((0.73, 0.55, 0.25, 0.3)) - self.groupsInfoAx = self.plot.addAxes((0.73, 0.15, 0.25, 0.3)) - self.grainPlot = self.currMap[self.grainID].plotMaxShear(fig=self.plot.fig, ax=self.maxShearAx, - vmax=self.vmax, plotScaleBar=True, plotColourBar=True) + self.max_shear_axis = self.plot.add_axes((0.05, 0.4, 0.65, 0.55)) + self.slip_trace_axis = self.plot.add_axes((0.25, 0.05, 0.5, 0.3)) + self.unit_cell_axis = self.plot.add_axes((0.05, 0.055, 0.2, 0.3), proj='3d') + self.grain_info_axis = self.plot.add_axes((div_frac, 0.86, 0.25, 0.06)) + self.line_info_axis = self.plot.add_axes((div_frac, 0.55, 0.25, 0.3)) + self.groups_info_axis = self.plot.add_axes((div_frac, 0.15, 0.25, 0.3)) + self.grain_plot = self.selected_dic_map[self.grain_id].plot_map( + 'max_shear', + fig=self.plot.fig, + ax=self.max_shear_axis, + vmax=self.vmax, + plot_scale_bar=True, + plot_colour_bar=True + ) self.plot.ax.axis('off') - - # Draw the stuff that will need to be redrawn often in a seperate function + + # Draw the stuff that will need to be redrawn often in a separate function self.redraw() - def gotoGrain(self, - event: int, - plot): + def goto_grain(self, + event: int, + plot): """ Go to a specified grain ID. Parameters @@ -108,16 +125,16 @@ def gotoGrain(self, Grain ID to go to. """ - ## Go to grain ID specified in event - self.grainID=int(event) - self.grainPlot.arrow=None - self.currDICGrain = self.currMap[self.grainID] - self.currEBSDGrain = self.currDICGrain.ebsdGrain + # Go to grain ID specified in event + self.grain_id = int(event) + self.grain_plot.arrow = None + self.selected_dic_grain = self.selected_dic_map[self.grain_id] + self.selected_ebsd_grain = self.selected_dic_grain.ebsd_grain self.redraw() - def saveLine(self, - event: np.ndarray, - plot): + def save_line(self, + event: np.ndarray, + plot): """ Save the start point, end point and angle of drawn line into the grain. Parameters @@ -128,31 +145,33 @@ def saveLine(self, """ # Get angle of lines - lineAngle = 90-np.rad2deg(np.arctan2(self.grainPlot.p2[1]-self.grainPlot.p1[1], - self.grainPlot.p2[0]-self.grainPlot.p1[0])) - if lineAngle > 180: lineAngle -= 180 - elif lineAngle < 0: lineAngle += 180 - - lineAngle -= self.corrAngle + line_angle = 90 - np.rad2deg(np.arctan2(self.grain_plot.p2[1] - self.grain_plot.p1[1], + self.grain_plot.p2[0] - self.grain_plot.p1[0])) + if line_angle > 180: + line_angle -= 180 + elif line_angle < 0: + line_angle += 180 + + line_angle -= self.correction_angle # Two decimal places - points = [float("{:.2f}".format(point)) for point in self.grainPlot.p1+self.grainPlot.p2] - lineAngle = float("{:.2f}".format(lineAngle)) + points = [float("{:.2f}".format(point)) for point in self.grain_plot.p1 + self.grain_plot.p2] + line_angle = float("{:.2f}".format(line_angle)) # Save drawn line to the DIC grain - self.currDICGrain.pointsList.append([points, lineAngle, -1]) - + self.selected_dic_grain.points_list.append([points, line_angle, -1]) + # Group lines and redraw - self.groupLines() - self.redrawLine() - - def groupLines(self, - grain: 'defdap.hrdic.Grain'=None): + self.group_lines() + self.redraw_line() + + def group_lines(self, + grain: 'defdap.hrdic.Grain' = None): """ Group the lines drawn in the current grain item using a mean shift algorithm, save the average angle and then detect the active slip planes. - groupsList is a list of line groups: [id, angle, [slip plane id], [angular deviation] + groups_list is a list of line groups: [id, angle, [slip plane id], [angular deviation] Parameters ---------- @@ -161,57 +180,58 @@ def groupLines(self, """ - if grain == None: - grain = self.currDICGrain + if grain is None: + grain = self.selected_dic_grain - if grain.pointsList == []: - grain.groupsList = [] + if grain.points_list == []: + grain.groups_list = [] else: - for i, line in enumerate(grain.pointsList): + for i, line in enumerate(grain.points_list): angle = line[1] - if i == 0: - line[2]=0 # Make group 0 for first detected angle - grain.groupsList = [[0, angle, 0, 0, 0]] - nextGroup=1 - else: # If there is more that one angle - if np.any(np.abs(np.array([x[1] for x in grain.groupsList])-angle)<10): - # If within +- 5 degrees of exisitng group, set that as the group - group = np.argmin(np.abs(np.array([x[1] for x in grain.groupsList])-angle)) - grain.pointsList[i][2]=group - newAv = float('{0:.2f}'.format(np.average([x[1] for x in grain.pointsList if x[2]==group]))) - grain.groupsList[group][1] = newAv + if i == 0: + line[2] = 0 # Make group 0 for first detected angle + grain.groups_list = [[0, angle, 0, 0, 0]] + next_group = 1 + else: # If there is more that one angle + if np.any(np.abs(np.array([x[1] for x in grain.groups_list]) - angle) < 10): + # If within +- 5 degrees of existing group, set that as the group + group = np.argmin(np.abs(np.array([x[1] for x in grain.groups_list]) - angle)) + grain.points_list[i][2] = group + new_average = float('{0:.2f}'.format( + np.average([x[1] for x in grain.points_list if x[2] == group]))) + grain.groups_list[group][1] = new_average else: # Make new group and set - grain.groupsList.append([nextGroup, angle, 0, 0, 0]) - line[2]=nextGroup - nextGroup += 1 - + grain.groups_list.append([next_group, angle, 0, 0, 0]) + line[2] = next_group + next_group += 1 + # Detect active slip systems in each group - for group in grain.groupsList: - activePlanes = [] + for group in grain.groups_list: + active_planes = [] deviation = [] - experimentalAngle = group[1] - for idx, theoreticalAngle in enumerate(np.rad2deg(grain.ebsdGrain.slipTraceAngles)): - if theoreticalAngle-5 < experimentalAngle < theoreticalAngle+5: - activePlanes.append(idx) - deviation.append(float('{0:.2f}'.format(experimentalAngle-theoreticalAngle))) - group[2] = activePlanes + experimental_angle = group[1] + for idx, theoretical_angle in enumerate(np.rad2deg(grain.ebsd_grain.slip_trace_angles)): + if theoretical_angle - 5 < experimental_angle < theoretical_angle + 5: + active_planes.append(idx) + deviation.append(float('{0:.2f}'.format(experimental_angle - theoretical_angle))) + group[2] = active_planes group[3] = deviation - - def clearAllLines(self, - event, - plot): + + def clear_all_lines(self, + event, + plot): """ Clear all lines in a given grain. """ - self.currDICGrain.pointsList = [] - self.currDICGrain.groupsList = [] + self.selected_dic_grain.points_list = [] + self.selected_dic_grain.groups_list = [] self.redraw() - def removeLine(self, - event: int, - plot): + def remove_line(self, + event: int, + plot): """ Remove single line [runs after submitting a text box]. Parameters @@ -220,9 +240,9 @@ def removeLine(self, Line ID to remove. """ - ## Remove single line - del self.currDICGrain.pointsList[int(event)] - self.groupLines() + # Remove single line + del self.selected_dic_grain.points_list[int(event)] + self.group_lines() self.redraw() def redraw(self): @@ -231,74 +251,91 @@ def redraw(self): """ # Plot max shear for grain - self.maxShearAx.clear() - self.grainPlot = self.currMap[self.grainID].plotMaxShear( - fig=self.plot.fig, ax=self.maxShearAx, vmax=self.vmax, plotColourBar=False, plotScaleBar=True) - + self.max_shear_axis.clear() + self.grain_plot = self.selected_dic_map[self.grain_id].plot_map( + 'max_shear', fig=self.plot.fig, ax=self.max_shear_axis, + vmax=self.vmax, plot_colour_bar=False, plot_scale_bar=True + ) + # Draw unit cell - self.unitCellAx.clear() - self.currEBSDGrain.plotUnitCell(fig=self.plot.fig, ax=self.unitCellAx) - + self.unit_cell_axis.clear() + self.selected_ebsd_grain.plot_unit_cell(fig=self.plot.fig, ax=self.unit_cell_axis) + # Write grain info text - self.grainInfoAx.clear() - self.grainInfoAx.axis('off') - grainInfoText = 'Grain ID: {0} / {1}\n'.format(self.grainID, len(self.currMap.grainList)-1) - grainInfoText += 'Min: {0:.1f} % Mean:{1:.1f} % Max: {2:.1f} %'.format( - np.min(self.currDICGrain.maxShearList)*100, - np.mean(self.currDICGrain.maxShearList)*100, - np.max(self.currDICGrain.maxShearList)*100) - self.plot.addText(self.grainInfoAx, 0, 1, grainInfoText, va='top', ha='left', fontsize=10) - + self.grain_info_axis.clear() + self.grain_info_axis.axis('off') + grain_info_text = 'Grain ID: {0} / {1}\n'.format(self.grain_id, len(self.selected_dic_map.grains) - 1) + grain_info_text += 'Min: {0:.2f} % Mean:{1:.2f} % Max: {2:.2f} %'.format( + np.min(self.selected_dic_grain.data.max_shear) * 100, + np.mean(self.selected_dic_grain.data.max_shear) * 100, + np.max(self.selected_dic_grain.data.max_shear) * 100) + self.plot.add_text(self.grain_info_axis, 0, 1, grain_info_text, va='top', ha='left', + fontsize=10, fontfamily='monospace') + # Detect lines - self.plot.addEventHandler('button_press_event',lambda e, p: self.grainPlot.lineSlice(e, p)) - self.plot.addEventHandler('button_release_event', lambda e, p: self.grainPlot.lineSlice(e, p)) + self.plot.add_event_handler('button_press_event', lambda e, p: self.grain_plot.line_slice(e, p)) + self.plot.add_event_handler('button_release_event', lambda e, p: self.grain_plot.line_slice(e, p)) - self.redrawLine() + self.redraw_line() - def redrawLine(self): + def redraw_line(self): """ Draw items which need to be redrawn when adding a line. """ # Write lines text and draw lines - linesTxt = 'List of lines\n\nLineID x0 y0 x1 y1 Angle Group\n' - - if self.currDICGrain.pointsList != []: - for idx, points in enumerate(self.currDICGrain.pointsList): - linesTxt += '{0} {1:.1f} {2:.1f} {3:.1f} {4:.1f} {5:.1f} {6}\n'.format(idx, - points[0][0],points[0][1],points[0][2],points[0][3],points[1],points[2]) - self.grainPlot.addArrow(startEnd=points[0], clearPrev=False, persistent=True, label=idx) - - self.lineInfoAx.clear() - self.lineInfoAx.axis('off') - self.plot.addText(self.lineInfoAx, 0, 1, linesTxt, va='top', fontsize=10) + title_text = 'List of lines' + lines_text = 'ID x0 y0 x1 y1 Angle Group\n' \ + '-----------------------------------------\n' + if self.selected_dic_grain.points_list: + for idx, points in enumerate(self.selected_dic_grain.points_list): + lines_text += '{0:<3} {1:<5.0f} {2:<5.0f} {3:<5.0f} {4:<5.0f} {5:<7.1f} {6:<5}\n'.format( + idx, *points[0], points[1], points[2]) + self.grain_plot.add_arrow(start_end=points[0], clear_previous=False, persistent=True, label=idx) + + self.line_info_axis.clear() + self.line_info_axis.axis('off') + self.plot.add_text(self.line_info_axis, 0, 1, title_text, va='top', + fontsize=10, fontfamily='monospace', weight='bold') + self.plot.add_text(self.line_info_axis, 0, 0.9, lines_text, va='top', + fontsize=10, fontfamily='monospace') # Write groups info text - groupsTxt = 'List of groups\n\nGroupID Angle System Dev RDR\n' - if self.currDICGrain.groupsList != []: - for idx, group in enumerate(self.currDICGrain.groupsList): - groupsTxt += '{0} {1:.1f} {2} {3} {4:.2f}\n'.format( - idx, group[1], group[2], np.round(group[3], 3), group[4]) - - self.groupsInfoAx.clear() - self.groupsInfoAx.axis('off') - self.plot.addText(self.groupsInfoAx, 0, 1, groupsTxt, va='top', fontsize=10) + title_text = 'List of groups' + + groupsTxt = 'ID Av. Angle System Dev RDR\n' \ + '----------------------------------------\n' + if self.selected_dic_grain.groups_list: + for idx, group in enumerate(self.selected_dic_grain.groups_list): + groupsTxt += '{0:<3} {1:<10.1f} {2:<7} {3:<12} {4:.2f}\n'.format( + idx, + group[1], + ','.join([str(np.round(i, 1)) for i in group[2]]), + ','.join([str(np.round(i, 1)) for i in group[3]]), + group[4]) + + self.groups_info_axis.clear() + self.groups_info_axis.axis('off') + self.plot.add_text(self.groups_info_axis, 0, 1, title_text, va='top', fontsize=10, fontfamily='monospace', + weight='bold') + self.plot.add_text(self.groups_info_axis, 0, 0.9, groupsTxt, va='top', fontsize=10, fontfamily='monospace') # Draw slip traces - self.slipTraceAx.clear() - self.slipTraceAx.set_aspect('equal', 'box') - slipPlot = GrainPlot(fig=self.plot.fig, callingGrain=self.currMap[self.grainID], ax=self.slipTraceAx) - traces = slipPlot.addSlipTraces(topOnly=True) - self.slipTraceAx.axis('off') + self.slip_trace_axis.clear() + self.slip_trace_axis.set_aspect('equal', 'box') + slipPlot = GrainPlot(fig=self.plot.fig, + calling_grain=self.selected_dic_map[self.grain_id], ax=self.slip_trace_axis) + traces = slipPlot.add_slip_traces(top_only=True) + self.slip_trace_axis.axis('off') # Draw slip bands - bands = [elem[1] for elem in self.currDICGrain.groupsList] - if self.currDICGrain.groupsList != None: - slipPlot.addSlipBands(topOnly=True, angles=list(np.deg2rad(bands))) + bands = [elem[1] for elem in self.selected_dic_grain.groups_list] + if self.selected_dic_grain.groups_list != None: + slipPlot.add_slip_bands(top_only=True, angles=list(np.deg2rad(bands))) - def runRDRGroup(self, - event: int, - plot): + def run_rdr_group(self, + event: int, + plot): """ Run RDR on a specified group, upon submitting a text box. Parameters @@ -307,128 +344,107 @@ def runRDRGroup(self, Group ID specified from text box. """ - ## Run RDR for group of lines + # Run RDR for group of lines if event != '': - self.calcRDR(grain = self.currDICGrain, group=int(event)) - self.RDRGroupBox.set_val('') - - def batchRunSTA(self, - event, - plot): + self.calc_rdr(grain=self.selected_dic_grain, group=int(event)) + self.rdr_group_text_box.set_val('') + + def batch_run_sta(self, + event, + plot): """ Run slip trace analysis on all grains which hve slip trace lines drawn. """ # Print header - print("Grain\tEul1\tEul2\tEul3\tMaxSF\tGroup\tAngle\tSystem\tDev\RDR") - + print("Grain\tEul1\tEul2\tEul3\tMaxSF\tGroup\tAngle\tSystem\tDev\tRDR") + # Print information for each grain - for idx, grain in enumerate(self.currMap): - if grain.pointsList != []: - for group in grain.groupsList: - maxSF = np.max([item for sublist in grain.ebsdGrain.averageSchmidFactors for item in sublist]) - eulers = self.currEBSDGrain.refOri.eulerAngles()*180/np.pi + for idx, grain in enumerate(self.selected_dic_map): + if grain.points_list != []: + for group in grain.groups_list: + maxSF = np.max([item for sublist in grain.ebsd_grain.average_schmid_factors for item in sublist]) + eulers = self.selected_ebsd_grain.ref_ori.euler_angles() * 180 / np.pi text = '{0}\t{1:.1f}\t{2:.1f}\t{3:.1f}\t{4:.3f}\t'.format( - idx, eulers[0], eulers[1], eulers[2], maxSF) + idx, eulers[0], eulers[1], eulers[2], maxSF) text += '{0}\t{1:.1f}\t{2}\t{3}\t{4:.2f}'.format( - group[0], group[1], group[2], np.round(group[3],3), group[4]) + group[0], group[1], group[2], np.round(group[3], 3), group[4]) print(text) - def calcRDR(self, - grain: int, - group: int, - showPlot: bool = True, - length: float = 2.5): + def calc_rdr(self, + grain, + group: int, + show_plot: bool = True): """ Calculates the relative displacement ratio for a given grain and group. Parameters ---------- grain - DIC grain ID to run RDR on. + DIC grain to run RDR on. group group ID to run RDR on. - showPlot + show_plot if True, show plot window. - length - length of perpendicular lines used for RDR. """ - - ulist=[]; vlist=[]; allxlist = []; allylist = []; + + u_list, v_list, x_list, y_list = [], [], [], [] # Get all lines belonging to group - points = [] - for point in grain.pointsList: - if point[2] == group: - points.append(point[0]) + point_array = np.array(grain.points_list, dtype=object) + points = list(point_array[:, 0][point_array[:, 2] == group]) + angle = grain.groups_list[group][1] + + # Lookup deviation from (0,0) for 3 points along line perpendicular to slip line (x_new,y_new) + x_new = np.array([[-1, 0, 1], [1, 0, -1], [0, 0, 0], [1, 0, -1], [-1, 0, 1]])[int(np.round(angle / 45, 0))] + y_new = np.array([[0, 0, 0], [-1, 0, 1], [-1, 0, 1], [1, 0, -1], [0, 0, 0]])[int(np.round(angle / 45, 0))] + tuples = list(zip(x_new, y_new)) + # Allow increasing line length from default 3 to any odd number + num = np.arange(0, int((self.rdr_line_length - 1) / 2)) + 1 + coordinateOffsets = np.unique(np.array([np.array(tuples)*i for i in num]).reshape(-1, 2), axis=0) + + # For each slip trace line for point in points: - x0=point[0]; y0=point[1]; x1=point[2]; y1=point[3]; - grad = (y1-y0)/(x1-x0) - invgrad = -1/grad - profile_length = np.sqrt((y1-y0)**2+(x1-x0)**2) - num = np.round(profile_length*2) - - ### Calculate positions for each point along slip trace line (x,y) - x, y = np.round(np.linspace(x0, x1, int(num))), np.round(np.linspace(y0, y1, int(num))) - df = pd.DataFrame({'x':x, 'y':y}).drop_duplicates() - x,y = df['x'].values.tolist(),df['y'].values.tolist() - - ## Calculate deviation from (0,0) for points along line with angle perpendicular to slip line (xnew,ynew) - x0new = np.sqrt(length/(invgrad**2+1))*np.sign(grad) - y0new = -np.sqrt(length/(1/invgrad**2+1)) - x1new = -np.sqrt(length/(invgrad**2+1))*np.sign(grad) - y1new = np.sqrt(length/(1/invgrad**2+1)) - profile_length=np.sqrt((y1new-y0new)**2+(x1new-x0new)**2) - num = np.round(profile_length) - xnew, ynew = np.linspace(x0new, x1new, int(num)), np.linspace(y0new, y1new, int(num)) - xnew, ynew = np.around(xnew).astype(int), np.around(ynew).astype(int) - df = pd.DataFrame({'x':xnew, 'y':ynew}).drop_duplicates() - xnew,ynew = df['x'].values.tolist(), df['y'].values.tolist() - - for x,y in zip(x,y): - xperp = []; yperp = []; - for xdiff, ydiff in zip(xnew, ynew): - xperp.append(int(x+xdiff)) - yperp.append(int(y+ydiff)) - allxlist.append(xperp) - allylist.append(yperp) - - xmap = self.currDICGrain.extremeCoords[0] + xperp - ymap = self.currDICGrain.extremeCoords[1] + yperp - - ### For all points, append u and v to list - u = []; v = []; - for xmap, ymap in zip(xmap,ymap): - u.append((self.currMap.crop(self.currMap.x_map))[ymap, xmap]) - v.append((self.currMap.crop(self.currMap.y_map))[ymap, xmap]) - - ### Take away mean - u = u-np.mean(u); v = v-np.mean(v) - - ### Append to main lists (ulist,vlist) - ulist.extend(u) - vlist.extend(v) - - ### Linear regression of ucentered against vcentered - linRegResults = linregress(x=vlist,y=ulist) - - # Save measured RDR - grain.groupsList[group][4] = linRegResults.slope - + x0, y0, x1, y1 = point + + # Calculate positions for each pixel along slip trace line + x, y = skimage_line(int(x0), int(y0), int(x1), int(y1)) + + # Get x and y coordinates for points to be samples for RDR + xmap = np.array(x).T[:, None] + coordinateOffsets[:,0] + self.selected_dic_grain.extreme_coords[0] + ymap = np.array(y).T[:, None] + coordinateOffsets[:,1] + self.selected_dic_grain.extreme_coords[1] - if showPlot: self.plotRDR(grain, group, ulist, vlist, allxlist, allylist, linRegResults) + x_list.extend(xmap - self.selected_dic_grain.extreme_coords[0]) + y_list.extend(ymap - self.selected_dic_grain.extreme_coords[1]) - def plotRDR(self, - grain: int, - group: int, - ulist: List[float], - vlist: List[float], - allxlist: List[float], - allylist: List[float], - linRegResults): + # Get u and v values at each coordinate + u = self.selected_dic_map.crop(self.selected_dic_map.data.displacement[0])[ymap, xmap] + v = self.selected_dic_map.crop(self.selected_dic_map.data.displacement[1])[ymap, xmap] + + # Subtract mean u and v value for each row + u_list.extend(u - np.mean(u, axis=1)[:, None]) + v_list.extend(v - np.mean(v, axis=1)[:, None]) + + # Linear regression of ucentered against vcentered + lin_reg_result = linregress(x=np.array(v_list).flatten(), y=np.array(u_list).flatten()) + + # Save measured RDR + grain.groups_list[group][4] = lin_reg_result.slope + + if show_plot: + self.plot_rdr(grain, group, u_list, v_list, x_list, y_list, lin_reg_result) + + def plot_rdr(self, + grain, + group: int, + u_list: List[float], + v_list: List[float], + x_list: List[List[int]], + y_list: List[List[int]], + lin_reg_result: List): """ - Plot RDR figure, including location of perpendicular lines and scatter plot of ucentered vs vcentered. + Plot rdr figure, including location of perpendicular lines and scatter plot of ucentered vs vcentered. Parameters ---------- @@ -436,128 +452,156 @@ def plotRDR(self, DIC grain to plot. group Group ID to plot. - ulist + u_list List of ucentered values. - vlist + v_list List of vcentered values. - allxlist + x_list List of all x values. - allylist + y_list List of all y values. - linRegResults + lin_reg_result Results from linear regression of ucentered vs vcentered {slope, intercept, rvalue, pvalue, stderr}. """ # Draw window and axes - self.rdrPlot = Plot(ax=None, makeInteractive=True, title='RDR Calculation', figsize=(21, 7)) - self.rdrPlot.ax.axis('off') - self.rdrPlot.grainAx = self.rdrPlot.addAxes((0.05, 0.07, 0.20, 0.85)) - self.rdrPlot.textAx = self.rdrPlot.addAxes((0.27, 0.07, 0.20, 0.85)) - self.rdrPlot.textAx.axis('off') - self.rdrPlot.numLineAx = self.rdrPlot.addAxes((0.48, 0.07, 0.2, 0.85)) - self.rdrPlot.numLineAx.axis('off') - self.rdrPlot.plotAx = self.rdrPlot.addAxes((0.75, 0.07, 0.2, 0.85)) - - ## Draw grain plot - self.rdrPlot.grainPlot = self.currDICGrain.plotMaxShear(fig=self.rdrPlot.fig, ax=self.rdrPlot.grainAx, - plotColourBar=False, plotScaleBar = True) - self.rdrPlot.grainPlot.addColourBar(label='Effective Shear Strain', fraction=0.046, pad=0.04) - - ## Draw all points - self.rdrPlot.grainAx.plot(allxlist, allylist, 'rx',lw=0.5) - for xlist, ylist in zip(allxlist, allylist): - self.rdrPlot.grainAx.plot(xlist, ylist, '-',lw=1) - - ## Generate scatter plot - slope = linRegResults.slope - r_value = linRegResults.rvalue - intercept = linRegResults.intercept - std_err = linRegResults.stderr - - self.rdrPlot.plotAx.scatter(x=vlist,y=ulist,marker='x', lw=1) - self.rdrPlot.plotAx.plot( - [np.min(vlist), np.max(vlist)],[slope*np.min(vlist)+intercept,slope*np.max(vlist)+intercept], '-') - self.rdrPlot.plotAx.set_xlabel('v-centered') - self.rdrPlot.plotAx.set_ylabel('u-centered') - self.rdrPlot.addText(self.rdrPlot.plotAx, 0.95, 0.01, 'Slope = {0:.3f} ± {1:.3f}\nR-squared = {2:.3f}\nn={3}' - .format(slope,std_err,r_value**2,len(ulist)), va='bottom', ha='right', - transform=self.rdrPlot.plotAx.transAxes, fontsize=10); + self.rdr_plot = Plot(ax=None, make_interactive=True, title='RDR Calculation', figsize=(15, 8)) + self.rdr_plot.ax.axis('off') + self.rdr_plot.grain_axis = self.rdr_plot.add_axes((0.05, 0.5, 0.3, 0.45)) + self.rdr_plot.text_axis = self.rdr_plot.add_axes((0.37, 0.05, 0.3, 0.85)) + self.rdr_plot.text_axis.axis('off') + self.rdr_plot.number_line_axis = self.rdr_plot.add_axes((0.64, 0.05, 0.3, 0.83)) + self.rdr_plot.number_line_axis.axis('off') + self.rdr_plot.plot_axis = self.rdr_plot.add_axes((0.05, 0.1, 0.3, 0.35)) + + # Draw grain plot + self.rdr_plot.grainPlot = self.selected_dic_grain.plot_grain_data( + grain_data=self.selected_dic_grain.data.max_shear, + fig=self.rdr_plot.fig, + ax=self.rdr_plot.grain_axis, + plot_colour_bar=False, + plot_scale_bar=True) + + self.rdr_plot.grainPlot.add_colour_bar(label='Effective Shear Strain', fraction=0.046, pad=0.04) + + # Draw all points + self.rdr_plot.grain_axis.plot(x_list, y_list, 'rx', lw=0.5) + for xlist, ylist in zip(x_list, y_list): + self.rdr_plot.grain_axis.plot(xlist, ylist, '-', lw=1) + + # Generate scatter plot + slope = lin_reg_result.slope + r_value = lin_reg_result.rvalue + intercept = lin_reg_result.intercept + std_err = lin_reg_result.stderr + + self.rdr_plot.plot_axis.scatter(x=v_list, y=u_list, marker='x', lw=1) + self.rdr_plot.plot_axis.plot( + [np.min(v_list), np.max(v_list)], + [slope * np.min(v_list) + intercept, slope * np.max(v_list) + intercept], '-') + self.rdr_plot.plot_axis.set_xlabel('v-centered') + self.rdr_plot.plot_axis.set_ylabel('u-centered') + self.rdr_plot.add_text(self.rdr_plot.plot_axis, 0.95, 0.01, + 'Slope = {0:.3f} ± {1:.3f}\nR-squared = {2:.3f}\nn={3}' + .format(slope, std_err, r_value ** 2, len(u_list)), + va='bottom', ha='right', + transform=self.rdr_plot.plot_axis.transAxes, fontsize=10, fontfamily='monospace'); + + self.selected_ebsd_grain.calc_slip_traces() + self.selected_ebsd_grain.calc_rdr() + + if self.selected_ebsd_grain.average_schmid_factors is None: + raise Exception("Run 'calc_average_grain_schmid_factors' first") + + # Write grain info + eulers = np.rad2deg(self.selected_ebsd_grain.ref_ori.euler_angles()) + text = 'Average angle: {0:.2f}\n'.format(grain.groups_list[group][1]) + text += 'Eulers: {0:.1f} {1:.1f} {2:.1f}\n\n'.format(eulers[0], eulers[1], eulers[2]) - ## Write grain info - ebsdGrain = grain.ebsdGrain - ebsdGrain.calcSlipTraces() + self.rdr_plot.add_text(self.rdr_plot.text_axis, 0.15, 1, text, fontsize=10, va='top', fontfamily='monospace') - if ebsdGrain.averageSchmidFactors is None: - raise Exception("Run 'calcAverageGrainSchmidFactors' first") + # Write slip system info + offset = 0 - eulers = np.rad2deg(ebsdGrain.refOri.eulerAngles()) + # Loop over groups of slip systems with same slip plane + for i, slip_system_group in enumerate(self.selected_ebsd_grain.phase.slip_systems): + slip_trace_angle = np.rad2deg(self.selected_ebsd_grain.slip_trace_angles[i]) + text = "Plane: {0:s} Angle: {1:.1f}\n".format(slip_system_group[0].slip_plane_label, + slip_trace_angle) - text = 'Average angle: {0:.2f}\n'.format(grain.groupsList[group][1]) - text += 'Eulers: {0:.1f} {1:.1f} {2:.1f}\n\n'.format(eulers[0], eulers[1], eulers[2]) + # Then loop over individual slip systems + for j, slip_system in enumerate(slip_system_group): + schmid_factor = self.selected_ebsd_grain.average_schmid_factors[i][j] + + text = text + " {0:s} SF: {1:.3f} RDR: {2:.3f}\n".format( + slip_system.slip_dir_label, schmid_factor, self.selected_ebsd_grain.rdr[i][j]) - self.rdrPlot.addText(self.rdrPlot.textAx, 0.15, 1, text, fontsize=10, va='top') - - ## Write slip system info - RDRs = []; offset = 0; - for idx, (ssGroup, sfGroup, slipTraceAngle) in enumerate( - zip(ebsdGrain.phase.slipSystems, ebsdGrain.averageSchmidFactors, np.rad2deg(ebsdGrain.slipTraceAngles))): - text = "{0:s} {1:.1f}\n".format(ssGroup[0].slipPlaneLabel, slipTraceAngle) - tempRDRs = []; - for ss, sf in zip(ssGroup, sfGroup): - slipDirSample = ebsdGrain.refOri.conjugate.transformVector(ss.slipDir) - text = text + " {0:s} SF: {1:.3f} RDR: {2:.3f}\n".format\ - (ss.slipDirLabel, sf,-slipDirSample[0]/slipDirSample[1]) - RDR = -slipDirSample[0]/slipDirSample[1] - tempRDRs.append(RDR) - RDRs.append(tempRDRs) - - if idx in grain.groupsList[group][2]: - self.rdrPlot.addText(self.rdrPlot.textAx, 0.15, 0.9-offset, text, weight='bold', fontsize=10, va='top') + if i in grain.groups_list[group][2]: + self.rdr_plot.add_text(self.rdr_plot.text_axis, 0.15, 0.9 - offset, text, va='top', + weight='bold', fontsize=10) else: - self.rdrPlot.addText(self.rdrPlot.textAx, 0.15, 0.9-offset, text, fontsize=10, va='top') + self.rdr_plot.add_text(self.rdr_plot.text_axis, 0.15, 0.9 - offset, text, va='top', + fontsize=10) offset += 0.0275 * text.count('\n') - # Plot RDR values on number line - uniqueRDRs = set() - for x in [item for sublist in RDRs for item in sublist]: uniqueRDRs.add(x) - self.rdrPlot.numLineAx.axvline(x=0, ymin=-20, ymax=20, c='k') - self.rdrPlot.numLineAx.plot(np.zeros(len(uniqueRDRs)), list(uniqueRDRs), 'bo', label='Theroretical RDR values') - self.rdrPlot.numLineAx.plot([0], slope, 'ro', label='Measured RDR value') - self.rdrPlot.addText(self.rdrPlot.numLineAx, -0.009, slope-0.01, '{0:.3f}'.format(float(slope))) - self.rdrPlot.numLineAx.legend(bbox_to_anchor=(1.15, 1.05)) - - # Label RDRs by slip system on number line - for RDR in list(uniqueRDRs): - self.rdrPlot.addText(self.rdrPlot.numLineAx, -0.009, RDR-0.01, '{0:.3f}'.format(float(RDR))) - txt = '' - for idx, ssGroup in enumerate(RDRs): - for idx2, rdr in enumerate(ssGroup): - if rdr == RDR: - txt += str('{0} {1} '.format(ebsdGrain.phase.slipSystems[idx][idx2].slipPlaneLabel, - ebsdGrain.phase.slipSystems[idx][idx2].slipDirLabel)) - self.rdrPlot.addText(self.rdrPlot.numLineAx,0.002, RDR-0.01, txt) - - self.rdrPlot.numLineAx.set_ylim(slope-1, slope+1) - self.rdrPlot.numLineAx.set_xlim(-0.01, 0.05) - - def updateFilename(self, - event: str, - plot): + # Finf all unique rdr values + unique_rdrs = set([item for sublist in self.selected_ebsd_grain.rdr for item in sublist]) + + # Plot number line + self.rdr_plot.number_line_axis.axvline(x=0, ymin=-20, ymax=20, c='k') + + # Theoretical values as blue points + self.rdr_plot.number_line_axis.plot(np.zeros(len(unique_rdrs)), list(unique_rdrs), + 'bo', label='Theoretical RDR values') + + # Measured values as red points + self.rdr_plot.number_line_axis.plot([0], slope, 'ro', label='Measured RDR value') + self.rdr_plot.add_text(self.rdr_plot.number_line_axis, -0.002, slope, '{0:.3f}'.format(float(slope)), + fontfamily='monospace', horizontalalignment='right', verticalalignment='center') + + self.rdr_plot.number_line_axis.legend(bbox_to_anchor=(1.15, 1.05)) + + # Label rdrs by slip system on number line + for unique_rdr in list(unique_rdrs): + if (unique_rdr > slope - 1.5) & (unique_rdr < slope + 1.5): + # Add number to the left of point + self.rdr_plot.add_text(self.rdr_plot.number_line_axis, -0.002, unique_rdr, + '{0:.3f}'.format(float(unique_rdr)), + fontfamily='monospace', horizontalalignment='right', verticalalignment='center') + + # Go through all planes and directions and add to string if they have the rdr from above loop + txt = '' + for i, slip_system_group in enumerate(self.selected_ebsd_grain.phase.slip_systems): + # Then loop over individual slip systems + for j, slip_system in enumerate(slip_system_group): + rdr = self.selected_ebsd_grain.rdr[i][j] + if rdr == unique_rdr: + txt += str('{0} {1} '.format(slip_system.slip_plane_label, slip_system.slip_dir_label)) + + self.rdr_plot.add_text(self.rdr_plot.number_line_axis, 0.002, unique_rdr - 0.01, + txt) + + self.rdr_plot.number_line_axis.set_ylim(slope - 1.5, slope + 1.5) + self.rdr_plot.number_line_axis.set_xlim(-0.01, 0.05) + + def update_filename(self, + event: str, + plot): """ Update class variable filename, based on text input from textbox handler. event: Text in textbox. """ - + self.filename = event - def saveFile(self, - event, - plot): + def save_file(self, + event, + plot): """ Save a file which contains definitions of slip lines drawn in grains [(x0, y0, x1, y1), angle, groupID] and groups of lines, defined by an average angle and identified sip plane @@ -565,26 +609,27 @@ def saveFile(self, """ - with open(self.currMap.path + str(self.filename), 'w') as file: - file.write('# This is a file generated by defdap which contains definitions of slip lines drawn in grains by grainInspector\n') + with open(self.selected_dic_map.file_name.parent / str(self.filename), 'w') as file: + file.write('# This is a file generated by defdap which contains ') + file.write('definitions of slip lines drawn in grains by grainInspector\n') file.write('# [(x0, y0, x1, y1), angle, groupID]\n') file.write('# and groups of lines, defined by an average angle and identified sip plane\n') file.write('# [groupID, angle, [slip plane id], [angular deviation]\n\n') - for i, grain in enumerate(self.currMap): - if grain.pointsList != []: + for i, grain in enumerate(self.selected_dic_map): + if grain.points_list != []: file.write('Grain {0}\n'.format(i)) - file.write('{0} Lines\n'.format(len(grain.pointsList))) - for point in grain.pointsList: - file.write(str(point)+'\n') - file.write('{0} Groups\n'.format(len(grain.groupsList))) - for group in grain.groupsList: - file.write(str(group)+'\n') + file.write('{0} Lines\n'.format(len(grain.points_list))) + for point in grain.points_list: + file.write(str(point) + '\n') + file.write('{0} Groups\n'.format(len(grain.groups_list))) + for group in grain.groups_list: + file.write(str(group) + '\n') file.write('\n') - def loadFile(self, - event, - plot): + def load_file(self, + event, + plot): """ Load a file which contains definitions of slip lines drawn in grains [(x0, y0, x1, y1), angle, groupID] and groups of lines, defined by an average angle and identified sip plane @@ -592,33 +637,33 @@ def loadFile(self, """ - with open(self.currMap.path + str(self.filename), 'r') as file: + with open(self.selected_dic_map.file_name.parent / str(self.filename), 'r') as file: lines = file.readlines() # Parse file and make list of # [start index, grain ID, number of lines, number of groups] - indexlist=[] + index_list = [] for i, line in enumerate(lines): - if line[0] != '#' and len(line) >1: - if ('Grain') in line: - grainID = int(line.split(' ')[-1]) - startIndex = i - if ('Lines') in line: - numLines = int(line.split(' ')[0]) - if ('Groups') in line: - numGroups = int(line.split(' ')[0]) - indexlist.append([startIndex, grainID, numLines, numGroups]) + if line[0] != '#' and len(line) > 1: + if 'Grain' in line: + grain_id = int(line.split(' ')[-1]) + start_index = i + if 'Lines' in line: + num_lines = int(line.split(' ')[0]) + if 'Groups' in line: + num_groups = int(line.split(' ')[0]) + index_list.append([start_index, grain_id, num_lines, num_groups]) # Write data from file into grain - for startIndex, grainID, numLines, numGroups in indexlist: - startIndexLines = startIndex+2 - grainPoints = lines[startIndexLines:startIndexLines+numLines] - for point in grainPoints: - self.currMap[grainID].pointsList.append(ast.literal_eval(point.split('\\')[0])) - - startIndexGroups = startIndex+3+numLines - grainGroups = lines[startIndexGroups:startIndexGroups+numGroups] - for group in grainGroups: - self.currMap[grainID].groupsList.append(ast.literal_eval(group.split('\\')[0])) + for start_index, grain_id, num_lines, num_groups in index_list: + start_index_lines = start_index + 2 + grain_points = lines[start_index_lines:start_index_lines + num_lines] + for point in grain_points: + self.selected_dic_map[grain_id].points_list.append(ast.literal_eval(point.split('\\')[0])) + + start_index_groups = start_index + 3 + num_lines + grain_groups = lines[start_index_groups:start_index_groups + num_groups] + for group in grain_groups: + self.selected_dic_map[grain_id].groups_list.append(ast.literal_eval(group.split('\\')[0])) self.redraw() diff --git a/defdap/plotting.py b/defdap/plotting.py index fae5a2c..7afb1ca 100644 --- a/defdap/plotting.py +++ b/defdap/plotting.py @@ -1,4 +1,4 @@ -# Copyright 2021 Mechanics of Microstructures Group +# Copyright 2025 Mechanics of Microstructures Group # at The University of Manchester # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -13,6 +13,8 @@ # See the License for the specific language governing permissions and # limitations under the License. +from functools import partial + import numpy as np import matplotlib as mpl import matplotlib.pyplot as plt @@ -28,6 +30,8 @@ from defdap import defaults from defdap import quat +from defdap.crystal_utils import project_to_orth, equavlent_indicies, idc_to_string + # TODO: add plot parameter to add to current figure @@ -35,37 +39,42 @@ class Plot(object): """ Class used for creating and manipulating plots. """ - def __init__(self, ax=None, axParams={}, fig=None, makeInteractive=False, + + def __init__(self, ax=None, ax_params={}, fig=None, make_interactive=False, title=None, **kwargs): - self.interactive = makeInteractive - if makeInteractive: + self.interactive = make_interactive + if make_interactive: if fig is not None and ax is not None: self.fig = fig self.ax = ax else: # self.fig, self.ax = plt.subplots(**kwargs) self.fig = plt.figure(**kwargs) - self.ax = self.fig.add_subplot(111, **axParams) - self.btnStore = [] - self.txtStore = [] - self.txtBoxStore = [] - self.p1=[];self.p2=[]; + self.ax = self.fig.add_subplot(111, **ax_params) + self.btn_store = [] + self.txt_store = [] + self.txt_box_store = [] + self.p1 = [] + self.p2 = [] else: self.fig = fig # TODO: flag for new figure if ax is None: self.fig = plt.figure(**kwargs) - self.ax = self.fig.add_subplot(111, **axParams) + self.ax = self.fig.add_subplot(111, **ax_params) else: self.ax = ax - self.colourBar = None + self.colour_bar = None self.arrow = None if title is not None: - self.setTitle(title) + self.set_title(title) - def checkInteractive(self): + def set_empty_state(self): + pass + + def check_interactive(self): """Checks if current plot is interactive. Raises @@ -77,12 +86,12 @@ def checkInteractive(self): if not self.interactive: raise Exception("Plot must be interactive") - def addEventHandler(self, eventName, eventHandler): - self.checkInteractive() + def add_event_handler(self, eventName, eventHandler): + self.check_interactive() self.fig.canvas.mpl_connect(eventName, lambda e: eventHandler(e, self)) - def addAxes(self, loc, proj='2d'): + def add_axes(self, loc, proj='2d'): """Add axis to current plot Parameters @@ -102,14 +111,14 @@ def addAxes(self, loc, proj='2d'): if proj == '3d': return Axes3D(self.fig, rect=loc, proj_type='ortho', azim=270, elev=90) - def addButton(self, label, clickHandler, loc=(0.8, 0.0, 0.1, 0.07), **kwargs): + def add_button(self, label, click_handler, loc=(0.8, 0.0, 0.1, 0.07), **kwargs): """Add a button to the plot. Parameters ---------- label : str Label for the button. - clickHandler + click_handler Click handler to assign. loc : list(float), len 4 Left, bottom, width, height. @@ -117,22 +126,24 @@ def addButton(self, label, clickHandler, loc=(0.8, 0.0, 0.1, 0.07), **kwargs): All other arguments passed to :class:`matplotlib.widgets.Button`. """ - self.checkInteractive() - btnAx = self.fig.add_axes(loc) - btn = Button(btnAx, label, **kwargs) - btn.on_clicked(lambda e: clickHandler(e, self)) + self.check_interactive() + btn_ax = self.fig.add_axes(loc) + btn = Button(btn_ax, label, **kwargs) + btn.on_clicked(lambda e: click_handler(e, self)) - self.btnStore.append(btn) + self.btn_store.append(btn) - def addTextBox(self, label, submitHandler=None, changeHandler=None, loc=(0.8, 0.0, 0.1, 0.07), **kwargs): + def add_text_box(self, label, submit_handler=None, change_handler=None, loc=(0.8, 0.0, 0.1, 0.07), **kwargs): """Add a text box to the plot. Parameters ---------- label : str Label for the button. - submitHandler + submit_handler Submit handler to assign. + change_handler + Change handler to assign. loc : list(float), len 4 Left, bottom, width, height. kwargs @@ -143,19 +154,19 @@ def addTextBox(self, label, submitHandler=None, changeHandler=None, loc=(0.8, 0. matplotlotlib.widgets.TextBox """ - self.checkInteractive() - txtBoxAx = self.fig.add_axes(loc) - txtBox = TextBox(txtBoxAx, label, **kwargs) - if submitHandler != None: - txtBox.on_submit(lambda e: submitHandler(e, self)) - if changeHandler != None: - txtBox.on_text_change(lambda e: changeHandler(e, self)) + self.check_interactive() + txt_box_ax = self.fig.add_axes(loc) + txt_box = TextBox(txt_box_ax, label, **kwargs) + if submit_handler != None: + txt_box.on_submit(lambda e: submit_handler(e, self)) + if change_handler != None: + txt_box.on_text_change(lambda e: change_handler(e, self)) - self.txtBoxStore.append(txtBox) + self.txt_box_store.append(txt_box) - return txtBox + return txt_box - def addText(self, ax, x, y, txt, **kwargs): + def add_text(self, ax, x, y, txt, **kwargs): """Add text to the plot. Parameters @@ -174,28 +185,28 @@ def addText(self, ax, x, y, txt, **kwargs): """ txt = ax.text(x, y, txt, **kwargs) - self.txtStore.append(txt) + self.txt_store.append(txt) - def addArrow(self, startEnd, persistent=False, clearPrev=True, label=None): + def add_arrow(self, start_end, persistent=False, clear_previous=True, label=None): """Add arrow to grain plot. Parameters ---------- - startEnd: 4-tuple + start_end: 4-tuple Starting (x, y), Ending (x, y). persistent : If persistent, do not clear arrow with clearPrev. - clearPrev : + clear_previous : Clear all non-persistent arrows. label Label to place near arrow. """ - arrowParams = { - 'xy': startEnd[0:2], # Arrow start coordinates + arrow_params = { + 'xy': start_end[0:2], # Arrow start coordinates 'xycoords': 'data', - 'xytext': startEnd[2:4], # Arrow end coordinates + 'xytext': start_end[2:4], # Arrow end coordinates 'textcoords': 'data', 'arrowprops': dict(arrowstyle="<-", connectionstyle="arc3", color='red', alpha=0.7, linewidth=2, @@ -204,21 +215,21 @@ def addArrow(self, startEnd, persistent=False, clearPrev=True, label=None): # If persisent, add the arrow onto the plot directly if persistent: - self.ax.annotate("", **arrowParams) + self.ax.annotate("", **arrow_params) # If not persistent, save a reference so that it can be removed later if not persistent: - if clearPrev and (self.arrow is not None): self.arrow.remove() - if None not in startEnd: - self.arrow = self.ax.annotate("", **arrowParams) + if clear_previous and (self.arrow is not None): self.arrow.remove() + if None not in start_end: + self.arrow = self.ax.annotate("", **arrow_params) # Add a label if specified if label is not None: - self.ax.annotate(label, xy=startEnd[2:4], xycoords='data', + self.ax.annotate(label, xy=start_end[2:4], xycoords='data', xytext=(15, 15), textcoords='offset pixels', c='red', fontsize=14, fontweight='bold') - def setSize(self, size): + def set_size(self, size): """Set size of plot. Parameters @@ -229,7 +240,7 @@ def setSize(self, size): """ self.fig.set_size_inches(size[0], size[1], forward=True) - def setTitle(self, txt): + def set_title(self, txt): """Set title of plot. Parameters @@ -241,7 +252,7 @@ def setTitle(self, txt): if self.fig.canvas.manager is not None: self.fig.canvas.manager.set_window_title(txt) - def lineSlice(self, event, plot, action=None): + def line_slice(self, event, plot, action=None): """ Catch click and drag then draw an arrow. Parameters @@ -257,8 +268,8 @@ def lineSlice(self, event, plot, action=None): ---------- To use, add a click and release event handler to your plot, pointing to this function: - >>> plot.addEventHandler('button_press_event',lambda e, p: lineSlice(e, p)) - >>> plot.addEventHandler('button_release_event', lambda e, p: lineSlice(e, p)) + >>> plot.add_event_handler('button_press_event',lambda e, p: line_slice(e, p)) + >>> plot.add_event_handler('button_release_event', lambda e, p: line_slice(e, p)) """ # check if click was on the map @@ -269,15 +280,15 @@ def lineSlice(self, event, plot, action=None): self.p1 = (event.xdata, event.ydata) # save 1st point elif event.name == 'button_release_event': self.p2 = (event.xdata, event.ydata) # save 2nd point - self.addArrow(startEnd=(self.p1[0], self.p1[1], self.p2[0], self.p2[1])) + self.add_arrow(start_end=(self.p1[0], self.p1[1], self.p2[0], self.p2[1])) self.fig.canvas.draw_idle() if action is not None: - action(plot=self, startEnd=(self.p1[0], self.p1[1], self.p2[0], self.p2[1])) + action(plot=self, start_end=(self.p1[0], self.p1[1], self.p2[0], self.p2[1])) @property def exists(self): - self.checkInteractive() + self.check_interactive() return plt.fignum_exists(self.fig.number) @@ -285,11 +296,13 @@ def clear(self): """Clear plot. """ - self.checkInteractive() + self.check_interactive() + if self.colour_bar is not None: + self.colour_bar.remove() + self.colour_bar = None self.ax.clear() - if self.colourBar is not None: - self.colourBar.remove() + self.set_empty_state() self.draw() def draw(self): @@ -303,44 +316,49 @@ class MapPlot(Plot): """ Class for creating a map plot. """ - def __init__(self, callingMap, fig=None, ax=None, axParams={}, - makeInteractive=False, **kwargs): + + def __init__(self, calling_map, fig=None, ax=None, ax_params={}, + make_interactive=False, **kwargs): """Initialise a map plot. Parameters ---------- - callingMap : Map + calling_map : Map DIC or EBSD map which called this plot. fig : matplotlib.figure.Figure Matplotlib figure to plot on ax : matplotlib.axes.Axes Matplotlib axis to plot on - axParams : - Passed to defdap.plotting.Plot as axParams. - makeInteractive : bool, optional + ax_params : + Passed to defdap.plotting.Plot as ax_params. + make_interactive : bool, optional If true, make interactive kwargs Other arguments passed to :class:`defdap.plotting.Plot`. + """ super(MapPlot, self).__init__( - ax, axParams=axParams, fig=fig, makeInteractive=makeInteractive, + ax, ax_params=ax_params, fig=fig, make_interactive=make_interactive, **kwargs ) - self.callingMap = callingMap - self.imgLayers = [] - self.highlightsLayerID = None - self.pointsLayerIDs = [] + self.calling_map = calling_map + self.set_empty_state() + + def set_empty_state(self): + self.img_layers = [] + self.highlights_layer_id = None + self.points_layer_ids = [] self.ax.set_xticks([]) self.ax.set_yticks([]) - def addMap(self, mapData, vmin=None, vmax=None, cmap='viridis', **kwargs): + def add_map(self, map_data, vmin=None, vmax=None, cmap='viridis', **kwargs): """Add a map to a plot. Parameters ---------- - mapData : numpy.ndarray + map_data : numpy.ndarray Map data to plot. vmin : float Minimum value for the colour scale. @@ -356,15 +374,15 @@ def addMap(self, mapData, vmin=None, vmax=None, cmap='viridis', **kwargs): matplotlib.image.AxesImage """ - img = self.ax.imshow(mapData, vmin=vmin, vmax=vmax, + img = self.ax.imshow(map_data, vmin=vmin, vmax=vmax, interpolation='None', cmap=cmap, **kwargs) self.draw() - self.imgLayers.append(img) + self.img_layers.append(img) return img - def addColourBar(self, label, layer=0, **kwargs): + def add_colour_bar(self, label, layer=0, **kwargs): """Add a colour bar to plot. Parameters @@ -377,10 +395,10 @@ def addColourBar(self, label, layer=0, **kwargs): Other arguments are passed to :func:`matplotlib.pyplot.colorbar`. """ - img = self.imgLayers[layer] - self.colourBar = plt.colorbar(img, ax=self.ax, label=label, **kwargs) + img = self.img_layers[layer] + self.colour_bar = plt.colorbar(img, ax=self.ax, label=label, **kwargs) - def addScaleBar(self, scale=None): + def add_scale_bar(self, scale=None): """Add scale bar to plot. Parameters @@ -390,11 +408,11 @@ def addScaleBar(self, scale=None): """ if scale is None: - scale = self.callingMap.scale * 1e-6 - self.ax.add_artist(ScaleBar(scale)) + scale = self.calling_map.scale + self.ax.add_artist(ScaleBar(scale * 1e-6)) - def addGrainBoundaries(self, kind="pixel", boundaries=None, colour=None, - dilate=False, draw=True, **kwargs): + def add_grain_boundaries(self, kind="pixel", boundaries=None, colour=None, + dilate=False, draw=True, **kwargs): """Add grain boundaries to the plot. Parameters @@ -407,6 +425,11 @@ def addGrainBoundaries(self, kind="pixel", boundaries=None, colour=None, of coordinates representing the start and end of each boundary segment. If not provided the boundaries are loaded from the calling map. + + boundaries : various, defdap.ebsd.BoundarySet + Boundaries to plot. If not provided the boundaries are loaded from + the calling map. + colour : various One of: - Colour of all boundaries as a string (only option pixel kind) @@ -428,15 +451,14 @@ def addGrainBoundaries(self, kind="pixel", boundaries=None, colour=None, if colour is None: colour = "white" + if boundaries is None: + boundaries = self.calling_map.data.grain_boundaries + if kind == "line": if isinstance(colour, str): colour = mpl.colors.to_rgba(colour) - boundary_lines = boundaries - if boundary_lines is None: - boundary_lines = self.callingMap.boundaryLines - - if len(colour) == len(boundary_lines): + if len(colour) == len(boundaries.lines): colour_array = colour colour_lc = None elif len(colour) == 4: @@ -444,104 +466,97 @@ def addGrainBoundaries(self, kind="pixel", boundaries=None, colour=None, colour_lc = colour else: ValueError('Issue with passed colour') - - boundary_lines = boundaries - if boundary_lines is None: - boundary_lines = self.callingMap.boundaryLines - lc = LineCollection(boundary_lines, colors=colour_lc, **kwargs) + lc = LineCollection(boundaries.lines, colors=colour_lc, **kwargs) lc.set_array(colour_array) img = self.ax.add_collection(lc) else: - boundariesImage = boundaries - if boundariesImage is None: - boundariesImage = self.callingMap.boundaries - boundariesImage = -boundariesImage + boundaries_image = boundaries.image.astype(int) if dilate: - boundariesImage = mph.binary_dilation(boundariesImage) + boundaries_image = mph.binary_dilation(boundaries_image) # create colourmap for boundaries going from transparent to # opaque of the given colour - boundariesCmap = mpl.colors.LinearSegmentedColormap.from_list( + boundaries_cmap = mpl.colors.LinearSegmentedColormap.from_list( 'my_cmap', ['white', colour], 256 ) - boundariesCmap._init() - boundariesCmap._lut[:, -1] = np.linspace(0, 1, boundariesCmap.N + 3) + boundaries_cmap._init() + boundaries_cmap._lut[:, -1] = np.linspace(0, 1, boundaries_cmap.N + 3) - img = self.ax.imshow(boundariesImage, cmap=boundariesCmap, + img = self.ax.imshow(boundaries_image, cmap=boundaries_cmap, interpolation='None', vmin=0, vmax=1) if draw: self.draw() - self.imgLayers.append(img) + self.img_layers.append(img) return img - def addGrainHighlights(self, grainIds, grainColours=None, alpha=None, - newLayer=False): + def add_grain_highlights(self, grain_ids, grain_colours=None, alpha=None, + new_layer=False): """Highlight grains in the plot. Parameters ---------- - grainIds : list + grain_ids : list List of grain IDs to highlight. - grainColours : + grain_colours : Colour to use for grain highlight. alpha : float Alpha (transparency) to use for grain highlight. - newLayer : bool - If true, make a new layer in imgLayers. + new_layer : bool + If true, make a new layer in img_layers. Returns ------- matplotlib.image.AxesImage """ - if grainColours is None: - grainColours = ['white'] + if grain_colours is None: + grain_colours = ['white'] if alpha is None: - alpha = self.callingMap.highlightAlpha + alpha = self.calling_map.highlight_alpha - outline = np.zeros(self.callingMap.shape, dtype=int) - for i, grainId in enumerate(grainIds, start=1): - if i > len(grainColours): - i = len(grainColours) + outline = np.zeros(self.calling_map.shape, dtype=int) + for i, grainId in enumerate(grain_ids, start=1): + if i > len(grain_colours): + i = len(grain_colours) # outline of highlighted grain - grain = self.callingMap.grainList[grainId] - grainOutline = grain.grainOutline(bg=0, fg=i) - x0, y0, xmax, ymax = grain.extremeCoords + grain = self.calling_map.grains[grainId] + grainOutline = grain.grain_outline(bg=0, fg=i) + x0, y0, xmax, ymax = grain.extreme_coords # add to highlight image outline[y0:ymax + 1, x0:xmax + 1] += grainOutline # Custom colour map where 0 is transparent white for bg and # then a patch for each grain colour - grainColours.insert(0, 'white') - hightlightsCmap = mpl.colors.ListedColormap(grainColours) - hightlightsCmap._init() - alphaMap = np.full(hightlightsCmap.N + 3, alpha) + grain_colours.insert(0, 'white') + highlightsCmap = mpl.colors.ListedColormap(grain_colours) + highlightsCmap._init() + alphaMap = np.full(highlightsCmap.N + 3, alpha) alphaMap[0] = 0 - hightlightsCmap._lut[:, -1] = alphaMap + highlightsCmap._lut[:, -1] = alphaMap - if self.highlightsLayerID is None or newLayer: + if self.highlights_layer_id is None or new_layer: img = self.ax.imshow(outline, interpolation='none', - cmap=hightlightsCmap) - if self.highlightsLayerID is None: - self.highlightsLayerID = len(self.imgLayers) - self.imgLayers.append(img) + cmap=highlightsCmap) + if self.highlights_layer_id is None: + self.highlights_layer_id = len(self.img_layers) + self.img_layers.append(img) else: - img = self.imgLayers[self.highlightsLayerID] + img = self.img_layers[self.highlights_layer_id] img.set_data(outline) - img.set_cmap(hightlightsCmap) + img.set_cmap(highlightsCmap) img.autoscale() self.draw() return img - def addGrainNumbers(self, fontsize=10, **kwargs): + def add_grain_numbers(self, fontsize=10, **kwargs): """Add grain numbers to a map. Parameters @@ -552,15 +567,15 @@ def addGrainNumbers(self, fontsize=10, **kwargs): Pass other arguments to :func:`matplotlib.pyplot.text`. """ - for grainID, grain in enumerate(self.callingMap): - xCentre, yCentre = grain.centreCoords(centreType="com", - grainCoords=False) + for grain_id, grain in enumerate(self.calling_map): + x_centre, y_centre = grain.centre_coords(centre_type="com", + grain_coords=False) - self.ax.text(xCentre, yCentre, grainID, + self.ax.text(x_centre, y_centre, grain_id, fontsize=fontsize, **kwargs) self.draw() - def addLegend(self, values, labels, layer=0, **kwargs): + def add_legend(self, values, labels, layer=0, **kwargs): """Add a legend to a map. Parameters @@ -576,7 +591,7 @@ def addLegend(self, values, labels, layer=0, **kwargs): """ # Find colour values for given values - img = self.imgLayers[layer] + img = self.img_layers[layer] colors = [img.cmap(img.norm(value)) for value in values] # Get colour patches for each phase and make legend @@ -586,28 +601,28 @@ def addLegend(self, values, labels, layer=0, **kwargs): self.ax.legend(handles=patches, **kwargs) - def addPoints(self, x, y, updateLayer=None, **kwargs): + def add_points(self, x, y, update_layer=None, **kwargs): """Add points to plot. Parameters ---------- - x : float - x coordinate. - y : float - y coordinate. - updateLayer : int, optional + x : list of float + x coordinates + y : list of float + y coordinates + update_layer : int, optional Layer to place points on kwargs Other arguments passed to :func:`matplotlib.pyplot.scatter`. """ x, y = np.array(x), np.array(y) - if len(self.pointsLayerIDs) == 0 or updateLayer is None: + if len(self.points_layer_ids) == 0 or update_layer is None: points = self.ax.scatter(x, y, **kwargs) - self.pointsLayerIDs.append(len(self.imgLayers)) - self.imgLayers.append(points) + self.points_layer_ids.append(len(self.img_layers)) + self.img_layers.append(points) else: - points = self.imgLayers[self.pointsLayerIDs[updateLayer]] + points = self.img_layers[self.points_layer_ids[update_layer]] points.set_offsets(np.hstack((x[:, np.newaxis], y[:, np.newaxis]))) self.draw() @@ -616,36 +631,36 @@ def addPoints(self, x, y, updateLayer=None, **kwargs): @classmethod def create( - cls, callingMap, mapData, - fig=None, figParams={}, ax=None, axParams={}, - plot=None, makeInteractive=False, - plotColourBar=False, vmin=None, vmax=None, cmap=None, clabel="", - plotGBs=False, dilateBoundaries=False, boundaryColour=None, - plotScaleBar=False, scale=None, - highlightGrains=None, highlightColours=None, highlightAlpha=None, - **kwargs + cls, calling_map, map_data, + fig=None, fig_params={}, ax=None, ax_params={}, + plot=None, make_interactive=False, + plot_colour_bar=False, vmin=None, vmax=None, cmap=None, clabel="", + plot_gbs=False, dilate_boundaries=False, boundary_colour=None, + plot_scale_bar=False, scale=None, + highlight_grains=None, highlight_colours=None, highlight_alpha=None, + **kwargs ): """Create a plot for a map. Parameters ---------- - callingMap : base.Map + calling_map : base.Map DIC or EBSD map which called this plot. - mapData : numpy.ndarray + map_data : numpy.ndarray Data to be plotted. fig : matplotlib.figure.Figure Matplotlib figure to plot on. - figParams : + fig_params : Passed to defdap.plotting.Plot. ax : matplotlib.axes.Axes Matplotlib axis to plot on. - axParams : - Passed to defdap.plotting.Plot as axParams. + ax_params : + Passed to defdap.plotting.Plot as ax_params. plot : defdap.plotting.Plot If none, use current plot. - makeInteractive : + make_interactive : If true, make plot interactive - plotColourBar : bool + plot_colour_bar : bool If true, plot a colour bar next to the map. vmin : float, optional Minimum value for the colour scale. @@ -655,24 +670,24 @@ def create( Colour map. clabel : str Label for the colour bar. - plotGBs : bool + plot_gbs : bool If true, plot the grain boundaries on the map. - dilateBoundaries : bool + dilate_boundaries : bool If true, dilate the grain boundaries. - boundaryColour : str + boundary_colour : str Colour to use for the grain boundaries. - plotScaleBar : bool + plot_scale_bar : bool If true, plot a scale bar in the map. scale : float - Size of pizel in microns. - highlightGrains : list(int) + Size of pixel in microns. + highlight_grains : list(int) List of grain IDs to highlight. - highlightColours : str - Colour to hightlight grains. - highlightAlpha : float + highlight_colours : str + Colour to highlight grains. + highlight_alpha : float Alpha (transparency) by which to highlight grains. kwargs : - All other arguments passed to :func:`defdap.plotting.MapPlot.addMap` + All other arguments passed to :func:`defdap.plotting.MapPlot.add_map` Returns ------- @@ -680,54 +695,59 @@ def create( """ if plot is None: - plot = cls(callingMap, fig=fig, ax=ax, axParams=axParams, - makeInteractive=makeInteractive, **figParams) + plot = cls(calling_map, fig=fig, ax=ax, ax_params=ax_params, + make_interactive=make_interactive, **fig_params) - if mapData is not None: - plot.addMap(mapData, cmap=cmap, vmin=vmin, vmax=vmax, **kwargs) + if map_data is not None: + plot.add_map(map_data, cmap=cmap, vmin=vmin, vmax=vmax, **kwargs) - if plotColourBar: - plot.addColourBar(clabel) + if plot_colour_bar: + plot.add_colour_bar(clabel) - if plotGBs: - plot.addGrainBoundaries( - colour=boundaryColour, dilate=dilateBoundaries, kind=plotGBs + if plot_gbs: + plot.add_grain_boundaries( + colour=boundary_colour, dilate=dilate_boundaries, kind=plot_gbs ) - if highlightGrains is not None: - plot.addGrainHighlights( - highlightGrains, - grainColours=highlightColours, alpha=highlightAlpha + if highlight_grains is not None: + plot.add_grain_highlights( + highlight_grains, + grain_colours=highlight_colours, alpha=highlight_alpha ) - if plotScaleBar: - plot.addScaleBar(scale=scale) + if plot_scale_bar: + plot.add_scale_bar(scale=scale) return plot + class GrainPlot(Plot): """ Class for creating a map for a grain. """ - def __init__(self, callingGrain, fig=None, ax=None, axParams={}, - makeInteractive=False, **kwargs): + + def __init__(self, calling_grain, fig=None, ax=None, ax_params={}, + make_interactive=False, **kwargs): super(GrainPlot, self).__init__( - ax, axParams=axParams, fig=fig, makeInteractive=makeInteractive, + ax, ax_params=ax_params, fig=fig, make_interactive=make_interactive, **kwargs ) - self.callingGrain = callingGrain - self.imgLayers = [] + self.calling_grain = calling_grain + self.set_empty_state() + + def set_empty_state(self): + self.img_layers = [] self.ax.set_xticks([]) self.ax.set_yticks([]) - def addMap(self, mapData, vmin=None, vmax=None, cmap='viridis', **kwargs): + def addMap(self, map_data, vmin=None, vmax=None, cmap='viridis', **kwargs): """Add a map to a grain plot. Parameters ---------- - mapData : numpy.ndarray + map_data : numpy.ndarray Grain data to plot vmin : float Minimum value for the colour scale. @@ -743,17 +763,15 @@ def addMap(self, mapData, vmin=None, vmax=None, cmap='viridis', **kwargs): matplotlib.image.AxesImage """ - img = self.ax.imshow(mapData, vmin=vmin, vmax=vmax, + img = self.ax.imshow(map_data, vmin=vmin, vmax=vmax, interpolation='None', cmap=cmap, **kwargs) self.draw() - self.imgLayers.append(img) + self.img_layers.append(img) return img - - - def addColourBar(self, label, layer=0, **kwargs): + def add_colour_bar(self, label, layer=0, **kwargs): """Add colour bar to grain plot. Parameters @@ -766,10 +784,10 @@ def addColourBar(self, label, layer=0, **kwargs): Other arguments passed to :func:`matplotlib.pyplot.colorbar`. """ - img = self.imgLayers[layer] - self.colourBar = plt.colorbar(img, ax=self.ax, label=label, **kwargs) + img = self.img_layers[layer] + self.colour_bar = plt.colorbar(img, ax=self.ax, label=label, **kwargs) - def addScaleBar(self, scale=None): + def add_scale_bar(self, scale=None): """Add scale bar to grain plot. Parameters @@ -779,10 +797,10 @@ def addScaleBar(self, scale=None): """ if scale is None: - scale = self.callingGrain.ownerMap.scale * 1e-6 - self.ax.add_artist(ScaleBar(scale)) + scale = self.calling_grain.owner_map.scale + self.ax.add_artist(ScaleBar(scale * 1e-6)) - def addTraces(self, angles, colours, topOnly=False, pos=None, **kwargs): + def add_traces(self, angles, colours, top_only=False, pos=None, **kwargs): """Add slip trace angles to grain plot. Illustrated by lines crossing through central pivot point to create a circle. @@ -792,8 +810,8 @@ def addTraces(self, angles, colours, topOnly=False, pos=None, **kwargs): Angles of slip traces. colours : list Colours to plot. - topOnly : bool, optional - If true, plot only a semi-circle instead of a circle. + top_only : bool, optional + If true, plot only a semicircle instead of a circle. pos : tuple Position of slip traces. kwargs @@ -801,19 +819,19 @@ def addTraces(self, angles, colours, topOnly=False, pos=None, **kwargs): """ if pos is None: - pos = self.callingGrain.centreCoords() + pos = self.calling_grain.centre_coords() traces = np.array((-np.sin(angles), np.cos(angles))) # When plotting top half only, move all 'traces' to +ve y # and set the pivot to be in the tail instead of centre - if topOnly: + if top_only: pivot = 'tail' - for idx, (x,y) in enumerate(zip(traces[0], traces[1])): + for idx, (x, y) in enumerate(zip(traces[0], traces[1])): if x < 0 and y < 0: traces[0][idx] *= -1 traces[1][idx] *= -1 - self.ax.set_ylim(pos[1]-0.001, pos[1]+0.1) - self.ax.set_xlim(pos[0]-0.1, pos[0]+0.1) + self.ax.set_ylim(pos[1] - 0.001, pos[1] + 0.1) + self.ax.set_xlim(pos[0] - 0.1, pos[0] + 0.1) else: pivot = 'middle' @@ -828,15 +846,15 @@ def addTraces(self, angles, colours, topOnly=False, pos=None, **kwargs): ) self.draw() - def addSlipTraces(self, topOnly=False, colours=None, pos=None, **kwargs): + def add_slip_traces(self, top_only=False, colours=None, pos=None, **kwargs): """Add slip traces to plot, based on the calling grain's slip systems. Parameters ---------- colours : list Colours to plot. - topOnly : bool, optional - If true, plot only a semi-circle instead of a circle. + top_only : bool, optional + If true, plot only a semicircle instead of a circle. pos : tuple Position of slip traces. kwargs @@ -845,75 +863,75 @@ def addSlipTraces(self, topOnly=False, colours=None, pos=None, **kwargs): """ if colours is None: - colours = self.callingGrain.ebsdGrain.phase.slipTraceColours - slipTraceAngles = self.callingGrain.slipTraces + colours = self.calling_grain.ebsd_grain.phase.slip_trace_colours + slip_trace_angles = self.calling_grain.slip_traces - self.addTraces(slipTraceAngles, colours, topOnly, pos=pos, **kwargs) + self.add_traces(slip_trace_angles, colours, top_only, pos=pos, **kwargs) - def addSlipBands(self, topOnly=False, grainMapData=None, angles=None, pos=None, - thres=None, min_dist=None, **kwargs): + def add_slip_bands(self, top_only=False, grain_map_data=None, angles=None, pos=None, + thres=None, min_dist=None, **kwargs): """Add lines representing slip bands detected by Radon transform - in :func:`~defdap.hrdic.grain.calcSlipBands`. + in :func:`~defdap.hrdic.grain.calc_slip_bands`. Parameters ---------- - topOnly : bool, optional - If true, plot only a semi-circle instead of a circle. - grainMapData : - Map data to pass to :func:`~defdap.hrdic.Grain.calcSlipBands`. + top_only : bool, optional + If true, plot only a semicircle instead of a circle. + grain_map_data : + Map data to pass to :func:`~defdap.hrdic.Grain.calc_slip_bands`. angles : list(float), optional List of angles to plot, otherwise, use angles - detected in :func:`~defdap.hrdic.Grain.calcSlipBands`. + detected in :func:`~defdap.hrdic.Grain.calc_slip_bands`. pos : tuple Position in which to plot slip traces. thres : float - Threshold to use in :func:`~defdap.hrdic.Grain.calcSlipBands`. + Threshold to use in :func:`~defdap.hrdic.Grain.calc_slip_bands`. min_dist : - Minimum angle between bands in :func:`~defdap.hrdic.Grain.calcSlipBands`. + Minimum angle between bands in :func:`~defdap.hrdic.Grain.calc_slip_bands`. kwargs Other arguments are passed to :func:`matplotlib.pyplot.quiver`. """ if angles is None: - slipBandAngles = self.callingGrain.calcSlipBands(grainMapData, - thres=thres, - min_dist=min_dist) + slip_band_angles = self.calling_grain.calc_slip_bands(grain_map_data, + thres=thres, + min_dist=min_dist) else: - slipBandAngles = angles + slip_band_angles = angles - self.addTraces(slipBandAngles, ["black"], topOnly, pos=pos, **kwargs) + self.add_traces(slip_band_angles, ["black"], top_only, pos=pos, **kwargs) @classmethod def create( - cls, callingGrain, mapData, - fig=None, figParams={}, ax=None, axParams={}, - plot=None, makeInteractive=False, - plotColourBar=False, vmin=None, vmax=None, cmap=None, clabel="", - plotScaleBar=False, scale=None, - plotSlipTraces=False, plotSlipBands=False, **kwargs + cls, calling_grain, map_data, + fig=None, fig_params={}, ax=None, ax_params={}, + plot=None, make_interactive=False, + plot_colour_bar=False, vmin=None, vmax=None, cmap=None, clabel="", + plot_scale_bar=False, scale=None, + plot_slip_traces=False, plot_slip_bands=False, **kwargs ): """Create grain plot. Parameters ---------- - callingGrain : base.Grain + calling_grain : base.Grain DIC or EBSD grain which called this plot. - mapData : + map_data : Data to be plotted. fig : matplotlib.figure.Figure Matplotlib figure to plot on. - figParams : + fig_params : Passed to defdap.plotting.Plot. ax : matplotlib.axes.Axes Matplotlib axis to plot on. - axParams : - Passed to defdap.plotting.Plot as axParams. + ax_params : + Passed to defdap.plotting.Plot as ax_params. plot : defdap.plotting.Plot If none, use current plot. - makeInteractive : + make_interactive : If true, make plot interactive - plotColourBar : bool + plot_colour_bar : bool If true, plot a colour bar next to the map. vmin : float Minimum value for the colour scale. @@ -923,16 +941,16 @@ def create( Colour map. clabel : str Label for the colour bar. - plotScaleBar : bool + plot_scale_bar : bool If true, plot a scale bar in the map. scale : float Size of pizel in microns. - plotSlipTraces : bool - If true, plot slip traces with :func:`~defdap.plotting.GrainPlot.addSlipTraces` - plotSlipBands : bool - If true, plot slip traces with :func:`~defdap.plotting.GrainPlot.addSlipBands` + plot_slip_traces : bool + If true, plot slip traces with :func:`~defdap.plotting.GrainPlot.add_slip_traces` + plot_slip_bands : bool + If true, plot slip traces with :func:`~defdap.plotting.GrainPlot.add_slip_bands` kwargs : - All other arguments passed to :func:`defdap.plotting.GrainPlot.addMap` + All other arguments passed to :func:`defdap.plotting.GrainPlot.add_map` Returns ------- @@ -940,21 +958,21 @@ def create( """ if plot is None: - plot = cls(callingGrain, fig=fig, ax=ax, axParams=axParams, - makeInteractive=makeInteractive, **figParams) - plot.addMap(mapData, cmap=cmap, vmin=vmin, vmax=vmax, **kwargs) + plot = cls(calling_grain, fig=fig, ax=ax, ax_params=ax_params, + make_interactive=make_interactive, **fig_params) + plot.addMap(map_data, cmap=cmap, vmin=vmin, vmax=vmax, **kwargs) - if plotColourBar: - plot.addColourBar(clabel) + if plot_colour_bar: + plot.add_colour_bar(clabel) - if plotScaleBar: - plot.addScaleBar(scale=scale) + if plot_scale_bar: + plot.add_scale_bar(scale=scale) - if plotSlipTraces: - plot.addSlipTraces() + if plot_slip_traces: + plot.add_slip_traces() - if plotSlipBands: - plot.addSlipBands(grainMapData=mapData) + if plot_slip_bands: + plot.add_slip_bands(grain_map_data=map_data) return plot @@ -963,22 +981,23 @@ class PolePlot(Plot): """ Class for creating an inverse pole figure plot. """ - def __init__(self, plotType, crystalSym, projection=None, - fig=None, ax=None, axParams={}, makeInteractive=False, + + def __init__(self, plot_type, crystal_sym, projection=None, + fig=None, ax=None, ax_params={}, make_interactive=False, **kwargs): super(PolePlot, self).__init__( - ax, axParams=axParams, fig=fig, makeInteractive=makeInteractive, + ax, ax_params=ax_params, fig=fig, make_interactive=make_interactive, **kwargs) - self.plotType = plotType - self.crystalSym = crystalSym + self.plot_type = plot_type + self.crystal_sym = crystal_sym self.projection = self._validateProjection(projection) - self.imgLayers = [] + self.img_layers = [] - self.addAxis() + self.add_axis() - def addAxis(self): + def add_axis(self): """Draw axes on the IPF based on crystal symmetry. Raises @@ -987,59 +1006,66 @@ def addAxis(self): If a crystal type other than 'cubic' or 'hexagonal' are selected. """ - if self.plotType == "IPF" and self.crystalSym == "cubic": - # line between [001] and [111] - self.addLine([0, 0, 1], [1, 1, 1], c='k', lw=2) - - # line between [001] and [101] - self.addLine([0, 0, 1], [1, 0, 1], c='k', lw=2) - - # line between [101] and [111] - self.addLine([1, 0, 1], [1, 1, 1], c='k', lw=2) - - # label poles - self.labelPoint([0, 0, 1], '001', - padY=-0.005, va='top', ha='center', fontsize=12) - self.labelPoint([1, 0, 1], '101', - padY=-0.005, va='top', ha='center', fontsize=12) - self.labelPoint([1, 1, 1], '111', - padY=0.005, va='bottom', ha='center', fontsize=12) - - elif self.plotType == "IPF" and self.crystalSym == "hexagonal": - # line between [0001] and [10-10] ([001] and [210]) - # converted to cubic axes - self.addLine([0, 0, 1], [np.sqrt(3), 1, 0], c='k', lw=2) - - # line between [0001] and [2-1-10] ([001] and [100]) - self.addLine([0, 0, 1], [1, 0, 0], c='k', lw=2) - - # line between [2-1-10] and [10-10] ([100] and [210]) - self.addLine([1, 0, 0], [np.sqrt(3), 1, 0], c='k', lw=2) - - # label poles - self.labelPoint([0, 0, 1], '0001', - padY=-0.012, va='top', ha='center', fontsize=12) - self.labelPoint([1, 0, 0], r'$2\bar{1}\bar{1}0$', - padY=-0.012, va='top', ha='center', fontsize=12) - self.labelPoint([np.sqrt(3), 1, 0], r'$10\bar{1}0$', - padY=0.009, va='bottom', ha='center', fontsize=12) - + if self.plot_type == "IPF" and self.crystal_sym == "cubic": + lines = [ + ((0, 0, 1), (0, 1, 1)), + ((0, 0, 1), (-1, 1, 1)), + ((0, 1, 1), (-1, 1, 1)), + ] + labels = [ + ((0, 0, 1), -0.005, 'top'), + ((0, 1, 1), -0.005, 'top'), + ((-1, 1, 1), 0.005, 'bottom'), + ] + + elif self.plot_type == "IPF" and self.crystal_sym == "hexagonal": + if defaults['ipf_triangle_convention'] == 'down': + lines = [ + ((0, 0, 0, 1), (-1, 2, -1, 0)), + ((0, 0, 0, 1), (0, 1, -1, 0)), + ((-1, 2, -1, 0), (0, 1, -1, 0)), + ] + labels = [ + ((0, 0, 0, 1), 0.012, 'bottom'), + ((-1, 2, -1, 0), 0.012, 'bottom'), + ((0, 1, -1, 0), -0.012, 'top'), + ] + + else: + lines = [ + ((0, 0, 0, 1), (-1, 2, -1, 0)), + ((0, 0, 0, 1), (-1, 1, 0, 0)), + ((-1, 2, -1, 0), (-1, 1, 0, 0)), + ] + labels = [ + ((0, 0, 0, 1), -0.012, 'top'), + ((-1, 2, -1, 0), -0.012, 'top'), + ((-1, 1, 0, 0), 0.012, 'bottom'), + ] else: raise NotImplementedError("Only works for cubic and hexagonal.") + + for line in lines: + self.add_line(*line, c='k', lw=2) + for label in labels: + self.label_point( + label[0], pad_y=label[1], va=label[2], + ha='center', fontsize=12 + ) self.ax.axis('equal') self.ax.axis('off') - def addLine(self, startPoint, endPoint, plotSyms=False, res=100, **kwargs): + def add_line(self, start_point, end_point, plot_syms=False, res=100, **kwargs): """Draw lines on the IPF plot. Parameters ---------- - startPoint : numpy.ndarray + start_point : tuple Start point in crystal coordinates (i.e. [0,0,1]). - endPoint : numpy.ndarray + end_point : tuple End point in crystal coordinates, (i.e. [1,0,0]). - plotSyms : bool, optional + plot_syms : bool, optional If true, plot all symmetrically equivelant points. res : int Number of points within each line to plot. @@ -1047,63 +1073,96 @@ def addLine(self, startPoint, endPoint, plotSyms=False, res=100, **kwargs): All other arguments are passed to :func:`matplotlib.pyplot.plot`. """ - lines = [(startPoint, endPoint)] - if plotSyms: - for symm in quat.Quat.symEqv(self.crystalSym)[1:]: - startPointSymm = symm.transformVector(startPoint).astype(int) - endPointSymm = symm.transformVector(endPoint).astype(int) + if self.crystal_sym == 'hexagonal': + start_point = project_to_orth(0.8165, dir=start_point, in_type='mb') + end_point = project_to_orth(0.8165, dir=end_point, in_type='mb') + + lines = [(start_point, end_point)] + if plot_syms: + for symm in quat.Quat.sym_eqv(self.crystal_sym)[1:]: + start_point_symm = symm.transform_vector(start_point) + end_point_symm = symm.transform_vector(end_point) - if startPointSymm[2] < 0: - startPointSymm *= -1 - if endPointSymm[2] < 0: - endPointSymm *= -1 + if start_point_symm[2] < 0: + start_point_symm *= -1 + if end_point_symm[2] < 0: + end_point_symm *= -1 - lines.append((startPointSymm, endPointSymm)) + lines.append((start_point_symm, end_point_symm)) - linePoints = np.zeros((3, res), dtype=float) + line_points = np.zeros((3, res), dtype=float) for line in lines: for i in range(3): if line[0][i] == line[1][i]: - linePoints[i] = np.full(res, line[0][i]) + line_points[i] = np.full(res, line[0][i]) else: - linePoints[i] = np.linspace(line[0][i], line[1][i], res) + line_points[i] = np.linspace(line[0][i], line[1][i], res) - xp, yp = self.projection(linePoints[0], linePoints[1], linePoints[2]) + xp, yp = self.projection(line_points[0], line_points[1], line_points[2]) self.ax.plot(xp, yp, **kwargs) - def labelPoint(self, point, label, padX=0, padY=0, **kwargs): + def label_point(self, point, label=None, plot_syms=False, pad_x=0, pad_y=0, **kwargs): """Place a label near a coordinate in the pole plot. Parameters ---------- point : tuple (x, y) coordinate to place text. - label : str + label : str, optional Text to use in label. - padX : int, optional + pad_x : int, optional Pad added to x coordinate. - padY : int, optional + pad_y : int, optional Pad added to y coordinate. kwargs Other arguments are passed to :func:`matplotlib.axes.Axes.text`. """ - xp, yp = self.projection(*point) - self.ax.text(xp + padX, yp + padY, label, **kwargs) + labels = [idc_to_string(point, str_type='tex')] if label is None else [label] + + point_idc = point + if self.crystal_sym == 'hexagonal': + point = project_to_orth(0.8165, dir=point, in_type='mb') + + points = [point] + + if plot_syms: + for symm in quat.Quat.sym_eqv(self.crystal_sym)[1:]: + point_symm = symm.transform_vector(point) + if point_symm[2] < 0: + point_symm *= -1 + points.append(point_symm) + + if label is None: + labels = map( + partial(idc_to_string, str_type='tex'), + equavlent_indicies( + self.crystal_sym, + quat.Quat.sym_eqv(self.crystal_sym), + dir=point_idc, + c_over_a=0.8165 + ) + ) + else: + labels *= len(quat.Quat.sym_eqv(self.crystal_sym)) + + for point, label in zip(points, labels): + xp, yp = self.projection(*point) + self.ax.text(xp + pad_x, yp + pad_y, label, **kwargs) - def addPoints(self, alphaAng, betaAng, markerColour=None, markerSize=None, **kwargs): + def add_points(self, alpha_ang, beta_ang, marker_colour=None, marker_size=None, **kwargs): """Add a point to the pole plot. Parameters ---------- - alphaAng + alpha_ang Inclination angle to plot. - betaAng + beta_ang Azimuthal angle (around z axis from x in anticlockwise as per ISO) to plot. - markerColour : str or list(str), optional + marker_colour : str or list(str), optional Colour of marker. If two specified, then the point will have two semicircles of different colour. - markerSize : float + marker_size : float Size of marker. kwargs Other arguments are passed to :func:`matplotlib.axes.Axes.scatter`. @@ -1115,21 +1174,21 @@ def addPoints(self, alphaAng, betaAng, markerColour=None, markerSize=None, **kwa """ # project onto equatorial plane - xp, yp = self.projection(alphaAng, betaAng) + xp, yp = self.projection(alpha_ang, beta_ang) # plot poles - # plot markers with 'half and half' colour - if type(markerColour) is str: - markerColour = [markerColour] + # plot markers with 'half-and-half' colour + if type(marker_colour) is str: + marker_colour = [marker_colour] - if markerColour is None: + if marker_colour is None: points = self.ax.scatter(xp, yp, **kwargs) - self.imgLayers.append(points) - elif len(markerColour) == 2: + self.img_layers.append(points) + elif len(marker_colour) == 2: pos = (xp, yp) r1 = 0.5 r2 = r1 + 0.5 - markerSize = np.sqrt(markerSize) + marker_size = np.sqrt(marker_size) x = [0] + np.cos(np.linspace(0, 2 * np.pi * r1, 10)).tolist() y = [0] + np.sin(np.linspace(0, 2 * np.pi * r1, 10)).tolist() @@ -1141,18 +1200,18 @@ def addPoints(self, alphaAng, betaAng, markerColour=None, markerSize=None, **kwa points = self.ax.scatter( pos[0], pos[1], marker=(xy1, 0), - s=markerSize, c=markerColour[0], **kwargs + s=marker_size, c=marker_colour[0], **kwargs ) - self.imgLayers.append(points) + self.img_layers.append(points) points = self.ax.scatter( pos[0], pos[1], marker=(xy2, 0), - s=markerSize, c=markerColour[1], **kwargs + s=marker_size, c=marker_colour[1], **kwargs ) - self.imgLayers.append(points) + self.img_layers.append(points) else: raise Exception("specify one colour for solid markers or list two for 'half and half'") - def addColourBar(self, label, layer=0, **kwargs): + def add_colour_bar(self, label, layer=0, **kwargs): """Add a colour bar to the pole plot. Parameters @@ -1165,10 +1224,17 @@ def addColourBar(self, label, layer=0, **kwargs): Other argument are passed to :func:`matplotlib.pyplot.colorbar`. """ - img = self.imgLayers[layer] - self.colourBar = plt.colorbar(img, ax=self.ax, label=label, **kwargs) - - def addLegend(self, label='Grain area (μm$^2$)', number=6, layer=0, scaling=1, **kwargs): + img = self.img_layers[layer] + self.colour_bar = plt.colorbar(img, ax=self.ax, label=label, **kwargs) + + def add_legend( + self, + label='Grain area (μm$^2$)', + number=6, + layer=0, + scaling=1, + **kwargs + ): """Add a marker size legend to the pole plot. Parameters @@ -1185,38 +1251,41 @@ def addLegend(self, label='Grain area (μm$^2$)', number=6, layer=0, scaling=1, Other argument are passed to :func:`matplotlib.pyplot.legend`. """ - img = self.imgLayers[layer] - self.legend = plt.legend(*img.legend_elements("sizes", num=number, - func=lambda s: s / scaling), title=label, **kwargs) + img = self.img_layers[layer] + self.legend = plt.legend( + *img.legend_elements("sizes", num=number, func=lambda s: s / scaling), + title=label, + **kwargs + ) @staticmethod - def _validateProjection(projectionIn, validateDefault=False): - if validateDefault: - defaultProjection = None + def _validateProjection(projection_in, validate_default=False): + if validate_default: + default_projection = None else: - defaultProjection = PolePlot._validateProjection( - defaults['pole_projection'], validateDefault=True + default_projection = PolePlot._validateProjection( + defaults['pole_projection'], validate_default=True ) - if projectionIn is None: - projection = defaultProjection + if projection_in is None: + projection = default_projection - elif type(projectionIn) is str: - projectionName = projectionIn.replace(" ", "").lower() - if projectionName in ["lambert", "equalarea"]: - projection = PolePlot.lambertProject - elif projectionName in ["stereographic", "stereo", "equalangle"]: - projection = PolePlot.stereoProject + elif type(projection_in) is str: + projection_name = projection_in.replace(" ", "").lower() + if projection_name in ["lambert", "equalarea"]: + projection = PolePlot.lambert_project + elif projection_name in ["stereographic", "stereo", "equalangle"]: + projection = PolePlot.stereo_project else: print("Unknown projection name, using default") - projection = defaultProjection + projection = default_projection - elif callable(projectionIn): - projection = projectionIn + elif callable(projection_in): + projection = projection_in else: print("Unknown projection, using default") - projection = defaultProjection + projection = default_projection if projection is None: raise ValueError("Problem with default projection.") @@ -1224,7 +1293,7 @@ def _validateProjection(projectionIn, validateDefault=False): return projection @staticmethod - def stereoProject(*args): + def stereo_project(*args): """Stereographic projection of pole direction or pair of polar angles. Parameters @@ -1244,20 +1313,20 @@ def stereoProject(*args): """ if len(args) == 3: - alpha, beta = quat.Quat.polarAngles(args[0], args[1], args[2]) + alpha, beta = quat.Quat.polar_angles(args[0], args[1], args[2]) elif len(args) == 2: alpha, beta = args else: raise Exception("3 arguments for pole directions and 2 for polar angles.") - alphaComp = np.tan(alpha / 2) - xp = alphaComp * np.cos(beta) - yp = alphaComp * np.sin(beta) + alpha_comp = np.tan(alpha / 2) + xp = alpha_comp * np.cos(beta - np.pi/2) + yp = alpha_comp * np.sin(beta - np.pi/2) return xp, yp @staticmethod - def lambertProject(*args): + def lambert_project(*args): """Lambert Projection of pole direction or pair of polar angles. Parameters @@ -1277,15 +1346,15 @@ def lambertProject(*args): """ if len(args) == 3: - alpha, beta = quat.Quat.polarAngles(args[0], args[1], args[2]) + alpha, beta = quat.Quat.polar_angles(args[0], args[1], args[2]) elif len(args) == 2: alpha, beta = args else: raise Exception("3 arguments for pole directions and 2 for polar angles.") - alphaComp = np.sqrt(2 * (1 - np.cos(alpha))) - xp = alphaComp * np.cos(beta) - yp = alphaComp * np.sin(beta) + alpha_comp = np.sqrt(2 * (1 - np.cos(alpha))) + xp = alpha_comp * np.cos(beta - np.pi/2) + yp = alpha_comp * np.sin(beta - np.pi/2) return xp, yp @@ -1294,15 +1363,16 @@ class HistPlot(Plot): """ Class for creating a histogram. """ - def __init__(self, plotType = "scatter", axesType="linear", density=True, fig=None, - ax=None, axParams={}, makeInteractive=False, **kwargs): + + def __init__(self, plot_type="scatter", axes_type="linear", density=True, fig=None, + ax=None, ax_params={}, make_interactive=False, **kwargs): """Initialise a histogram plot Parameters ---------- - plotType: str, {'scatter', 'bar', 'step'} + plot_type: str, {'scatter', 'bar', 'step'} Type of plot to use - axesType : str, {'linear', 'logx', 'logy', 'loglog', 'None'}, optional + axes_type : str, {'linear', 'logx', 'logy', 'loglog', 'None'}, optional If 'log' is specified, logarithmic scale is used. density : If true, histogram is normalised such that the integral sums to 1. @@ -1310,29 +1380,29 @@ def __init__(self, plotType = "scatter", axesType="linear", density=True, fig=No Matplotlib figure to plot on. ax : matplotlib.axes.Axes Matplotlib axis to plot on. - axParams : - Passed to defdap.plotting.Plot as axParams. - makeInteractive : bool + ax_params : + Passed to defdap.plotting.Plot as ax_params. + make_interactive : bool If true, make the plot interactive. kwargs Other arguments are passed to :class:`defdap.plotting.Plot` """ super(HistPlot, self).__init__( - ax, axParams=axParams, fig=fig, makeInteractive=makeInteractive, + ax, ax_params=ax_params, fig=fig, make_interactive=make_interactive, **kwargs ) - axesType = axesType.lower() - if axesType in ["linear", "logy", "logx", "loglog"]: - self.axesType = axesType + axes_type = axes_type.lower() + if axes_type in ["linear", "logy", "logx", "loglog"]: + self.axes_type = axes_type else: - raise ValueError("plotType must be linear or log.") + raise ValueError("plot_type must be linear or log.") - if plotType in ['scatter', 'bar', 'step']: - self.plotType = plotType + if plot_type in ['scatter', 'bar', 'step']: + self.plot_type = plot_type else: - raise ValueError("plotType must be scatter, bar or step.") + raise ValueError("plot_type must be scatter, bar or step.") self.density = bool(density) @@ -1341,20 +1411,20 @@ def __init__(self, plotType = "scatter", axesType="linear", density=True, fig=No self.ax.set_ylabel(yLabel) # set axes to linear or log as appropriate and set to be numbers as opposed to scientific notation - if self.axesType == 'logx' or self.axesType == 'loglog': + if self.axes_type == 'logx' or self.axes_type == 'loglog': self.ax.set_xscale("log") self.ax.xaxis.set_major_formatter(FuncFormatter(lambda y, _: '{:.5g}'.format(y))) - if self.axesType == 'logy' or self.axesType == 'loglog': + if self.axes_type == 'logy' or self.axes_type == 'loglog': self.ax.set_yscale("log") self.ax.yaxis.set_major_formatter(FuncFormatter(lambda y, _: '{:.5g}'.format(y))) - def addHist(self, histData, bins=100, range=None, line='o', - label=None, **kwargs): + def add_hist(self, hist_data, bins=100, range=None, line='o', + label=None, **kwargs): """Add a histogram to the current plot Parameters ---------- - histData : numpy.ndarray + hist_data : numpy.ndarray Data to be used in the histogram. bins : int Number of bins to use for histogram. @@ -1370,26 +1440,25 @@ def addHist(self, histData, bins=100, range=None, line='o', """ # Generate the x bins with appropriate spaceing for linear or log - if self.axesType == 'logx' or self.axesType == 'loglog': - binList = np.logspace(np.log10(range[0]), np.log10(range[1]), bins) + if self.axes_type == 'logx' or self.axes_type == 'loglog': + bin_list = np.logspace(np.log10(range[0]), np.log10(range[1]), bins) else: - binList = np.linspace(range[0], range[1], bins) + bin_list = np.linspace(range[0], range[1], bins) - - if self.plotType == 'scatter': + if self.plot_type == 'scatter': # Generate the histogram data and plot as a scatter plot - hist = np.histogram(histData.flatten(), bins=binList, density=self.density) - yVals = hist[0] - xVals = 0.5 * (hist[1][1:] + hist[1][:-1]) + hist = np.histogram(hist_data.flatten(), bins=bin_list, density=self.density) + y_vals = hist[0] + x_vals = 0.5 * (hist[1][1:] + hist[1][:-1]) - self.ax.plot(xVals, yVals, line, label=label, **kwargs) + self.ax.plot(x_vals, y_vals, line, label=label, **kwargs) else: # Plot as a matplotlib histogram - self.ax.hist(histData.flatten(),bins=binList, histtype=self.plotType, + self.ax.hist(hist_data.flatten(), bins=bin_list, histtype=self.plot_type, density=self.density, label=label, **kwargs) - def addLegend(self, **kwargs): + def add_legend(self, **kwargs): """Add legend to histogram. Parameters @@ -1402,32 +1471,32 @@ def addLegend(self, **kwargs): @classmethod def create( - cls, histData, fig=None, figParams={}, ax=None, axParams={}, - plot=None, makeInteractive=False, - plotType = "scatter", axesType="linear", density=True, bins=10, range=None, - line='o', label=None, **kwargs + cls, hist_data, fig=None, fig_params={}, ax=None, ax_params={}, + plot=None, make_interactive=False, + plot_type="scatter", axes_type="linear", density=True, bins=10, range=None, + line='o', label=None, **kwargs ): """Create a histogram plot. Parameters ---------- - histData : numpy.ndarray + hist_data : numpy.ndarray Data to be used in the histogram. fig : matplotlib.figure.Figure Matplotlib figure to plot on. - figParams : + fig_params : Passed to defdap.plotting.Plot. ax : matplotlib.axes.Axes Matplotlib axis to plot on. - axParams : - Passed to defdap.plotting.Plot as axParams. + ax_params : + Passed to defdap.plotting.Plot as ax_params. plot : defdap.plotting.HistPlot Plot where histgram is created. If none, a new plot is created. - makeInteractive : bool, optional + make_interactive : bool, optional If true, make plot interactive. - plotType: str, {'scatter', 'bar', 'barfilled', 'step'} + plot_type: str, {'scatter', 'bar', 'barfilled', 'step'} Type of plot to use - axesType : str, {'linear', 'logx', 'logy', 'loglog', 'None'}, optional + axes_type : str, {'linear', 'logx', 'logy', 'loglog', 'None'}, optional If 'log' is specified, logarithmic scale is used. density : If true, histogram is normalised such that the integral sums to 1. @@ -1440,7 +1509,7 @@ def create( label : str, optional Label to use for data (is used for legend). kwargs - Other arguments are passed to :func:`defdap.plotting.HistPlot.addHist` + Other arguments are passed to :func:`defdap.plotting.HistPlot.add_hist` Returns ------- @@ -1448,11 +1517,11 @@ def create( """ if plot is None: - plot = cls(axesType=axesType, plotType=plotType, density=density, fig=fig, ax=ax, - axParams=axParams, makeInteractive=makeInteractive, - **figParams) - plot.addHist(histData, bins=bins, range=range, line=line, - label=label, **kwargs) + plot = cls(axes_type=axes_type, plot_type=plot_type, density=density, fig=fig, ax=ax, + ax_params=ax_params, make_interactive=make_interactive, + **fig_params) + plot.add_hist(hist_data, bins=bins, range=range, line=line, + label=label, **kwargs) return plot @@ -1461,8 +1530,9 @@ class CrystalPlot(Plot): """ Class for creating a 3D plot for plotting unit cells. """ - def __init__(self, fig=None, ax=None, axParams={}, - makeInteractive=False, **kwargs): + + def __init__(self, fig=None, ax=None, ax_params={}, + make_interactive=False, **kwargs): """Initialise a 3D plot. Parameters @@ -1471,32 +1541,32 @@ def __init__(self, fig=None, ax=None, axParams={}, Figure to plot to. ax : matplotlib.pyplot.Axis Axis to plot to. - axParams - Passed to defdap.plotting.Plot as axParams. - makeInteractive : bool, optional + ax_params + Passed to defdap.plotting.Plot as ax_params. + make_interactive : bool, optional If true, make plot interactive. kwargs Other arguments are passed to :class:`defdap.plotting.Plot`. """ # Set default plot parameters then update with input - figParams = { + fig_params = { 'figsize': (6, 6) } - figParams.update(kwargs) - axParamsDefault = { + fig_params.update(kwargs) + ax_params_default = { 'projection': '3d', 'proj_type': 'ortho' } - axParamsDefault.update(axParams) - axParams = axParamsDefault + ax_params_default.update(ax_params) + ax_params = ax_params_default super(CrystalPlot, self).__init__( - ax, axParams=axParams, fig=fig, makeInteractive=makeInteractive, - **figParams + ax, ax_params=ax_params, fig=fig, make_interactive=make_interactive, + **fig_params ) - def addVerts(self, verts, **kwargs): + def add_verts(self, verts, **kwargs): """Plots planes, defined by the vertices provided. Parameters @@ -1508,14 +1578,14 @@ def addVerts(self, verts, **kwargs): """ # Set default plot parameters then update with any input - plotParams = { + plot_params = { 'alpha': 0.6, 'facecolor': '0.8', 'linewidths': 3, 'edgecolor': 'k' } - plotParams.update(kwargs) + plot_params.update(kwargs) # Add list of planes defined by given vertices to the 3D plot - pc = Poly3DCollection(verts, **plotParams) + pc = Poly3DCollection(verts, **plot_params) self.ax.add_collection3d(pc) diff --git a/defdap/quat.py b/defdap/quat.py index 80adf97..d3a8d00 100755 --- a/defdap/quat.py +++ b/defdap/quat.py @@ -1,4 +1,4 @@ -# Copyright 2021 Mechanics of Microstructures Group +# Copyright 2025 Mechanics of Microstructures Group # at The University of Manchester # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -16,6 +16,7 @@ import numpy as np from defdap import plotting +from defdap import defaults from typing import Union, Tuple, List, Optional @@ -25,7 +26,7 @@ class Quat(object): are interpreted in the passive sense. """ - __slots__ = ['quatCoef'] + __slots__ = ['quat_coef'] def __init__(self, *args, allow_southern: Optional[bool] = False) -> None: """ @@ -44,11 +45,11 @@ def __init__(self, *args, allow_southern: Optional[bool] = False) -> None: if len(args) == 1: if len(args[0]) != 4: raise TypeError("Arrays input must have 4 elements") - self.quatCoef = np.array(args[0], dtype=float) + self.quat_coef = np.array(args[0], dtype=float) # construct with quat coefficients elif len(args) == 4: - self.quatCoef = np.array(args, dtype=float) + self.quat_coef = np.array(args, dtype=float) else: raise TypeError("Incorrect argument length. Input should be " @@ -56,11 +57,11 @@ def __init__(self, *args, allow_southern: Optional[bool] = False) -> None: "quat coefficients") # move to northern hemisphere - if not allow_southern and self.quatCoef[0] < 0: - self.quatCoef = self.quatCoef * -1 + if not allow_southern and self.quat_coef[0] < 0: + self.quat_coef = self.quat_coef * -1 @classmethod - def fromEulerAngles(cls, ph1: float, phi: float, ph2: float) -> 'Quat': + def from_euler_angles(cls, ph1: float, phi: float, ph2: float) -> 'Quat': """Create a quat object from 3 Bunge euler angles. Parameters @@ -79,7 +80,7 @@ def fromEulerAngles(cls, ph1: float, phi: float, ph2: float) -> 'Quat': """ # calculate quat coefficients - quatCoef = np.array([ + quat_coef = np.array([ np.cos(phi / 2.0) * np.cos((ph1 + ph2) / 2.0), -np.sin(phi / 2.0) * np.cos((ph1 - ph2) / 2.0), -np.sin(phi / 2.0) * np.sin((ph1 - ph2) / 2.0), @@ -87,10 +88,10 @@ def fromEulerAngles(cls, ph1: float, phi: float, ph2: float) -> 'Quat': ], dtype=float) # call constructor - return cls(quatCoef) + return cls(quat_coef) @classmethod - def fromAxisAngle(cls, axis: np.ndarray, angle: float) -> 'Quat': + def from_axis_angle(cls, axis: np.ndarray, angle: float) -> 'Quat': """Create a quat object from a rotation around an axis. This creates a quaternion to represent the passive rotation (-ve axis). @@ -111,14 +112,14 @@ def fromAxisAngle(cls, axis: np.ndarray, angle: float) -> 'Quat': axis = np.array(axis) axis = axis / np.sqrt(np.dot(axis, axis)) # calculate quat coefficients - quatCoef = np.zeros(4, dtype=float) - quatCoef[0] = np.cos(angle / 2) - quatCoef[1:4] = -np.sin(angle / 2) * axis + quat_coef = np.zeros(4, dtype=float) + quat_coef[0] = np.cos(angle / 2) + quat_coef[1:4] = -np.sin(angle / 2) * axis # call constructor - return cls(quatCoef) + return cls(quat_coef) - def eulerAngles(self) -> np.ndarray: + def euler_angles(self) -> np.ndarray: """Calculate the Euler angle representation for this rotation. Returns @@ -139,7 +140,7 @@ def eulerAngles(self) -> np.ndarray: """ eulers = np.empty(3, dtype=float) - q = self.quatCoef + q = self.quat_coef q03 = q[0]**2 + q[3]**2 q12 = q[1]**2 + q[2]**2 chi = np.sqrt(q03 * q12) @@ -155,18 +156,18 @@ def eulerAngles(self) -> np.ndarray: eulers[2] = 0 else: - cosPh1 = (-q[0] * q[1] - q[2] * q[3]) / chi - sinPh1 = (-q[0] * q[2] + q[1] * q[3]) / chi + cos_ph1 = (-q[0] * q[1] - q[2] * q[3]) / chi + sin_ph1 = (-q[0] * q[2] + q[1] * q[3]) / chi - cosPhi = q[0]**2 + q[3]**2 - q[1]**2 - q[2]**2 - sinPhi = 2 * chi + cos_phi = q[0]**2 + q[3]**2 - q[1]**2 - q[2]**2 + sin_phi = 2 * chi - cosPh2 = (-q[0] * q[1] + q[2] * q[3]) / chi - sinPh2 = (q[1] * q[3] + q[0] * q[2]) / chi + cos_ph2 = (-q[0] * q[1] + q[2] * q[3]) / chi + sin_ph2 = (q[1] * q[3] + q[0] * q[2]) / chi - eulers[0] = np.arctan2(sinPh1, cosPh1) - eulers[1] = np.arctan2(sinPhi, cosPhi) - eulers[2] = np.arctan2(sinPh2, cosPh2) + eulers[0] = np.arctan2(sin_ph1, cos_ph1) + eulers[1] = np.arctan2(sin_phi, cos_phi) + eulers[2] = np.arctan2(sin_ph2, cos_ph2) if eulers[0] < 0: eulers[0] += 2 * np.pi @@ -175,12 +176,12 @@ def eulerAngles(self) -> np.ndarray: return eulers - def rotMatrix(self) -> np.ndarray: + def rot_matrix(self) -> np.ndarray: """Calculate the rotation matrix representation for this rotation. Returns ------- - rotMatrix : numpy.ndarray, shape (3, 3) + rot_matrix : numpy.ndarray, shape (3, 3) Rotation matrix. References @@ -194,61 +195,61 @@ def rotMatrix(self) -> np.ndarray: Model. Simul. Mater. Sci. Eng., 23(8) """ - rotMatrix = np.empty((3, 3), dtype=float) + rot_matrix = np.empty((3, 3), dtype=float) - q = self.quatCoef + q = self.quat_coef qbar = q[0]**2 - q[1]**2 - q[2]**2 - q[3]**2 - rotMatrix[0, 0] = qbar + 2 * q[1]**2 - rotMatrix[0, 1] = 2 * (q[1] * q[2] - q[0] * q[3]) - rotMatrix[0, 2] = 2 * (q[1] * q[3] + q[0] * q[2]) + rot_matrix[0, 0] = qbar + 2 * q[1]**2 + rot_matrix[0, 1] = 2 * (q[1] * q[2] - q[0] * q[3]) + rot_matrix[0, 2] = 2 * (q[1] * q[3] + q[0] * q[2]) - rotMatrix[1, 0] = 2 * (q[1] * q[2] + q[0] * q[3]) - rotMatrix[1, 1] = qbar + 2 * q[2]**2 - rotMatrix[1, 2] = 2 * (q[2] * q[3] - q[0] * q[1]) + rot_matrix[1, 0] = 2 * (q[1] * q[2] + q[0] * q[3]) + rot_matrix[1, 1] = qbar + 2 * q[2]**2 + rot_matrix[1, 2] = 2 * (q[2] * q[3] - q[0] * q[1]) - rotMatrix[2, 0] = 2 * (q[1] * q[3] - q[0] * q[2]) - rotMatrix[2, 1] = 2 * (q[2] * q[3] + q[0] * q[1]) - rotMatrix[2, 2] = qbar + 2 * q[3]**2 + rot_matrix[2, 0] = 2 * (q[1] * q[3] - q[0] * q[2]) + rot_matrix[2, 1] = 2 * (q[2] * q[3] + q[0] * q[1]) + rot_matrix[2, 2] = qbar + 2 * q[3]**2 - return rotMatrix + return rot_matrix # show components when the quat is printed def __repr__(self) -> str: - return "[{:.4f}, {:.4f}, {:.4f}, {:.4f}]".format(*self.quatCoef) + return "[{:.4f}, {:.4f}, {:.4f}, {:.4f}]".format(*self.quat_coef) def __str__(self) -> str: return self.__repr__() def __eq__(self, right: 'Quat') -> bool: return (isinstance(right, type(self)) and - self.quatCoef.tolist() == right.quatCoef.tolist()) + self.quat_coef.tolist() == right.quat_coef.tolist()) def __hash__(self) -> int: - return hash(tuple(self.quatCoef.tolist())) + return hash(tuple(self.quat_coef.tolist())) def _plotIPF( self, direction: np.ndarray, - symGroup: str, + sym_group: str, **kwargs ) -> 'plotting.PolePlot': - Quat.plotIPF([self], direction, symGroup, **kwargs) + Quat.plot_ipf([self], direction, sym_group, **kwargs) # overload * operator for quaternion product and vector product def __mul__(self, right: 'Quat', allow_southern: bool = False) -> 'Quat': if isinstance(right, type(self)): # another quat - newQuatCoef = np.zeros(4, dtype=float) - newQuatCoef[0] = ( - self.quatCoef[0] * right.quatCoef[0] - - np.dot(self.quatCoef[1:4], right.quatCoef[1:4]) + new_quat_coef = np.zeros(4, dtype=float) + new_quat_coef[0] = ( + self.quat_coef[0] * right.quat_coef[0] - + np.dot(self.quat_coef[1:4], right.quat_coef[1:4]) ) - newQuatCoef[1:4] = ( - self.quatCoef[0] * right.quatCoef[1:4] + - right.quatCoef[0] * self.quatCoef[1:4] + - np.cross(self.quatCoef[1:4], right.quatCoef[1:4]) + new_quat_coef[1:4] = ( + self.quat_coef[0] * right.quat_coef[1:4] + + right.quat_coef[0] * self.quat_coef[1:4] + + np.cross(self.quat_coef[1:4], right.quat_coef[1:4]) ) - return Quat(newQuatCoef, allow_southern=allow_southern) + return Quat(new_quat_coef, allow_southern=allow_southern) raise TypeError("{:} - {:}".format(type(self), type(right))) @@ -267,28 +268,28 @@ def dot(self, right: 'Quat') -> float: """ if isinstance(right, type(self)): - return np.dot(self.quatCoef, right.quatCoef) + return np.dot(self.quat_coef, right.quat_coef) raise TypeError() # overload + operator def __add__(self, right: 'Quat') -> 'Quat': if isinstance(right, type(self)): - return Quat(self.quatCoef + right.quatCoef) + return Quat(self.quat_coef + right.quat_coef) raise TypeError() # overload += operator def __iadd__(self, right: 'Quat') -> 'Quat': if isinstance(right, type(self)): - self.quatCoef += right.quatCoef + self.quat_coef += right.quat_coef return self raise TypeError() # allow array like setting/getting of components def __getitem__(self, key: int) -> float: - return self.quatCoef[key] + return self.quat_coef[key] def __setitem__(self, key: int, value: float) -> None: - self.quatCoef[key] = value + self.quat_coef[key] = value def norm(self) -> float: """Calculate the norm of the quaternion. @@ -299,7 +300,7 @@ def norm(self) -> float: Norm of the quaternion. """ - return np.sqrt(np.dot(self.quatCoef[0:4], self.quatCoef[0:4])) + return np.sqrt(np.dot(self.quat_coef[0:4], self.quat_coef[0:4])) def normalise(self) -> 'Quat': """ Normalise the quaternion (turn it into an unit quaternion). @@ -310,7 +311,7 @@ def normalise(self) -> 'Quat': Normalised quaternion. """ - self.quatCoef /= self.norm() + self.quat_coef /= self.norm() return # also the inverse if this is a unit quaternion @@ -326,7 +327,7 @@ def conjugate(self) -> 'Quat': """ return Quat(self[0], -self[1], -self[2], -self[3]) - def transformVector( + def transform_vector( self, vector: Union[Tuple, List, np.ndarray] ) -> np.ndarray: @@ -354,18 +355,18 @@ def transformVector( if np.array(vector).shape != (3,): raise TypeError("Vector must be length 3.") - vectorQuat = Quat(0, *vector) - vectorQuatTransformed = self.__mul__( - vectorQuat.__mul__(self.conjugate, allow_southern=True), + vector_quat = Quat(0, *vector) + vector_quat_transformed = self.__mul__( + vector_quat.__mul__(self.conjugate, allow_southern=True), allow_southern=True ) - return vectorQuatTransformed.quatCoef[1:4] + return vector_quat_transformed.quat_coef[1:4] - def misOri( + def mis_ori( self, right: 'Quat', - symGroup: str, - returnQuat: Optional[int] = 0 + sym_group: str, + return_quat: Optional[int] = 0 ) -> Tuple[float, 'Quat']: """ Calculate misorientation angle between 2 orientations taking @@ -376,9 +377,9 @@ def misOri( ---------- right Orientation to find misorientation to. - symGroup + sym_group Crystal type (cubic, hexagonal). - returnQuat + return_quat What to return: 0 for minimum misorientation, 1 for symmetric equivalent with minimum misorientation, 2 for both. @@ -392,24 +393,24 @@ def misOri( """ if isinstance(right, type(self)): # looking for max of this as it is cos of misorientation angle - minMisOri = 0 + min_mis_ori = 0 # loop over symmetrically equivalent orientations - for sym in Quat.symEqv(symGroup): - quatSym = sym * right - currentMisOri = abs(self.dot(quatSym)) - if currentMisOri > minMisOri: # keep if misorientation lower - minMisOri = currentMisOri - minQuatSym = quatSym - - if returnQuat == 1: - return minQuatSym - elif returnQuat == 2: - return minMisOri, minQuatSym + for sym in Quat.sym_eqv(sym_group): + quat_sym = sym * right + current_mis_ori = abs(self.dot(quat_sym)) + if current_mis_ori > min_mis_ori: # keep if misorientation lower + min_mis_ori = current_mis_ori + min_quat_sym = quat_sym + + if return_quat == 1: + return min_quat_sym + elif return_quat == 2: + return min_mis_ori, min_quat_sym else: - return minMisOri + return min_mis_ori raise TypeError("Input must be a quaternion.") - def misOriAxis(self, right: 'Quat') -> np.ndarray: + def mis_ori_axis(self, right: 'Quat') -> np.ndarray: """ Calculate misorientation axis between 2 orientations. This does not consider symmetries of the crystal structure. @@ -427,24 +428,24 @@ def misOriAxis(self, right: 'Quat') -> np.ndarray: """ if isinstance(right, type(self)): Dq = right * self.conjugate - Dq = Dq.quatCoef - misOriAxis = 2 * Dq[1:4] * np.arccos(Dq[0]) / np.sqrt(1 - Dq[0]**2) - return misOriAxis + Dq = Dq.quat_coef + mis_ori_axis = 2 * Dq[1:4] * np.arccos(Dq[0]) / np.sqrt(1 - Dq[0]**2) + return mis_ori_axis raise TypeError("Input must be a quaternion.") - def plotIPF( + def plot_ipf( self, direction: np.ndarray, - symGroup: str, + sym_group: str, projection: Optional[str] = None, plot: Optional['plotting.Plot'] = None, fig: Optional['matplotlib.figure.Figure'] = None, ax: Optional['matplotlib.axes.Axes'] = None, - plotColourBar: Optional[bool] = False, + plot_colour_bar: Optional[bool] = False, clabel: Optional[str] = "", - makeInteractive: Optional[bool] = False, - markerColour: Optional[Union[List[str], str]] = None, - markerSize: Optional[float] = 40, + make_interactive: Optional[bool] = False, + marker_colour: Optional[Union[List[str], str]] = None, + marker_size: Optional[float] = 40, **kwargs ) -> 'plotting.PolePlot': """ @@ -454,7 +455,7 @@ def plotIPF( ---------- direction Sample reference direction for IPF. - symGroup + sym_group Crystal type (cubic, hexagonal). projection Projection to use. Either string (stereographic or lambert) @@ -467,24 +468,24 @@ def plotIPF( ax Axis to plot on, if not provided the current active axis is used. - makeInteractive + make_interactive If true, make the plot interactive. - plotColourBar : bool + plot_colour_bar : bool If true, plot a colour bar next to the map. clabel : str Label for the colour bar. - markerColour: str or list of str + marker_colour: str or list of str Colour of markers (only used for half and half colouring, otherwise use argument c). - markerSize + marker_size Size of markers (only used for half and half colouring, otherwise use argument s). kwargs - All other arguments are passed to :func:`defdap.plotting.PolePlot.addPoints`. + All other arguments are passed to :func:`defdap.plotting.PolePlot.add_points`. """ - plotParams = {'marker': '+'} - plotParams.update(kwargs) + plot_params = {'marker': '+'} + plot_params.update(kwargs) # Works as an instance or static method on a list of Quats if isinstance(self, Quat): @@ -492,39 +493,39 @@ def plotIPF( else: quats = self - alphaFund, betaFund = Quat.calcFundDirs(quats, direction, symGroup) + alpha_fund, beta_fund = Quat.calc_fund_dirs(quats, direction, sym_group) if plot is None: plot = plotting.PolePlot( - "IPF", symGroup, projection=projection, - ax=ax, fig=fig, makeInteractive=makeInteractive + "IPF", sym_group, projection=projection, + ax=ax, fig=fig, make_interactive=make_interactive ) - plot.addPoints( - alphaFund, betaFund, - markerColour=markerColour, markerSize=markerSize, - **plotParams + plot.add_points( + alpha_fund, beta_fund, + marker_colour=marker_colour, marker_size=marker_size, + **plot_params ) - if plotColourBar: - plot.addColourBar(clabel) + if plot_colour_bar: + plot.add_colour_bar(clabel) return plot - def plotUnitCell( + def plot_unit_cell( self, - crystalStructure: 'defdap.crystal.CrystalStructure', + crystal_structure: 'defdap.crystal.CrystalStructure', OI: Optional[bool] = True, plot: Optional['plotting.CrystalPlot'] = None, fig: Optional['matplotlib.figure.Figure'] = None, ax: Optional['matplotlib.axes.Axes'] = None, - makeInteractive: Optional[bool] = False, + make_interactive: Optional[bool] = False, **kwargs ) -> 'plotting.CrystalPlot': """Plots a unit cell. Parameters ---------- - crystalStructure + crystal_structure Crystal structure. OI True if using oxford instruments system. @@ -534,38 +535,38 @@ def plotUnitCell( Figure to plot on, if not provided the current active axis is used. ax Axis to plot on, if not provided the current active axis is used. - makeInteractive + make_interactive True to make the plot interactive. kwargs - All other arguments are passed to :func:`defdap.plotting.CrystalPlot.addVerts`. + All other arguments are passed to :func:`defdap.plotting.CrystalPlot.add_verts`. """ # Set default plot parameters then update with any input - plotParams = {} - plotParams.update(kwargs) + plot_params = {} + plot_params.update(kwargs) # TODO: most of this should be moved to either the crystal or # plotting module - vert = crystalStructure.vertices - faces = crystalStructure.faces + vert = crystal_structure.vertices + faces = crystal_structure.faces - if crystalStructure.name == 'hexagonal': - szFac = 0.18 + if crystal_structure.name == 'hexagonal': + sz_fac = 0.18 if OI: # Add 30 degrees to phi2 for OI - eulerAngles = self.eulerAngles() + eulerAngles = self.euler_angles() eulerAngles[2] += np.pi / 6 - gg = Quat.fromEulerAngles(*eulerAngles).rotMatrix().T + gg = Quat.from_euler_angles(*eulerAngles).rot_matrix().T else: - gg = self.rotMatrix().T + gg = self.rot_matrix().T - elif crystalStructure.name == 'cubic': - szFac = 0.25 - gg = self.rotMatrix().T + elif crystal_structure.name == 'cubic': + sz_fac = 0.25 + gg = self.rot_matrix().T # Rotate the lattice cell points - pts = np.matmul(gg, vert.T).T * szFac + pts = np.matmul(gg, vert.T).T * sz_fac # Plot unit cell planes = [] @@ -574,7 +575,7 @@ def plotUnitCell( if plot is None: plot = plotting.CrystalPlot( - ax=ax, fig=fig, makeInteractive=makeInteractive + ax=ax, fig=fig, make_interactive=make_interactive ) plot.ax.set_xlim3d(-0.15, 0.15) @@ -583,14 +584,14 @@ def plotUnitCell( plot.ax.view_init(azim=270, elev=90) plot.ax._axis3don = False - plot.addVerts(planes, **plotParams) + plot.add_verts(planes, **plot_params) return plot # Static methods @staticmethod - def createManyQuats(eulerArray: np.ndarray) -> np.ndarray: + def create_many_quats(eulerArray: np.ndarray) -> np.ndarray: """Create a an array of quats from an array of Euler angles. Parameters @@ -607,24 +608,24 @@ def createManyQuats(eulerArray: np.ndarray) -> np.ndarray: ph1 = eulerArray[0] phi = eulerArray[1] ph2 = eulerArray[2] - oriShape = eulerArray.shape[1:] + ori_shape = eulerArray.shape[1:] - quatComps = np.zeros((4,) + oriShape, dtype=float) + quat_comps = np.zeros((4,) + ori_shape, dtype=float) - quatComps[0] = np.cos(phi / 2.0) * np.cos((ph1 + ph2) / 2.0) - quatComps[1] = -np.sin(phi / 2.0) * np.cos((ph1 - ph2) / 2.0) - quatComps[2] = -np.sin(phi / 2.0) * np.sin((ph1 - ph2) / 2.0) - quatComps[3] = -np.cos(phi / 2.0) * np.sin((ph1 + ph2) / 2.0) + quat_comps[0] = np.cos(phi / 2.0) * np.cos((ph1 + ph2) / 2.0) + quat_comps[1] = -np.sin(phi / 2.0) * np.cos((ph1 - ph2) / 2.0) + quat_comps[2] = -np.sin(phi / 2.0) * np.sin((ph1 - ph2) / 2.0) + quat_comps[3] = -np.cos(phi / 2.0) * np.sin((ph1 + ph2) / 2.0) - quats = np.empty(oriShape, dtype=Quat) + quats = np.empty(ori_shape, dtype=Quat) - for i, idx in enumerate(np.ndindex(oriShape)): - quats[idx] = Quat(quatComps[(slice(None),) + idx]) + for i, idx in enumerate(np.ndindex(ori_shape)): + quats[idx] = Quat(quat_comps[(slice(None),) + idx]) return quats @staticmethod - def multiplyManyQuats(quats: List['Quat'], right: 'Quat') -> List['Quat']: + def multiply_many_quats(quats: List['Quat'], right: 'Quat') -> List['Quat']: """ Multiply all quats in a list of quats, by a single quat. Parameters @@ -639,17 +640,17 @@ def multiplyManyQuats(quats: List['Quat'], right: 'Quat') -> List['Quat']: list(defdap.quat.Quat) """ - quatArray = np.array([q.quatCoef for q in quats]) + quat_array = np.array([q.quat_coef for q in quats]) - tempArray = np.zeros((len(quatArray),4), dtype=float) - tempArray[...,0] = ((quatArray[...,0] * right.quatCoef[0]) - - np.dot(quatArray[...,1:4], right.quatCoef[1:4])) + temp_array = np.zeros((len(quat_array),4), dtype=float) + temp_array[...,0] = ((quat_array[...,0] * right.quat_coef[0]) - + np.dot(quat_array[...,1:4], right.quat_coef[1:4])) - tempArray[...,1:4] = ((quatArray[...,0,None] * right.quatCoef[None,1:4]) + - (right.quatCoef[0] * quatArray[...,1:4]) + - np.cross(quatArray[...,1:4], right.quatCoef[1:4])) + temp_array[...,1:4] = ((quat_array[...,0,None] * right.quat_coef[None, 1:4]) + + (right.quat_coef[0] * quat_array[..., 1:4]) + + np.cross(quat_array[...,1:4], right.quat_coef[1:4])) - return [Quat(coefs) for coefs in tempArray] + return [Quat(coefs) for coefs in temp_array] @staticmethod def extract_quat_comps(quats: np.ndarray) -> np.ndarray: @@ -672,14 +673,14 @@ def extract_quat_comps(quats: np.ndarray) -> np.ndarray: quats = np.array(quats) quat_comps = np.empty((4,) + quats.shape) for idx in np.ndindex(quats.shape): - quat_comps[(slice(None),) + idx] = quats[idx].quatCoef + quat_comps[(slice(None),) + idx] = quats[idx].quat_coef return quat_comps @staticmethod - def calcSymEqvs( + def calc_sym_eqvs( quats: np.ndarray, - symGroup: str, + sym_group: str, dtype: Optional[type] = float ) -> np.ndarray: """Calculate all symmetrically equivalent quaternions of given quaternions. @@ -688,124 +689,124 @@ def calcSymEqvs( ---------- quats : numpy.ndarray(defdap.quat.Quat) Array of quat objects. - symGroup + sym_group Crystal type (cubic, hexagonal). dtype - Data type used for calculation, defaults to `float`. + Datatype used for calculation, defaults to `float`. Returns ------- - quatComps: numpy.ndarray, shape: (numSym x 4 x numQuats) + quat_comps: numpy.ndarray, shape: (numSym x 4 x numQuats) Array containing all symmetrically equivalent quaternion components of input quaternions. """ - syms = Quat.symEqv(symGroup) - quatComps = np.empty((len(syms), 4, len(quats)), dtype=dtype) + syms = Quat.sym_eqv(sym_group) + quat_comps = np.empty((len(syms), 4, len(quats)), dtype=dtype) # store quat components in array - quatComps[0] = Quat.extract_quat_comps(quats) + quat_comps[0] = Quat.extract_quat_comps(quats) # calculate symmetrical equivalents for i, sym in enumerate(syms[1:], start=1): # sym[i] * quat for all points (* is quaternion product) - quatComps[i, 0, :] = ( - quatComps[0, 0, :] * sym[0] - quatComps[0, 1, :] * sym[1] - - quatComps[0, 2, :] * sym[2] - quatComps[0, 3, :] * sym[3]) - quatComps[i, 1, :] = ( - quatComps[0, 0, :] * sym[1] + quatComps[0, 1, :] * sym[0] - - quatComps[0, 2, :] * sym[3] + quatComps[0, 3, :] * sym[2]) - quatComps[i, 2, :] = ( - quatComps[0, 0, :] * sym[2] + quatComps[0, 2, :] * sym[0] - - quatComps[0, 3, :] * sym[1] + quatComps[0, 1, :] * sym[3]) - quatComps[i, 3, :] = ( - quatComps[0, 0, :] * sym[3] + quatComps[0, 3, :] * sym[0] - - quatComps[0, 1, :] * sym[2] + quatComps[0, 2, :] * sym[1]) + quat_comps[i, 0, :] = ( + quat_comps[0, 0, :] * sym[0] - quat_comps[0, 1, :] * sym[1] - + quat_comps[0, 2, :] * sym[2] - quat_comps[0, 3, :] * sym[3]) + quat_comps[i, 1, :] = ( + quat_comps[0, 0, :] * sym[1] + quat_comps[0, 1, :] * sym[0] - + quat_comps[0, 2, :] * sym[3] + quat_comps[0, 3, :] * sym[2]) + quat_comps[i, 2, :] = ( + quat_comps[0, 0, :] * sym[2] + quat_comps[0, 2, :] * sym[0] - + quat_comps[0, 3, :] * sym[1] + quat_comps[0, 1, :] * sym[3]) + quat_comps[i, 3, :] = ( + quat_comps[0, 0, :] * sym[3] + quat_comps[0, 3, :] * sym[0] - + quat_comps[0, 1, :] * sym[2] + quat_comps[0, 2, :] * sym[1]) # swap into positive hemisphere if required - quatComps[i, :, quatComps[i, 0, :] < 0] *= -1 + quat_comps[i, :, quat_comps[i, 0, :] < 0] *= -1 - return quatComps + return quat_comps @staticmethod - def calcAverageOri( - quatComps: np.ndarray + def calc_average_ori( + quat_comps: np.ndarray ) -> 'Quat': """Calculate the average orientation of given quats. Parameters ---------- - quatComps : numpy.ndarray + quat_comps : numpy.ndarray Array containing all symmetrically equivalent quaternion components of given quaternions - (shape: numSym x 4 x numQuats), can be calculated with :func:`Quat.calcSymEqvs`. + (shape: numSym x 4 x numQuats), can be calculated with :func:`Quat.calc_sym_eqvs`. Returns ------- - avOri : defdap.quat.Quat + av_ori : defdap.quat.Quat Average orientation of input quaternions. """ - avOri = np.copy(quatComps[0, :, 0]) - currMisOris = np.empty(quatComps.shape[0]) + av_ori = np.copy(quat_comps[0, :, 0]) + curr_mis_oris = np.empty(quat_comps.shape[0]) - for i in range(1, quatComps.shape[2]): + for i in range(1, quat_comps.shape[2]): # calculate misorientation between current average and all # symmetrical equivalents. Dot product of each symm quat in # quatComps with refOri for point i - currMisOris[:] = abs(np.einsum( - "ij,j->i", quatComps[:, :, i], avOri + curr_mis_oris[:] = abs(np.einsum( + "ij,j->i", quat_comps[:, :, i], av_ori )) # find min misorientation with current average then add to it - maxIdx = np.argmax(currMisOris[:]) - avOri += quatComps[maxIdx, :, i] + max_idx = np.argmax(curr_mis_oris[:]) + av_ori += quat_comps[max_idx, :, i] # Convert components back to a quat and normalise - avOri = Quat(avOri) - avOri.normalise() + av_ori = Quat(av_ori) + av_ori.normalise() - return avOri + return av_ori @staticmethod def calcMisOri( - quatComps: np.ndarray, - refOri: 'Quat' + quat_comps: np.ndarray, + ref_ori: 'Quat' ) -> Tuple[np.ndarray, 'Quat']: """Calculate the misorientation between the quaternions and a reference quaternion. Parameters ---------- - quatComps + quat_comps Array containing all symmetrically equivalent quaternion components of given quaternions - (shape: numSym x 4 x numQuats), can be calculated from quats with :func:`Quat.calcSymEqvs` . - refOri + (shape: numSym x 4 x numQuats), can be calculated from quats with :func:`Quat.calc_sym_eqvs` . + ref_ori Reference orientation. Returns ------- - minMisOris : numpy.ndarray, len numQuats + min_mis_oris : numpy.ndarray, len numQuats Minimum misorientation between quats and reference orientation. - minQuatComps : defdap.quat.Quat + min_quat_comps : defdap.quat.Quat Quaternion components describing minimum misorientation between quats and reference orientation. """ - misOris = np.empty((quatComps.shape[0], quatComps.shape[2])) + mis_oris = np.empty((quat_comps.shape[0], quat_comps.shape[2])) # Dot product of each quat in quatComps with refOri - misOris[:, :] = abs(np.einsum("ijk,j->ik", quatComps, refOri.quatCoef)) + mis_oris[:, :] = abs(np.einsum("ijk,j->ik", quat_comps, ref_ori.quat_coef)) - maxIdxs0 = np.argmax(misOris, axis=0) - maxIdxs1 = np.arange(misOris.shape[1]) + max_idxs0 = np.argmax(mis_oris, axis=0) + max_idxs1 = np.arange(mis_oris.shape[1]) - minMisOris = misOris[maxIdxs0, maxIdxs1] + min_mis_oris = mis_oris[max_idxs0, max_idxs1] - minQuatComps = quatComps[maxIdxs0, :, maxIdxs1].transpose() + min_quat_comps = quat_comps[max_idxs0, :, max_idxs1].transpose() - minMisOris[minMisOris > 1] = 1 + min_mis_oris[min_mis_oris > 1] = 1 - return minMisOris, minQuatComps + return min_mis_oris, min_quat_comps @staticmethod - def polarAngles(x: np.ndarray, y: np.ndarray, z: np.ndarray): + def polar_angles(x: np.ndarray, y: np.ndarray, z: np.ndarray): """Convert Cartesian coordinates to polar coordinates, for an unit vector. @@ -836,10 +837,10 @@ def polarAngles(x: np.ndarray, y: np.ndarray, z: np.ndarray): return alpha, beta @staticmethod - def calcIPFcolours( + def calc_ipf_colours( quats: np.ndarray, direction: np.ndarray, - symGroup: str, + sym_group: str, dtype: Optional[type] = np.float32 ) -> np.ndarray: """ @@ -852,14 +853,14 @@ def calcIPFcolours( Array of quat objects. direction Direction in sample space. - symGroup + sym_group Crystal type (cubic, hexagonal). dtype Data type to use for calculation. Returns ------- - numpy.ndarray, shape (3, numQuats) + numpy.ndarray, shape (3, num_quats) Array of rgb colours for each quat. References @@ -868,87 +869,94 @@ def calcIPFcolours( https://github.com/BYU-MicrostructureOfMaterials/OpenXY/blob/master/Code/PlotIPF.m """ - numQuats = len(quats) + num_quats = len(quats) - alphaFund, betaFund = Quat.calcFundDirs( - quats, direction, symGroup, dtype=dtype + alpha_fund, beta_fund = Quat.calc_fund_dirs( + quats, direction, sym_group, triangle='up', dtype=dtype ) # revert to cartesians - dirvec = np.empty((3, numQuats), dtype=dtype) - dirvec[0, :] = np.sin(alphaFund) * np.cos(betaFund) - dirvec[1, :] = np.sin(alphaFund) * np.sin(betaFund) - dirvec[2, :] = np.cos(alphaFund) - - if symGroup == 'cubic': - poleDirections = np.array([[0, 0, 1], - [1, 0, 1]/np.sqrt(2), - [1, 1, 1]/np.sqrt(3)], dtype=dtype) - if symGroup == 'hexagonal': - poleDirections = np.array([[0, 0, 1], - [np.sqrt(3), 1, 0]/np.sqrt(4), - [1, 0, 0]], dtype=dtype) - - rvect = np.broadcast_to(poleDirections[0].reshape((-1, 1)), (3, numQuats)) - gvect = np.broadcast_to(poleDirections[1].reshape((-1, 1)), (3, numQuats)) - bvect = np.broadcast_to(poleDirections[2].reshape((-1, 1)), (3, numQuats)) - - rgb = np.zeros((3, numQuats), dtype=dtype) + dirvec = np.empty((3, num_quats), dtype=dtype) + dirvec[0, :] = np.sin(alpha_fund) * np.cos(beta_fund) + dirvec[1, :] = np.sin(alpha_fund) * np.sin(beta_fund) + dirvec[2, :] = np.cos(alpha_fund) + + if sym_group == 'cubic': + pole_directions = np.array([ + [0, 0, 1], + [0, 1, 1]/np.sqrt(2), + [-1, 1, 1]/np.sqrt(3) + ], dtype=dtype) + elif sym_group == 'hexagonal': + pole_directions = np.array([ + [0, 0, 1], + [0, 1, 0], + [-0.5, np.sqrt(3)/2, 0] + ], dtype=dtype) + else: + raise ValueError(f'Unknown sym_group `{sym_group}`') + + rvect = np.broadcast_to(pole_directions[0].reshape((-1, 1)), (3, num_quats)) + gvect = np.broadcast_to(pole_directions[1].reshape((-1, 1)), (3, num_quats)) + bvect = np.broadcast_to(pole_directions[2].reshape((-1, 1)), (3, num_quats)) + + rgb = np.zeros((3, num_quats), dtype=dtype) # Red Component - RDirPlane = np.cross(dirvec, rvect, axis=0) - GBplane = np.cross(bvect, gvect, axis=0) - Rintersect = np.cross(RDirPlane, GBplane, axis=0) - NORM = np.linalg.norm(Rintersect, axis=0, keepdims=True) - NORM[NORM == 0] = 1 #Prevent division by zero - Rintersect /= NORM - - temp = np.arccos(np.clip(np.einsum("ij,ij->j", dirvec, Rintersect), -1, 1)) - Rintersect[:, temp > (np.pi / 2)] *= -1 + r_dir_plane = np.cross(dirvec, rvect, axis=0) + gb_plane = np.cross(bvect, gvect, axis=0) + r_intersect = np.cross(r_dir_plane, gb_plane, axis=0) + r_norm = np.linalg.norm(r_intersect, axis=0, keepdims=True) + r_norm[r_norm == 0] = 1 #Prevent division by zero + r_intersect /= r_norm + + temp = np.arccos(np.clip(np.einsum("ij,ij->j", dirvec, r_intersect), -1, 1)) + r_intersect[:, temp > (np.pi / 2)] *= -1 rgb[0, :] = np.divide( - np.arccos(np.clip(np.einsum("ij,ij->j", dirvec, Rintersect), -1, 1)), - np.arccos(np.clip(np.einsum("ij,ij->j", rvect, Rintersect), -1, 1)) + np.arccos(np.clip(np.einsum("ij,ij->j", dirvec, r_intersect), -1, 1)), + np.arccos(np.clip(np.einsum("ij,ij->j", rvect, r_intersect), -1, 1)) ) # Green Component - GDirPlane = np.cross(dirvec, gvect, axis=0) - RBplane = np.cross(rvect, bvect, axis=0) - Gintersect = np.cross(GDirPlane, RBplane, axis=0) - NORM = np.linalg.norm(Gintersect, axis=0, keepdims=True) - NORM[NORM == 0] = 1 #Prevent division by zero - Gintersect /= NORM - - temp = np.arccos(np.clip(np.einsum("ij,ij->j", dirvec, Gintersect), -1, 1)) - Gintersect[:, temp > (np.pi / 2)] *= -1 + g_dir_plane = np.cross(dirvec, gvect, axis=0) + rb_plane = np.cross(rvect, bvect, axis=0) + g_intersect = np.cross(g_dir_plane, rb_plane, axis=0) + g_norm = np.linalg.norm(g_intersect, axis=0, keepdims=True) + g_norm[g_norm == 0] = 1 #Prevent division by zero + g_intersect /= g_norm + + temp = np.arccos(np.clip(np.einsum("ij,ij->j", dirvec, g_intersect), -1, 1)) + g_intersect[:, temp > (np.pi / 2)] *= -1 rgb[1, :] = np.divide( - np.arccos(np.clip(np.einsum("ij,ij->j", dirvec, Gintersect), -1, 1)), - np.arccos(np.clip(np.einsum("ij,ij->j", gvect, Gintersect), -1, 1)) + np.arccos(np.clip(np.einsum("ij,ij->j", dirvec, g_intersect), -1, 1)), + np.arccos(np.clip(np.einsum("ij,ij->j", gvect, g_intersect), -1, 1)) ) # Blue Component - BDirPlane = np.cross(dirvec, bvect, axis=0) - RGplane = np.cross(gvect, rvect, axis=0) - Bintersect = np.cross(BDirPlane, RGplane, axis=0) - NORM = np.linalg.norm(Bintersect, axis=0, keepdims=True) - NORM[NORM == 0] = 1 #Prevent division by zero - Bintersect /= NORM - - temp = np.arccos(np.clip(np.einsum("ij,ij->j", dirvec, Bintersect), -1, 1)) - Bintersect[:, temp > (np.pi / 2)] *= -1 + b_dir_plane = np.cross(dirvec, bvect, axis=0) + rg_plane = np.cross(gvect, rvect, axis=0) + b_intersect = np.cross(b_dir_plane, rg_plane, axis=0) + b_norm = np.linalg.norm(b_intersect, axis=0, keepdims=True) + b_norm[b_norm == 0] = 1 #Prevent division by zero + b_intersect /= b_norm + + temp = np.arccos(np.clip(np.einsum("ij,ij->j", dirvec, b_intersect), -1, 1)) + b_intersect[:, temp > (np.pi / 2)] *= -1 rgb[2, :] = np.divide( - np.arccos(np.clip(np.einsum("ij,ij->j", dirvec, Bintersect), -1, 1)), - np.arccos(np.clip(np.einsum("ij,ij->j", bvect, Bintersect), -1, 1)) + np.arccos(np.clip(np.einsum("ij,ij->j", dirvec, b_intersect), -1, 1)), + np.arccos(np.clip(np.einsum("ij,ij->j", bvect, b_intersect), -1, 1)) ) rgb /= np.amax(rgb, axis=0) return rgb @staticmethod - def calcFundDirs( + def calc_fund_dirs( quats: np.ndarray, direction: np.ndarray, - symGroup: str, - dtype: Optional[type] = float + sym_group: str, + dtype: Optional[type] = float, + triangle: Optional[str] = None, ) -> Tuple[np.ndarray, np.ndarray]: """ Transform the sample direction to crystal coords based on the quats @@ -960,10 +968,13 @@ def calcFundDirs( Array of quat objects. direction Direction in sample space. - symGroup + sym_group Crystal type (cubic, hexagonal). dtype Data type to use for calculation. + triangle: str, optional + Triangle convention to use for hexagonal symmetry (up, down). If None, + defaults to the value in `defaults['ipf_triangle_convention']`. Returns ------- @@ -975,106 +986,103 @@ def calcFundDirs( direction = np.array(direction, dtype=dtype) # get array of symmetry operations. shape - (numSym, 4, numQuats) - quatCompsSym = Quat.calcSymEqvs(quats, symGroup, dtype=dtype) + quat_comps_sym = Quat.calc_sym_eqvs(quats, sym_group, dtype=dtype) # array to store crystal directions for all orientations and symmetries - directionCrystal = np.empty( - (3, quatCompsSym.shape[0], quatCompsSym.shape[2]), dtype=dtype + direction_crystal = np.empty( + (3, quat_comps_sym.shape[0], quat_comps_sym.shape[2]), dtype=dtype ) # temp variables to use below - quatDotVec = (quatCompsSym[:, 1, :] * direction[0] + - quatCompsSym[:, 2, :] * direction[1] + - quatCompsSym[:, 3, :] * direction[2]) - temp = (np.square(quatCompsSym[:, 0, :]) - - np.square(quatCompsSym[:, 1, :]) - - np.square(quatCompsSym[:, 2, :]) - - np.square(quatCompsSym[:, 3, :])) + quat_dot_vec = (quat_comps_sym[:, 1, :] * direction[0] + + quat_comps_sym[:, 2, :] * direction[1] + + quat_comps_sym[:, 3, :] * direction[2]) + temp = (np.square(quat_comps_sym[:, 0, :]) - + np.square(quat_comps_sym[:, 1, :]) - + np.square(quat_comps_sym[:, 2, :]) - + np.square(quat_comps_sym[:, 3, :])) # transform the pole direction to crystal coords for all # orientations and symmetries - # (quatCompsSym * vectorQuat) * quatCompsSym.conjugate - directionCrystal[0, :, :] = ( - 2 * quatDotVec * quatCompsSym[:, 1, :] + + # (quat_comps_sym * vectorQuat) * quat_comps_sym.conjugate + direction_crystal[0, :, :] = ( + 2 * quat_dot_vec * quat_comps_sym[:, 1, :] + temp * direction[0] + - 2 * quatCompsSym[:, 0, :] * ( - quatCompsSym[:, 2, :] * direction[2] - - quatCompsSym[:, 3, :] * direction[1] + 2 * quat_comps_sym[:, 0, :] * ( + quat_comps_sym[:, 2, :] * direction[2] - + quat_comps_sym[:, 3, :] * direction[1] ) ) - directionCrystal[1, :, :] = ( - 2 * quatDotVec * quatCompsSym[:, 2, :] + + direction_crystal[1, :, :] = ( + 2 * quat_dot_vec * quat_comps_sym[:, 2, :] + temp * direction[1] + - 2 * quatCompsSym[:, 0, :] * ( - quatCompsSym[:, 3, :] * direction[0] - - quatCompsSym[:, 1, :] * direction[2] + 2 * quat_comps_sym[:, 0, :] * ( + quat_comps_sym[:, 3, :] * direction[0] - + quat_comps_sym[:, 1, :] * direction[2] ) ) - directionCrystal[2, :, :] = ( - 2 * quatDotVec * quatCompsSym[:, 3, :] + + direction_crystal[2, :, :] = ( + 2 * quat_dot_vec * quat_comps_sym[:, 3, :] + temp * direction[2] + - 2 * quatCompsSym[:, 0, :] * ( - quatCompsSym[:, 1, :] * direction[1] - - quatCompsSym[:, 2, :] * direction[0] + 2 * quat_comps_sym[:, 0, :] * ( + quat_comps_sym[:, 1, :] * direction[1] - + quat_comps_sym[:, 2, :] * direction[0] ) ) # normalise vectors - directionCrystal /= np.sqrt(np.einsum( - 'ijk,ijk->jk', directionCrystal, directionCrystal + direction_crystal /= np.sqrt(np.einsum( + 'ijk,ijk->jk', direction_crystal, direction_crystal )) # move all vectors into north hemisphere - directionCrystal[:, directionCrystal[2, :, :] < 0] *= -1 + direction_crystal[:, direction_crystal[2, :, :] < 0] *= -1 # convert to spherical coordinates - alpha, beta = Quat.polarAngles( - directionCrystal[0], directionCrystal[1], directionCrystal[2] + alpha, beta = Quat.polar_angles( + direction_crystal[0], direction_crystal[1], direction_crystal[2] ) # find the poles in the fundamental triangle - if symGroup == "cubic": - # first beta should be between 0 and 45 deg leaving 3 - # symmetric equivalents per orientation - trialPoles = np.logical_and(beta >= 0, beta <= np.pi / 4) - - # if less than 3 left need to expand search slighly to - # catch edge cases - if np.any(np.sum(trialPoles, axis=0) < 3): - deltaBeta = 1e-8 - trialPoles = np.logical_and(beta >= -deltaBeta, - beta <= np.pi / 4 + deltaBeta) + if sym_group == "cubic": + beta_range = (np.pi / 2, 3/4 * np.pi, 3) + + elif sym_group == "hexagonal": + if triangle is None: + triangle = defaults['ipf_triangle_convention'] + + if triangle == 'up': + beta_range = (np.pi / 2, 2/3 * np.pi, 1) + elif triangle == 'down': + beta_range = (1/3 * np.pi, np.pi / 2, 1) + else: + ValueError("`triangle` must be 'up' or 'down'") + else: + raise ValueError("sym_group must be cubic or hexagonal") + + trial_poles = np.logical_and(beta >= beta_range[0], beta <= beta_range[1]) + # expand search slightly to catch edge cases if needed + if np.any(np.sum(trial_poles, axis=0) < beta_range[2]): + delta_beta = 1e-8 + trial_poles = np.logical_and( + beta >= beta_range[0] - delta_beta, + beta <= beta_range[1] + delta_beta + ) + if sym_group == "cubic": # now of symmetric equivalents left we want the one with # minimum alpha - min_alpha_idx = np.nanargmin(np.where(trialPoles==False, np.nan, alpha), axis=0) - betaFund = beta[min_alpha_idx, np.arange(len(min_alpha_idx))] - alphaFund = alpha[min_alpha_idx, np.arange(len(min_alpha_idx))] - - elif symGroup == "hexagonal": - # first beta should be between 0 and 30 deg leaving 1 - # symmetric equivalent per orientation - trialPoles = np.logical_and(beta >= 0, beta <= np.pi / 6) - # if less than 1 left need to expand search slighly to - # catch edge cases - if np.any(np.sum(trialPoles, axis=0) < 1): - deltaBeta = 1e-8 - trialPoles = np.logical_and(beta >= -deltaBeta, - beta <= np.pi / 6 + deltaBeta) - + fund_idx = np.nanargmin(np.where(trial_poles, alpha, np.nan), axis=0) + else: # non-indexed points cause more than 1 symmetric equivalent, use this # to pick one and filter non-indexed points later - first_idx = (trialPoles==True).argmax(axis=0) - betaFund = beta[first_idx, np.arange(len(first_idx))] - alphaFund = alpha[first_idx, np.arange(len(first_idx))] - - else: - raise Exception("symGroup must be cubic or hexagonal") + fund_idx = trial_poles.argmax(axis=0) - return alphaFund, betaFund + fund_idx = (fund_idx, range(len(fund_idx))) + return alpha[fund_idx], beta[fund_idx] @staticmethod - def symEqv(symGroup: str) -> List['Quat']: + def sym_eqv(symGroup: str) -> List['Quat']: """Returns all symmetric equivalents for a given crystal type. LEGACY: move to use symmetries defined in crystal structures diff --git a/defdap/utils.py b/defdap/utils.py index fda5a54..4e4bf6e 100644 --- a/defdap/utils.py +++ b/defdap/utils.py @@ -1,4 +1,4 @@ -# Copyright 2021 Mechanics of Microstructures Group +# Copyright 2025 Mechanics of Microstructures Group # at The University of Manchester # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -15,9 +15,10 @@ import functools from datetime import datetime +from uuid import uuid4 -def reportProgress(message: str = ""): +def report_progress(message: str = ""): """Decorator for reporting progress of given function Parameters @@ -67,3 +68,386 @@ def wrapper(*args, **kwargs): return wrapper return decorator + +class Datastore(object): + """Storage of data and metadata, with methods to allow derived data + to be calculated only when accessed. + + Attributes + ---------- + _store : dict of dict + Storage for data and metadata, keyed by data name. Each item is + a dict with at least a `data` key, all other items are metadata, + possibly including: + type : str + Type of data stored: + `map` - at least a 2-axis array, trailing axes are spatial + order : int + Tensor order of the data + unit : str + Measurement unit the data is stored in + plot_params : dict + Dictionary of the default parameters used to plot + _generators: dict + Methods to generate derived data, keyed by tuple of data names + that the method produces. + + """ + __slots__ = [ + '_store', + '_generators', + '_derivatives', + '_group_id', + '_crop_func', + '_mask_func' + ] + _been_to = None + + @staticmethod + def generate_id(): + return uuid4() + + def __init__(self, group_id=None, crop_func=None, mask_func=None): + self._store = {} + self._generators = {} + self._derivatives = [] + self._group_id = self.generate_id() if group_id is None else group_id + self._crop_func = (lambda x, **kwargs: x) if crop_func is None else crop_func + self._mask_func = (lambda x, **kwargs: x) if mask_func is None else mask_func + + def __len__(self): + """Number of data in the store, including data not yet generated.""" + return len(self.keys()) + + def __str__(self): + text = 'Datastore' + for key, val in self._store.items(): + # text += f'\n {key}: {val["data"].__repr__()}' + text += f'\n {key}' + text2 = '' + for derivative in self._derivatives: + for key in self.lookup_derivative_keys(derivative): + text2 += f'\n {key}' + if text2 != '': + text += '\n Derived data:' + text2 + + return text + + def __contains__(self, key): + return key in self.keys() + + def __getitem__(self, key): + """Get data or metadata + + Parameters + ---------- + key : str or tuple of str + Either the data name or tuple of data name and metadata name. + + Returns + ------- + data or metadata + + """ + if isinstance(key, tuple): + attr = key[1] + key = key[0] + else: + attr = 'data' + + # Avoid looking up all keys over derivatives + if key not in self._store: + if key not in self: + raise KeyError(f'Data with name `{key}` does not exist.') + return self._get_derived_item(key, attr) + if attr not in self._store[key]: + raise KeyError(f'Metadata `{attr}` does not exist for `{key}`.') + + val = self._store[key][attr] + + # Generate data if needed + if attr == 'data' and val is None: + try: + val = self.generate(key, return_val=True) + except DataGenerationError: + # No generator found + pass + + if attr == 'data' and self.get_metadata(key, 'type') == 'map': + if not self.get_metadata(key, 'cropped', False): + binning = self.get_metadata(key, 'binning', 1) + val = self._crop_func(val, binning=binning) + if self.get_metadata(key, 'apply_mask', True): + val = self._mask_func(val) + + return val + + def __setitem__(self, key, val): + """Set data or metadata of item that already exists. + + Parameters + ---------- + key : str or tuple of str + Either the data name or tuple of data name and metadata name. + val : any + Value to set + + """ + if isinstance(key, tuple): + attr = key[1] + key = key[0] + else: + attr = 'data' + + if key not in self: + raise ValueError(f'Data with name `{key}` does not exist.') + + ## TODO: fix derived data + self._store[key][attr] = val + + def __getattr__(self, key): + """Get data + + """ + return self[key] + + def __setattr__(self, key, val): + """Set data of item that already exists. + + """ + if key in self.__slots__: + super().__setattr__(key, val) + else: + self[key] = val + + def __iter__(self): + """Iterate through the data names. Allows use of `*datastore` to + get all keys in the store, imitating functionality of a dictionary. + + """ + for key in self.keys(): + yield key + + def keys(self): + """Get the names of all data items. Allows use of `**datastore` + to get key-value pairs, imitating functionality of a dictionary. + + """ + keys = list(self._store.keys()) + for derivative in self._derivatives: + keys += self.lookup_derivative_keys(derivative) + return keys + + def lookup_derivative_keys(self, derivative): + root_call = False + if Datastore._been_to is None: + root_call = True + Datastore._been_to = set() + Datastore._been_to.add(self._group_id) + + source = derivative['source'] + matched_keys = [] + if source._group_id in Datastore._been_to: + return matched_keys + for key in source: + for meta_key in derivative['in_props']: + if source.get_metadata(key, meta_key) != derivative['in_props'][meta_key]: + break + else: + matched_keys.append(key) + + if root_call: + Datastore._been_to = None + + return matched_keys + + def _get_derived_item(self, key, attr): + for derivative in self._derivatives: + if key in self.lookup_derivative_keys(derivative): + break + else: + raise KeyError(f'Data with name `{key}` does not exist.') + source = derivative['source'] + + ## TODO: fix derived metadata + # if attr not in source._store[key]: + # raise KeyError(f'Metadata `{attr}` does not exist for `{key}`.') + + if attr in derivative['out_props']: + return derivative['out_props'][attr] + + if derivative['pass_ref'] and attr == 'data': + return derivative['func'](key) + + val = derivative['source'][(key, attr)] + if attr == 'data': + val = derivative['func'](val) + + return val + + # def values(self): + # return self._store.values() + + # def items(self): + # return dict(**self) + + def add(self, key, data, **kwargs): + """Add an item to the datastore. + + Parameters + ---------- + key : str + Name of the data. + data : any + Data to store. + kwargs : dict + Key-value pairs stored as the items metadata. + + """ + if key in self: + raise ValueError(f'Data with name `{key}` already exists.') + if 'data' in kwargs: + raise ValueError(f'Metadata name `data` is not allowed.') + + self._store[key] = { + 'data': data, + **kwargs + } + + def add_generator(self, keys, func, metadatas=None, **kwargs): + """Add a data generator method that produces one or more data. + + Parameters + ---------- + keys: str or tuple of str + Name(s) of data that the generator produces. + func: callable + Method that produces the data. Should return the same number + of values as there are `keys`. + metadatas : list of dict + Metadata dicts for each of data items produced. + kwargs : dict + Key-value pairs stored as the items metadata for every data + item produced. + + """ + if isinstance(keys, str): + keys = (keys, ) + if isinstance(metadatas, dict): + metadatas = (metadatas, ) + for i, key in enumerate(keys): + if metadatas is None: + metadata = {} + else: + metadata = metadatas[i] + metadata.update(kwargs) + self.add(key, None, **metadata) + self._generators[keys] = func + + def add_derivative(self, datastore, derive_func, in_props=None, + out_props=None, pass_ref=False): + if in_props is None: + in_props = {} + if out_props is None: + out_props = {} + new_derivative = { + 'source': datastore, + 'func': derive_func, + 'in_props': in_props, + 'out_props': out_props, + 'pass_ref': pass_ref, + } + # check if exists and update + for derivative in self._derivatives: + if derivative['func'] == derive_func: + derivative.update(new_derivative) + break + # or add new + else: + self._derivatives.append(new_derivative) + + def generate(self, key, return_val=False, **kwargs): + """Generate data from the associated data generation method and + store if metadata `save` is not set to False. + + Parameters + ---------- + key : str + Name of the data to generate. + + Returns + ------- + Requested data after generating. + + """ + for (keys, generator) in self._generators.items(): + if key not in keys: + continue + + datas = generator(**kwargs) + if len(keys) == 1: + if self.get_metadata(key, 'save', True): + self[key] = datas + return datas if return_val else None + + if len(keys) != len(datas): + raise ValueError( + 'Data generator method did not return the expected ' + 'number of values.' + ) + for key_i, data in zip(keys, datas): + if self.get_metadata(key_i, 'save', True): + self[key_i] = data + if key_i == key: + rtn_val = data + return rtn_val if return_val else None + + else: + raise DataGenerationError(f'Generator not found for data `{key}`') + + def update(self, other, priority=None): + """Update with data items stored in `other`. + + Parameters + ---------- + other : defdap.utils.Datastore + priority : str + Which datastore to keep an item from if the same name exists + in both. Default is to prioritise `other`. + + """ + if priority == 'self': + other._store.update(self._store) + self._store = other._store + else: + self._store.update(other._store) + + def get_metadata(self, key, attr, value=None): + """Get metadata value with a default returned if it does not + exist. Imitating the `get()` method of a dictionary. + + Parameters + ---------- + key : str + Name of the data item. + attr : str + Metadata to get. + value : any + Default value to return if metadata does not exist. + + Returns + ------- + Metadata value or the default value. + + """ + if key in self._store: + return self._store[key].get(attr, value) + + try: + return self._get_derived_item(key, attr) + except KeyError: + return value + + +class DataGenerationError(Exception): + pass diff --git a/docs/source/conf.py b/docs/source/conf.py index 691a20d..3d79157 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -1,35 +1,43 @@ # -*- coding: utf-8 -*- # # Configuration file for the Sphinx documentation builder. -# -# This file does only contain a selection of the most common options. For a -# full list see the documentation: -# http://www.sphinx-doc.org/en/master/config + +import os +import shutil +import sys # -- Path setup -------------------------------------------------------------- # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. -# -import os -import sys -import shutil -sys.path.insert(0, os.path.abspath('../../')) # Reference the root directory so autodocs can find the python modules +sys.path.insert(0, os.path.abspath('../../')) # Reference the root directory so autodocs can find the python modules -# Copy the example notebook, change %matplotlib to inline and change directory so that paths still work +# Copy the example notebook into the docs source shutil.copyfile('../../notebooks/example_notebook.ipynb', 'howtouse.ipynb') + +# Open file with open('howtouse.ipynb') as f: - newText=f.read().replace('%matplotlib tk', r'%matplotlib inline\n%cd -q ../') -newText=newText.replace('DefDAP Example notebook', r'How to use') -newText=newText.replace('This notebook', r'These pages') + old_text = f.read() + +# change %matplotlib to inline +new_text = old_text.replace('%matplotlib tk', r'%matplotlib inline') + +# change directory so that paths still work +new_text = new_text.replace('../tests/data/', r'../../tests/data/') + +# Change title to 'How to use' +new_text = new_text.replace('DefDAP Example notebook', r'How to use') +new_text = new_text.replace('This notebook', r'These pages') + +# Write back to notebook with open('howtouse.ipynb', "w") as f: - f.write(newText) + f.write(new_text) # -- Project information ----------------------------------------------------- project = 'DefDAP' -copyright = '2020, Mechanics of Microstructures Group at The University of Manchester' +copyright = '2023, Mechanics of Microstructures Group at The University of Manchester' author = 'Michael D. Atkinson, Rhys Thomas, João Quinta da Fonseca' @@ -71,6 +79,8 @@ def get_version(): nbsphinx_allow_errors = True nbsphinx_execute = 'always' +nbsphinx_kernel_name = 'python3' + nbsphinx_prolog = """ This page was built from the example_notebook Jupyter notebook available on `Github `_ @@ -81,7 +91,6 @@ def get_version(): """ napoleon_use_param = True -#set_type_checking_flag = True # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] @@ -98,11 +107,7 @@ def get_version(): # The master toctree document. master_doc = 'index' -# The language for content autogenerated by Sphinx. Refer to documentation -# for a list of supported languages. -# -# This is also used if you do content translation via gettext catalogs. -# Usually you set "language" from the command line for these cases. +# The language for content autogenerated by Sphinx language = 'en' # List of patterns, relative to source directory, that match files and @@ -138,16 +143,6 @@ def get_version(): # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['_static'] -# Custom sidebar templates, must be a dictionary that maps document names -# to template names. -# -# The default sidebars (for documents that don't match any pattern) are -# defined by theme itself. Builtin themes are using these templates by -# default: ``['localtoc.html', 'relations.html', 'sourcelink.html', -# 'searchbox.html']``. -# -# html_sidebars = {} - # -- Options for HTMLHelp output --------------------------------------------- diff --git a/docs/source/installation.rst b/docs/source/installation.rst index ace368b..8ffc856 100644 --- a/docs/source/installation.rst +++ b/docs/source/installation.rst @@ -7,7 +7,7 @@ The defdap package is available from the Python Package Index (PyPI) and can be The prerequisite packages should be installed automatically by pip, but if you want to manually install them, using the conda package manager for example, then run the following command: :: - conda install scipy numpy matplotlib scikit-image scikit-learn pandas networkx jupyter ipython + conda install scipy numpy matplotlib scikit-image scikit-learn pandas networkx If you are doing development work on the scripts, first clone the repository from GitHub. The package can then be installed in editable mode using pip with flag -e to create a "linked" .egg module, which means the module is loaded from the directory at runtime. This avoids having to reinstall every time changes are made. Run the following command from the root of the cloned repository: :: diff --git a/docs/source/papers.rst b/docs/source/papers.rst index 19168a1..163c23b 100644 --- a/docs/source/papers.rst +++ b/docs/source/papers.rst @@ -1,12 +1,38 @@ Papers ======== -Here is a list of papers which have use the DefDAP Python library. +Here is a list of papers which have used the DefDAP Python library. + +2025 +------ + +* `B.Yang, X.Xu, D.Lunt, F.Zhang, M.D.Atkinson, Y.Li, J.LLorca, X.Zhou. Grain size dependence of microscopic strain distribution in a high entropy alloy at the onset of plastic deformation. Acta Materialia. Volume 285, Feb 2025, 120682. `_ + +* `D.Hu, A.D.Smith, D.Lunt, R.Thomas, M.D.Atkinson, X.Liu, Ö.Koç, J.M.Donoghue, Z.Zhang, J.Quinta da Fonseca, M.Preuss, Tracking the onset of plasticity in a Ni-base superalloy using in-situ High-Resolution Digital Image Correlation. Materialia. Volume 220, Feb 2025, 114654. `_ + +2024 +------ + +* `S.Cao, R.Thomas, A.D.Smith, P.Zhang, L.Meng, H.Liu, J.Guo, J.Donoghue, D.Lunt. The effect of a keyhole defect on strain localisation in an additive manufactured titanium alloy. Journal of Materials Research and Technology. Volume 33, Nov–Dec 2024. Pages 9664-9673. `_ + +* `B.Poole, A.Marsh, D.Lunt, C.Hardie, M.Gorley, C.Hamelin, A.Harte. Nanoscale speckle patterning for combined high-resolution strain and orientation mapping of environmentally sensitive materials. Strain. Volume 60. Issue 6. Dec 2024. `_ + +* `R.Nia, C.J.Boehlert, Y.Zenga, B.Chen, S.Huang, J.Zheng, H.Zhou, Q.Wang, D.Yin. Automated analysis framework of strain partitioning and deformation mechanisms via multimodal fusion and computer vision. International Journal of Plasticity. Volume 182. 2024. 104119. `_ + +* `E. Nieto-Valeiras, A. Orozco-Caballero, M. Sarebanzadeh, J. Sun, J. LLorca. Analysis of slip transfer across grain boundaries in Ti via diffraction contrast tomography and high-resolution digital image correlation: When the geometrical criteria are not sufficient. Volume 175, April 2024, 103941. `_ + +* `I.Alakiozidis, C.Hunt, R.Thomas, D.Lunt, A.D.Smith, M.Maric, Z.Shah, A.Ambard, P.Frankel. Quantifying cracking and strain localisation in a cold spray chromium coating on a zirconium alloy substrate under tensile loading at room temperature. Journal of Nuclear Materials. Apr 2024. 154899. `_ + +* `B.Poole, A.Marsh, D.Lunt, M.Gorley, C.Hamelin, C. Hardie, A.Harte. High-resolution strain mapping in a thermionic LaB6 scanning electron microscope. Strain. Feb 2024. `_ + +* `M.Maric, R.Thomas, A.Davis, D.Lunt, J.Donoghue, A.Gholinia, M.De Graef, T.Ungar, P.Barberis, F.Bourlier, P.Frankel, P.Shanthraj, M.Preuss. Identification, classification and characterisation of hydrides in Zr alloys. Scripta Materialia. Jan 2024. 115768. `_ 2023 ------ -* `R.Thomas, D.Lunt, M.D.Atkinson, J.Quinta da Fonseca, M.Preuss, P.Honniball, P.Frankel. The role of hydrides and precipitates on the strain localisation behaviour in a zirconium alloy. Acta Materialia. 119327. `_ +* `Y.Liu, R.Thomas, C.D.Hardie, P.Frankel, F.P.E.Dunne. Exploring the hydride-slip interaction in zirconium alloys. Acta Materialia. Dec 2023. 119388. `_ + +* `R.Thomas, D.Lunt, M.D.Atkinson, J.Quinta da Fonseca, M.Preuss, P.Honniball, P.Frankel. The role of hydrides and precipitates on the strain localisation behaviour in a zirconium alloy. Acta Materialia. Dec 2023. 119327. `_ * `M.Maric, R,Thomas, A.Davis, D.Lunt, J.Donoghue, A.Gholinia, M.De Graef, T.Ungar, P.Barberis, F.Bourlier, P.Frankel, P.Shanthraj, M.Preuss. Identification, classification and characterisation of hydrides in Zr alloys. Scripta Materialia. Volume 238. Aug 2023. 115768. `_ @@ -16,19 +42,27 @@ Here is a list of papers which have use the DefDAP Python library. * `C.Liu, X.Xu, T.Sun, R.Thomas, J.Quinta da Fonseca, M.Preuss. Microstructural effects on fatigue crack initiation mechanisms in a near-alpha titanium alloy. Acta Materialia. Volume 253. Jul 2023. 118957. `_ +* `B.Yavuzyegit, E.Avcu, A.D.Smith, J.M.Donoghue a, D.Lunt, J.D.Robson, T.L.Burnett, J.Quinta da Fonseca, P.J.Withers. Mapping plastic deformation mechanisms in AZ31 magnesium alloy at the nanoscale. Acta Materialia. Volume 250. May 2023. 118876. `_ + 2022 ------ +* `X.Li, Z.Zhai, W.Lin, Y.Ou, Y.Wu, R.Yang, Z.Zhang. Precipitate mediated plasticity at twin boundary in Nickel-based superalloy. Materialia. Volume 26. Dec 2022. 101612. `_ + * `C.Hardie, R.Thomas, Y. Liu, P.Frankel, F.Dunne. Simulation of crystal plasticity in irradiated metals: A case study on Zircaloy-4. Acta Materialia. Volume 241. Dec 2022. 118361. `_ -* `A.E. Davis, X. Zeng, R. Thomas, J.R. Kennedy 1, J. Donoghue, A. Gholinia, P.B. Prangnell, J. Quinta Da Fonseca. Optimising large-area crystal orientation mapping of nanoscale β phase in α + β titanium alloys using EBSD. Materials Characterization. Volume 194. Dec 2022. 112371. `_ +* `A.E. Davis, X. Zeng, R. Thomas, J.R. Kennedy, J. Donoghue, A. Gholinia, P.B. Prangnell, J. Quinta Da Fonseca. Optimising large-area crystal orientation mapping of nanoscale β phase in α + β titanium alloys using EBSD. Materials Characterization. Volume 194. Dec 2022. 112371. `_ * `S.Cao, L.Meng, H.Liu, Y.Zou, A.Smith, X.Wu, J.Donoghue, R.Thomas, M.Preuss, D.Lunt. Role of microstructure heterogeneity on deformation behaviour in additive manufactured Ti-6Al-4V. Materialia. Volume 26. Dec 2022. 101636. `_ +* `X.C.Li, Y.N.Wu, R.Yang, Z.B.Zhang, Origin of strain localization at twin boundary in Inconel 718 superalloy fabricated by laser powder bed fusion. 42nd Risø International Symposium on Materials Science: Microstructural variability: Processing, analysis, mechanisms and properties. Volume 1249. September 2022. `_ + * `C.Liu, R.Thomas, T.Sun, J.Donoghue, X.Zhang, T.L.Burnett, J.Quinta da Fonseca, M.Preuss. Multi-dimensional study of the effect of early slip activity on fatigue crack initiation in a near-α titanium alloy. Acta Materialia. Volume 223. Jul 2022. 117967. `_ * `C.Dichtl, D.Lunt, M.Atkinson, R.Thomas, A.Plowman, B.Barzdajn, R.Sandala, J.Quinta da Fonseca, M.Preuss. Slip activity during low-stress cold creep deformation in a near-α titanium alloy. Acta Materialia. Volume 229. May 2022. 117691. `_ +* `X.C.Li, Y.N.Wu, R.Yang, Z.B.Zhang. Origin of strain localization at twin boundary in Inconel 718 superalloy fabricated by laser powder bed fusion. IOP Conference Series: Materials Science and Engineering. 1249. 012016. `_ + 2021 ------ @@ -36,6 +70,9 @@ Here is a list of papers which have use the DefDAP Python library. * `D.Lunt, R.Thomas, M.D.Atkinson, A. Smith, R.Sandala, J.Quinta da Fonseca, M. Preuss. Understanding the role of local texture variation on slip activity in a two-phase titanium alloy. Acta Materialia. Volume 216. Sept 2021. 117111. `_ +* `O.Levano Blanch, D.Lunt, G.J.Baxter, Deformation Behaviour of a FAST Diffusion Bond Processed from Dissimilar Titanium Alloy Powders. Metall Mater Trans A. Volume 52. Apr 2021. 3064–3082 (2021). `_ + + 2020 ------ @@ -43,6 +80,8 @@ Here is a list of papers which have use the DefDAP Python library. * `R.Sperry, A.Harte, J.Quinta da Fonseca, E.R.Homer, R.H.Wagoner, D.T.Fullwood. Slip band characteristics in the presence of grain boundaries in nickel-based superalloy. Acta Materialia. Volume 193, July 2020, Pages 229-238. `_ +* `E.Polatidis, M.Šmíd, I.Kuběna, W.-N.Hsu, G.Laplanche, H.V.Swygenhoven. Deformation mechanisms in a superelastic NiTi alloy: An in-situ high resolution digital image correlation study. Materials & Design. Volume 191, June 2020, 108622. `_ + * `A.Harte, M.Atkinson, M.Preuss, J.Quinta da Fonseca. A statistical study of the relationship between plastic strain and lattice misorientation on the surface of a deformed Ni-based superalloy. Acta Materialia. May 2020. `_ * `A.Harte, M.Atkinson, A.Smith, C.Drouven, S.Zaefferer, J.Quinta da Fonseca, M.Preuss. The effect of solid solution and gamma prime on the deformation modes in Ni-based superalloys. Acta Materialia. May 2020. `_ diff --git a/notebooks/advanced_notebook.ipynb b/notebooks/advanced_notebook.ipynb new file mode 100644 index 0000000..09110a0 --- /dev/null +++ b/notebooks/advanced_notebook.ipynb @@ -0,0 +1,491 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# DefDAP Advanced notebook\n", + "\n", + "This notebook will outline usage of DefDAP, including loading a DIC and EBSD map, linking them with homologous points, producing maps, drawing line profiles and performing slip system analysis using grain inspector." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook contains the dataset used in the following paper: https://www.sciencedirect.com/science/article/pii/S2589152919300444 which is available at this respository: https://data.mendeley.com/datasets/n4cdwp6pwc/1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load packages" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib notebook\n", + "\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import cm\n", + "from matplotlib.colors import ListedColormap\n", + "\n", + "from defdap import ebsd, hrdic\n", + "from defdap.plotting import HistPlot\n", + "from defdap.quat import Quat\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load DIC data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "file_path = \"../data/\"\n", + "\n", + "irrMap = hrdic.Map(file_path + \"irr_003.txt\")\n", + "irrMap.set_pattern(\"irr_8bin.jpg\", 2)\n", + "\n", + "nirrMap = hrdic.Map(file_path + \"nirr_003.txt\")\n", + "nirrMap.set_pattern(\"nirr_8bin.jpg\", 2)\n", + "\n", + "for dic_map in [irrMap, nirrMap]:\n", + " dic_map.set_crop(left=0, right=0, top=0, bottom=0)\n", + " dic_map.set_scale((10/2048))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load EBSD data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "irrEbsd = ebsd.Map(file_path + \"irr_new\")\n", + "nirrEbsd = ebsd.Map(file_path + \"nirr_new\")\n", + "\n", + "for ebsd_map in [nirrEbsd, irrEbsd]:\n", + " ebsd_map.data.generate('grain_boundaries', misori_tol=3.6)\n", + " ebsd_map.data.generate('grains', min_grain_size=20)\n", + " ebsd_map.calc_average_grain_schmid_factors(load_vector=np.array([1, 0, 0]))\n", + " ebsd_map.calc_grain_mis_ori(calc_axis=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can try to select your own homologous points using these functions, or you can use predefined ones in the following cell" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#irrMap.setHomogPoint(display='pattern')\n", + "#irrEbsd.setHomogPoint()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "irrMap.frame.homog_points = [\n", + " (939, 170), (132, 220), (226, 860), (942, 864), (530, 430)\n", + "]\n", + "nirrMap.frame.homog_points = [\n", + " (98, 126), (99, 884), (880, 100), (555, 614), (483, 106), (936, 696)\n", + "]\n", + "irrEbsd.frame.homog_points = [\n", + " (407, 106), (85, 109), (112, 329), (392, 342), (240, 186)\n", + "]\n", + "nirrEbsd.frame.homog_points = [\n", + " (62, 60), (46, 339), (373, 69), (229, 250), (217, 59), (378, 295)\n", + "]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Link maps" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "irrMap.link_ebsd_map(irrEbsd, transform_type='affine')\n", + "irrMap.find_grains(algorithm='warp');\n", + "\n", + "nirrMap.link_ebsd_map(nirrEbsd, transform_type='affine')\n", + "nirrMap.find_grains(algorithm='warp');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Draw a line profile" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "nirrMap.draw_line_profile(vmax=0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "irrMap.draw_line_profile(vmax=0.2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Stats" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "irrMap.print_stats_table(\n", + " percentiles=[0, 1, 5, 50, 95, 99, 100], \n", + " components=['e','max_shear']\n", + ")\n", + "nirrMap.print_stats_table(\n", + " percentiles=[0, 1, 5, 50, 95, 99, 100], \n", + " components=['e', 'max_shear']\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Comparison plots" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# New colour map with red when saturated\n", + "viridis = cm.get_cmap('viridis', 512)\n", + "newcolors = viridis(np.linspace(0, 1, 512))\n", + "newcolors[-1:, :] = np.array([1, 0, 0, 1])\n", + "newcmp = ListedColormap(newcolors)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f0ca832099624c8fbf16bcd768e2f299", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, (ax1, ax2) = plt.subplots(1,2, figsize=(10,5), constrained_layout=True)\n", + "\n", + "plot0 = nirrMap.plot_map(\n", + " 'max_shear', ax=ax1, fig=fig, plot_colour_bar=False,\n", + " vmin=0, vmax=0.2, cmap = newcmp, plot_gbs='line'\n", + ")\n", + "plot1 = irrMap.plot_map(\n", + " 'max_shear', ax=ax2, fig=fig, plot_colour_bar=False, plot_scale_bar=True, \n", + " vmin=0, vmax=0.2, cmap = newcmp, plot_gbs='line'\n", + ")\n", + "\n", + "plot1.add_colour_bar(label='Effective Shear Strain', aspect=35, shrink=0.86)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, (ax1, ax2) = plt.subplots(1,2, figsize=(10,5), constrained_layout=True)\n", + "\n", + "plot0 = nirrEbsd.plot_mis_ori_map(ax=ax1, fig=fig,component=3, \n", + " plot_gbs='line', boundary_colour='black',\n", + " plot_colour_bar = False, cmap='coolwarm',\n", + " vmin=-4, vmax=4)\n", + "plot1 = irrEbsd.plot_mis_ori_map(ax=ax2, fig=fig, component=3, \n", + " plot_gbs='line', boundary_colour='black',\n", + " plot_colour_bar=False, cmap='coolwarm',\n", + " vmin=-4, vmax=4)\n", + "\n", + "plot1.add_colour_bar(label='Rotation about Z ($^\\circ$)', aspect=35, shrink=0.86)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Histogram" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot = HistPlot.create(\n", + " irrMap.crop(irrMap.data['max_shear']) / np.nanmedian(irrMap.crop(irrMap.data['max_shear'])),\n", + " plot_type='step', axes_type=\"loglog\", bins=200, \n", + " range=(0.0001,100), label='Irradiated', alpha=0.6\n", + ")\n", + "\n", + "plot.add_hist(\n", + " nirrMap.crop(nirrMap.data['max_shear']) / np.nanmedian(nirrMap.crop(nirrMap.data['max_shear'])), \n", + " bins=200, range=(0.0001,100), label = 'Unirradiated', alpha=0.6\n", + ")\n", + "\n", + "plot.add_legend()\n", + "\n", + "plot.ax.set_xlabel(\"Effective shear strain (multiples of median)\")\n", + "plot.ax.set_xlim(0.01, 50)\n", + "plot.ax.set_ylim(0.0001)\n", + "\n", + "plt.axvline(1, color='black', linestyle='dashed', linewidth=1)\n", + "\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Grain inspector" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This will load a GUI tool used to inspect the slip in each grain. You can navigate between grains using the 'Previous Grain' and 'Next Grain' buttons in the top right. Click and drag within the grain to define slip lines and click the 'Save Line' button to the right to save and detect the active slip system." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "irrMap.grain_inspector(vmax=0.1)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Finished finding grains (0:00:00) \n" + ] + } + ], + "source": [ + "nirrMap.grain_inspector(vmax=0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot grains" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After drawing lines on some grains above, this code will plot an IPF with the active slip system coloured." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "selMap = irrMap\n", + "\n", + "prorilist = []; pyorilist=[]; baorilist=[]; multorilist = [];\n", + "for grain in selMap:\n", + " for system in grain.groups_list:\n", + " # If one slip system\n", + " if len(system[2]) == 1:\n", + " # If prismatic\n", + " if system[2][0] in [1, 2, 3]:\n", + " prorilist.append(grain.ref_ori)\n", + " # If pyramidal\n", + " if system[2][0] in [4, 5, 6, 7, 8, 9]:\n", + " pyorilist.append(grain.ref_ori)\n", + " #If basal\n", + " if system[2][0] in [0]:\n", + " pyorilist.append(grain.ref_ori)\n", + " #If ambiguous\n", + " if len(system[2]) >1:\n", + " multorilist.append(grain.ref_ori)\n", + "\n", + "f, ax = plt.subplots(figsize=(6,4))\n", + "\n", + "markersize=40\n", + " \n", + "Quat.plot_ipf(\n", + " [grain.ref_ori for grain in selMap], [1,0,0], 'hexagonal',\n", + " c='0.9', marker='o', s=markersize, ax=ax, label='no slip'\n", + ")\n", + "if multorilist != []: \n", + " Quat.plot_ipf(\n", + " multorilist, [1,0,0], 'hexagonal', \n", + " c='0.6', marker='o', s=markersize, ax=ax, label='ambiguous'\n", + " )\n", + "if prorilist != []: \n", + " Quat.plot_ipf(\n", + " prorilist, [1,0,0], 'hexagonal', \n", + " c='r', marker='o', s=markersize, ax=ax, label='prismatic'\n", + " )\n", + "if pyorilist != []:\n", + " Quat.plot_ipf(\n", + " pyorilist, [1,0,0], 'hexagonal', \n", + " c='g', marker='o', s=markersize, ax=ax, label='pyramidal'\n", + " )\n", + "if baorilist != []:\n", + " Quat.plot_ipf(\n", + " baorilist, [1,0,0], 'hexagonal', \n", + " c='b', marker='o', s=markersize, ax=ax, label='basal'\n", + " )\n", + "\n", + "plt.legend(loc='upper left')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "defdap", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + }, + "toc": { + "nav_menu": { + "height": "405px", + "width": "252px" + }, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "toc_cell": false, + "toc_position": { + "height": "756px", + "left": "0px", + "right": "1161px", + "top": "107px", + "width": "273px" + }, + "toc_section_display": "none", + "toc_window_display": true + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/example_notebook.ipynb b/notebooks/example_notebook.ipynb index a4b0212..1e6c220 100644 --- a/notebooks/example_notebook.ipynb +++ b/notebooks/example_notebook.ipynb @@ -2,7 +2,11 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "# DefDAP Example notebook\n", "\n", @@ -11,14 +15,22 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## Load in packages" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "DefDAP is split into modules for processing EBSD (`defdap.ebsd`) and HRDIC (`defdap.hrdic`) data. There are also modules for manpulating orientations (`defdap.quat`) and creating custom figures (`defdap.plotting`) which is introduced later. We also import some of the usual suspects of the python scientific stack: `numpy` and `matplotlib`." ] @@ -26,7 +38,12 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, "outputs": [], "source": [ "import numpy as np\n", @@ -37,12 +54,16 @@ "from defdap.quat import Quat\n", "\n", "# try tk, qt, osx (if using mac) or notebook for interactive plots. If none work, use inline\n", - "%matplotlib tk" + "%matplotlib inline" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## Load in a HRDIC map" ] @@ -50,16 +71,24 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "dicFilePath = \"../tests/data/\"\n", - "dicMap = hrdic.Map(dicFilePath, \"testDataDIC.txt\")" + "dic_filepath = \"../tests/data/testDataDIC.txt\"\n", + "dic_map = hrdic.Map(dic_filepath)" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Set the scale of the map\n", "This is defined as the pixel size in the DIC pattern images, measured in microns per pixel." @@ -68,19 +97,25 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "fieldWidth = 20 # microns\n", - "numPixels = 2048\n", - "pixelSize = fieldWidth / numPixels\n", - "\n", - "dicMap.setScale(pixelSize)" + "field_width = 20 # microns\n", + "num_pixels = 2048\n", + "dic_map.set_scale(field_width / num_pixels)" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Plot the map with a scale bar" ] @@ -88,18 +123,21 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "dicMap.plotMaxShear(vmin=0, vmax=0.10, plotScaleBar=True)" + "dic_map.plot_map('max_shear', vmin=0, vmax=0.10, plot_scale_bar=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Crop the map\n", - "HRDIC maps often contain spurious data at the edges which should be removed before performing any analysis. The crop is defined by the number of points to remove from each edge of the map, where `xMin`, `xMax`, `yMin` and `yMax` are the left, right, top and bottom edges respectively. Note that the test data doesn not require cropping as it is a subset of a larger dataset." + "You can print out the names of all data currently available in the map. Try plotting different data, `plot_map` has a parameter `component` that is either an int `0` or tuple of ints `(0,1)` for tensor components or a named component such as `'norm'`." ] }, { @@ -108,12 +146,41 @@ "metadata": {}, "outputs": [], "source": [ - "dicMap.setCrop(xMin=0, xMax=0, yMin=0, yMax=0)" + "print(dic_map.data)" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Crop the map\n", + "HRDIC maps often contain spurious data at the edges which should be removed before performing any analysis. The crop is defined by the number of points to remove from each edge of the map. Note that the test data doesn not require cropping as it is a subset of a larger dataset." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "dic_map.set_crop(left=0, right=0, top=0, bottom=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Statistics\n", "Some simple statistics such as the minimum, mean and maximum of the effective shear strain, E11 and E22 components can be printed." @@ -122,15 +189,23 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "dicMap.printStatsTable(percentiles=[0, 50, 100], components = ['eMaxShear', 'e11', 'e22', 'e12'])" + "dic_map.print_stats_table(percentiles=[0, 50, 100], components=['max_shear', 'e'])" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Set the location of the DIC pattern images \n", "The pattern images are used later to define the position of homologous material points. The path is relative to the directory set when loading in the map. The second parameter is the pixel binning factor of the image relative to the DIC sub-region size i.e. the number of pixels in the image across a single datapoint in the DIC map. We recommend binning the pattern images by the same factor as the DIC sub-region size, doing so enhances the contrast between microstructure features." @@ -139,36 +214,99 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# set the path of the pattern image, this is relative to the location of the DIC data file\n", - "dicMap.setPatternPath(\"testDataPat.bmp\", 1)" + "dic_map.set_pattern(\"testDataPat.bmp\", 1)" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## Load in an EBSD map\n", - "The crystal structure of each phase is read from file and used to set the slip systems for the phase. The orientation in the EBSD are converted to a quaternion representation so calculations can be applied later." + "Currently, OxfordBinary (a .crc and .cpr file pair), OxfordText (.ctf file), EdaxAng (.ang file) or PythonDict (Python dictionary) filetypes are supported. The crystal structure and slip systems are automatically loaded for each phase in the map. The orientation in the EBSD are converted to a quaternion representation so calculations can be applied later." ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "ebsdFilePath = \"../tests/data/testDataEBSD\"\n", - "\n", - "ebsdMap = ebsd.Map(ebsdFilePath)\n", - "ebsdMap.buildQuatArray()" + "ebsd_map = ebsd.Map(\"../tests/data/testDataEBSD.cpr\")" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "A list of detected phases and crystal structures can be printed" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "for i, phase in enumerate(ebsd_map.phases):\n", + " print(i+1)\n", + " print(phase)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "A list of the slip planes, colours and slip directions can be printed" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "ebsd_map.phases[0].print_slip_systems()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Plot the EBSD map\n", "Using an Euler colour mapping or inverse pole figure colouring with the sample reference direction passed as a vector." @@ -177,24 +315,36 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "ebsdMap.plotEulerMap(plotScaleBar=True)" + "ebsd_map.plot_map('euler_angle', 'all_euler', plot_scale_bar=True)" ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "ebsdMap.plotIPFMap([1,0,0], plotScaleBar=True)" + "ebsd_map.plot_map('orientation', 'IPF_x', plot_scale_bar=True)" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "A KAM map can also be plotted as follows" ] @@ -202,15 +352,23 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "ebsdMap.plotKamMap(vmin=0, vmax=1)" + "ebsd_map.plot_map('KAM', vmin=0, vmax=2*np.pi/180)" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Detect grains in the EBSD\n", "This is done in two stages: first bounaries are detected in the map as any point with a misorientation to a neighbouring point greater than a critical value (`boundDef` in degrees). A flood fill type algorithm is then applied to segment the map into grains, with any grains containining fewer than a critical number of pixels removed (`minGrainSize` in pixels). The data e.g. orientations associated with each grain are then stored (referenced strictly, the data isn't stored twice) in a grain object and a list of the grains is stored in the EBSD map (named `grainList`). This allows analysis routines to be applied to each grain in a map in turn." @@ -219,18 +377,22 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "ebsdMap.findBoundaries(boundDef=8)\n", - "ebsdMap.findGrains(minGrainSize=10)" + "ebsd_map.data.generate('grain_boundaries', misori_tol=8)\n", + "ebsd_map.data.generate('grains', min_grain_size=10)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "A list of the slip planes, colours and slip directions can be printed for each phase in the map." + "Now when we print the available data there is a section for dervied data, this comes from data defined at the grain level. This derived data can be from different sources and later you will see data shared between linked HRDIC and EBSD maps." ] }, { @@ -239,42 +401,64 @@ "metadata": {}, "outputs": [], "source": [ - "phase = ebsdMap.phases[0]\n", - "print(phase.name)\n", - "phase.printSlipSystems()" + "print(ebsd_map.data)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The Schmid factors for each grain can be calculated and plotted. The `slipSystems` argument can be specified, to only calculate the Schmid factor for certain planes, otherwise the maximum for all slip systems is calculated." + "You can use this derived data as with other map data to plots maps, statistics or directly access the data as a numpy array." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Schmid factors for each grain can be calculated and plotted. The `slip_systems` argument can be specified, to only calculate the Schmid factor for certain planes, otherwise the maximum for all slip systems is calculated.\n", + "\n", + "Try changing the loading direction." ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "ebsdMap.calcAverageGrainSchmidFactors(loadVector=np.array([1,0,0]), slipSystems=None)" + "ebsd_map.calc_average_grain_schmid_factors(\n", + " load_vector=np.array([1,0,0]), \n", + " slip_systems=None\n", + ")" ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "ebsdMap.plotAverageGrainSchmidFactorsMap()" + "ebsd_map.plot_average_grain_schmid_factors_map()" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Single grain analysis\n", - "The `locateGrainID` method allows interactive selection of a grain of intereset to apply any analysis to. Clicking on grains in the map will highlight the grain and print out the grain ID (position in the grain list) of the grain." + "The `locate_grain` method allows interactive selection of a grain of intereset to apply any analysis to. Clicking on grains in the map will highlight the grain and print out the grain ID (position in the grain list) of the grain." ] }, { @@ -283,12 +467,25 @@ "metadata": {}, "outputs": [], "source": [ - "ebsdMap.locateGrainID()" + "ebsd_map.locate_grain()" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], + "source": [ + "print(f'Grain ID of last selected grain: {ebsd_map.sel_grain.grain_id}')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "A built-in example is to calculate the average orientation of the grain and plot this orientation in a IPF" ] @@ -296,19 +493,27 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "grainID = 48\n", - "grain = ebsdMap[grainID]\n", - "grain.calcAverageOri() # stored as a quaternion named grain.refOri\n", - "print(grain.refOri)\n", - "grain.plotRefOri(direction=[0, 0, 1])" + "grain_id = 48\n", + "grain = ebsd_map[grain_id]\n", + "grain.calc_average_ori() # stored as a quaternion named grain.refOri\n", + "print(grain.ref_ori)\n", + "grain.plot_ref_ori(direction=[0, 0, 1])" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "The spread of orientations in a given grain can also be plotted on an IPF" ] @@ -316,16 +521,24 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "plot = grain.plotOriSpread(direction=np.array([0, 0, 1]), c='b', s=1, alpha=0.2)\n", - "grain.plotRefOri(direction=[0, 0, 1], c='k', plot=plot)" + "plot = grain.plot_ori_spread(direction=np.array([0, 0, 1]), c='b', s=1, alpha=0.2)\n", + "grain.plot_ref_ori(direction=[0, 0, 1], c='k', plot=plot)" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "The unit cell for the average grain orientation can also be ploted" ] @@ -333,15 +546,23 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "grain.plotUnitCell()" + "grain.plot_unit_cell()" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Printing a list of the slip plane indices, angle of slip plane intersection with the screen (defined as counter-clockwise from upwards), colour defined for the slip plane and also the slip directions and corresponding Schmid factors, is also built in" ] @@ -349,17 +570,49 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "grain.printSlipTraces()" + "grain.print_slip_traces()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "A second built-in example is to calcuate the grain misorientation, specifically the grain reference orientation deviation (GROD). This shows another feature of the `locate_grain` method, which stores the last selected grain in a variable called `sel_grain` in the EBSD map." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "if ebsd_map.sel_grain == None: \n", + " ebsd_map.sel_grain = ebsd_map[57]\n", + " \n", + "ebsd_map.sel_grain.build_mis_ori_list()\n", + "ebsd_map.sel_grain.plot_mis_ori(plot_scale_bar=True, vmin=0, vmax=3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "A second built-in example is to calcuate the grain misorientation, specifically the grain reference orientation deviation (GROD). This shows another feature of the `locateGrainID` method, which stores the ID of the last selected grain in a variable called `currGrainId` in the EBSD map." + "You can also explore and visulaise all data available for a grain" ] }, { @@ -368,14 +621,27 @@ "metadata": {}, "outputs": [], "source": [ - "grain = ebsdMap[ebsdMap.currGrainId]\n", - "grain.buildMisOriList()\n", - "grain.plotMisOri(plotScaleBar=True, vmin=0, vmax=5)" + "grain_id = 40\n", + "grain = ebsd_map[grain_id]\n", + "print(grain.data)" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], + "source": [ + "grain.plot_map('band_contrast')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Multi grain analysis\n", "Once an analysis routine has been prototyped for a single grain it can be applied to all the grains in a map using a loop over the grains and any results added to a list for use later. Of couse you could also apply to a smaller subset of grains as well." @@ -384,22 +650,30 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "grainAvOris = []\n", - "for grain in ebsdMap:\n", - " grain.calcAverageOri()\n", - " grainAvOris.append(grain.refOri)\n", + "grain_av_oris = []\n", + "for grain in ebsd_map:\n", + " grain.calc_average_ori()\n", + " grain_av_oris.append(grain.ref_ori)\n", "\n", "# Plot all the grain orientations in the map\n", - "Quat.plotIPF(grainAvOris, [0, 0, 1], ebsdMap.crystalSym, marker='o', s=10)\n", + "Quat.plot_ipf(grain_av_oris, [0, 0, 1], ebsd_map.crystal_sym, marker='o', s=10)\n", "plt.tight_layout()" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Some common grain analysis routines are built into the EBSD map object, including:" ] @@ -407,59 +681,89 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "ebsdMap.calcGrainAvOris()" + "ebsd_map.calc_grain_av_oris()" ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "ebsdMap.calcGrainMisOri()\n", - "ebsdMap.plotMisOriMap(vmin=0, vmax=5, plotGBs=True, plotScaleBar=True)" + "ebsd_map.calc_grain_mis_ori()\n", + "ebsd_map.plot_mis_ori_map(vmin=0, vmax=5, plot_gbs=True, plot_scale_bar=True)" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ - "There are also methods for plotting GND density, phases and boundaries. All of the plotting functions in DefDAP use the same parameters to modify the plot, examples seen so far are `plotGBs`, `plotScaleBar`, `vmin`, `vmax`." + "There are also methods for plotting GND density, phases and boundaries. All of the plotting functions in DefDAP use the same parameters to modify the plot, examples seen so far are `plot_gbs`, `plotScaleBar`, `vmin`, `vmax`." ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## Linking the HRDIC and EBSD\n", "### Define homologous points\n", - "To register the two datasets, homologous points (points at the same material location) within each map are used to estimate a transformation between the two frames the data are defined in. The homologous points are selected manually using an interactive tool within DefDAP. To select homologous call the method `setHomogPoint` on each of the data maps, which will open a plot window with a button labelled 'save point' in the bottom right. You select a point by right clicking on the map, adjust the position with the arrow and accept the point by with the save point button. Then select the same location in the other map. Note that as we set the location of the pattern image for the HRDIC map that the points can be selected on the pattern image rather than the strain data." + "To register the two datasets, homologous points (points at the same material location) within each map are used to estimate a transformation between the two frames the data are defined in. The homologous points are selected manually using an interactive tool within DefDAP. To select homologous call the method `set_homog_point` on each of the data maps, which will open a plot window with a button labelled 'save point' in the bottom right. You select a point by right clicking on the map, adjust the position with the arrow and accept the point by with the save point button. Then select the same location in the other map. Note that as we set the location of the pattern image for the HRDIC map that the points can be selected on the pattern image rather than the strain data.\n", + "\n", + "Select 3-4 homologous points in spread over each map in the same order." ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "dicMap.setHomogPoint(display=\"pattern\")" + "dic_map.set_homog_point(map_name=\"pattern\")" ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "ebsdMap.setHomogPoint()" + "ebsd_map.set_homog_point()" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "The points are stored as a list of tuples `(x, y)` in each of the maps. This means the points can be set from previous values." ] @@ -467,35 +771,51 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "dicMap.homogPoints" + "dic_map.frame.homog_points" ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "ebsdMap.homogPoints" + "ebsd_map.frame.homog_points" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ - "Here are some example homologous points for this data, after setting these by running the cells below you can view the locations in the maps by running the `setHomogPoint` methods (above) again" + "Here are some example homologous points for this data, after setting these by running the cells below you can view the locations in the maps by running the `set_homog_point` methods (above) again. These will not be in the correct location if the crop values of the HRDIC map have been changed from 0." ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "dicMap.homogPoints = [\n", + "dic_map.frame.homog_points = [\n", " (36, 72), \n", " (279, 27), \n", " (162, 174), \n", @@ -506,10 +826,14 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "ebsdMap.homogPoints = [\n", + "ebsd_map.frame.homog_points = [\n", " (68, 95), \n", " (308, 45), \n", " (191, 187), \n", @@ -519,26 +843,40 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Link the maps\n", - "Finally the two data maps are linked. The type of transform between the two frames can be affine, projective, polynomial." + "Finally the two data maps are linked. The type of transform between the two frames can be affine, projective, polynomial.\n", + "\n", + "Try the different projections and see if the make any difference to the percieved transoformation for the points you selected." ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "dicMap.linkEbsdMap(ebsdMap, transformType=\"affine\")\n", - "# dicMap.linkEbsdMap(ebsdMap, transformType=\"projective\")\n", - "# dicMap.linkEbsdMap(ebsdMap, transformType=\"polynomial\", order=2)" + "dic_map.link_ebsd_map(ebsd_map, transform_type=\"affine\")\n", + "# dic_map.link_ebsd_map(ebsd_map, transform_type=\"projective\")\n", + "# dic_map.link_ebsd_map(ebsd_map, transform_type=\"polynomial\", order=2)" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Show the transformation" ] @@ -546,14 +884,19 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "from skimage import transform as tf\n", "\n", "data = np.zeros((2000, 2000), dtype=float)\n", "data[500:1500, 500:1500] = 1.\n", - "dataWarped = tf.warp(data, dicMap.ebsdTransform)\n", + "transform = dic_map.experiment.get_frame_transform(dic_map.frame, ebsd_map.frame)\n", + "dataWarped = tf.warp(data, transform)\n", "\n", "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8,4))\n", "ax1.set_title('Reference')\n", @@ -564,7 +907,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Segment into grains\n", "The HRDIC map can now be segmented into grains using the grain boundaries detected in the EBSD map. Analysis rountines can then be applied to individual grain, as with the EBSD grains. The grain finding process will also attempt to link the grains between the EBSD and HRDIC and each grain in the HRDIC has a reference (`ebsdGrain`) to the corrosponding grain in the EBSD map." @@ -573,10 +920,14 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "dicMap.findGrains(minGrainSize=10)" + "dic_map.data.generate('grains', min_grain_size=10)" ] }, { @@ -585,35 +936,54 @@ "metadata": {}, "outputs": [], "source": [ - "dicMap.plotMaxShear(vmin=0, vmax=0.1, plotScaleBar=True, plotGBs=True)" + "dic_map.plot_map(\n", + " 'max_shear', vmin=0, vmax=0.10, \n", + " plot_scale_bar=True, plot_gbs='pixel'\n", + ")" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ - "Now, a grain can also be selected interactively in the DIC map, in the same way a grain can be selected from an EBSD map. If `displaySelected` is set to true, then a pop-out window shows the map segmented for the grain" + "Now, a grain can also be selected interactively in the DIC map, in the same way a grain can be selected from an EBSD map. If `display_grain` is set to true, then a plot shows the map segmented for the grain with coloured lines to display the slip trace direction of the set slip systems (see colours `grain.print_slip_traces()`) and black lines marking direction of slip bands detected in the grain." ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "dicMap.locateGrainID(displaySelected=True)" + "dic_map.locate_grain(display_grain=True)" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## Plotting examples" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Some of the plotting features are shown in examples below." ] @@ -622,57 +992,80 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Built-in plots" + "### Built-in plots\n", + "These are the plotting functions you have been using so far, run by calling methods of the data objects. Each method returns a plot object that can be used to modify the plot after it has been created." ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "plot = dicMap.plotMaxShear(\n", - " vmin=0, vmax=0.1, plotScaleBar=True,\n", - " plotGBs=True, dilateBoundaries=True\n", + "plot = dic_map.plot_map(\n", + " 'max_shear', vmin=0, vmax=0.10, \n", + " plot_scale_bar=True, plot_gbs='line'\n", ")" ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "plot = ebsdMap.plotEulerMap(\n", - " plotScaleBar=True, plotGBs=True,\n", - " highlightGrains=[10, 20, 45], highlightAlpha=0.9, highlightColours=['y']\n", + "plot = ebsd_map.plot_map(\n", + " 'euler_angle', component='all_euler',\n", + " plot_scale_bar=True, plot_gbs=True,\n", + " highlight_grains=[10, 20, 45], highlight_alpha=0.9, highlight_colours=['r']\n", ")" ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "dicGrainID = 41\n", - "dicGrain = dicMap[dicGrainID]\n", + "dic_grain_id = 42\n", + "dic_grain = dic_map[dic_grain_id]\n", "\n", - "plot = dicGrain.plotMaxShear(\n", - " plotScaleBar=True, plotSlipTraces=True, plotSlipBands=True\n", + "plot = dic_grain.plot_map(\n", + " 'max_shear', plot_scale_bar=True, \n", + " plot_slip_traces=True, plot_slip_bands=True\n", ")" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### IPF plotting" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "This plot will show the positions of selected grains in an IPF pole figure, with the marker size representing grain area and mean effective shear strain." ] @@ -680,61 +1073,88 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# For all grains in the DIC map\n", "\n", "# Make an array of quaternions\n", - "grainOris = [grain.ebsdGrain.refOri for grain in dicMap]\n", + "grain_oris = [grain.ebsd_grain.ref_ori for grain in dic_map]\n", "\n", "# Make an array of grain area\n", - "grainAreas = np.array([len(grain) for grain in dicMap]) * dicMap.scale**2\n", + "grain_areas = np.array([len(grain) for grain in dic_map]) * dic_map.scale**2\n", "\n", "# Scaling the grain area, so that the maximum size of a marker is 200 points^2\n", - "grainAreaScaling = 200. / grainAreas.max()\n", + "grain_area_scaling = 200. / grain_areas.max()\n", "\n", "# Make an array of mean effective shear strain\n", - "grainStrains = [np.array(grain.maxShearList).mean() for grain in dicMap]\n", + "grain_strains = [np.array(grain.data.max_shear).mean() for grain in dic_map]\n", "\n", - "plot = Quat.plotIPF(grainOris, direction=[1,0,0], symGroup='cubic', marker='o', \n", - " s=grainAreas*grainAreaScaling, vmin=0, vmax=0.018, cmap='viridis', c=grainStrains)\n", - "plot.addColourBar(label='Mean Effective Shear Strain')\n", - "plot.addLegend(scaling=grainAreaScaling)" + "plot = Quat.plot_ipf(\n", + " grain_oris, direction=[1,0,0], sym_group='cubic', \n", + " marker='o', s=grain_areas*grain_area_scaling, \n", + " c=grain_strains, vmin=0, vmax=0.018, cmap='viridis'\n", + ")\n", + "plot.add_colour_bar(label='Mean effective shear strain')\n", + "plot.add_legend(scaling=grain_area_scaling)" ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# For selected grains in the DIC map\n", "\n", "# Select grains from the DIC map\n", - "dicGrainIDs = [2, 5, 7, 9, 15, 17, 18, 23, 29, 32, 33, 37, 40, 42, 49, 50, 51, 54, 58, 60]\n", + "dic_grain_ids = [\n", + " 2, 5, 7, 9, 15, 17, 18, 23, 29, 32, \n", + " 33, 37, 40, 42, 49, 50, 51, 54, 58, 60\n", + "]\n", "\n", "# Make an array of quaternions\n", - "grainOris = np.array([dicMap[grainID].ebsdGrain.refOri for grainID in dicGrainIDs])\n", + "grain_oris = np.array([\n", + " dic_map[grain_id].ebsd_grain.ref_ori for grain_id in dic_grain_ids\n", + "])\n", "\n", "# Make an array of grain area\n", - "grainAreas = np.array([len(dicMap[grainID]) for grainID in dicGrainIDs]) * dicMap.scale**2\n", + "grain_areas = np.array([\n", + " len(dic_map[grain_id]) for grain_id in dic_grain_ids\n", + "]) * dic_map.scale**2\n", "\n", "# Scaling the grain area, so that the maximum size of a marker is 200 points^2\n", - "grainAreaScaling = 200. / grainAreas.max()\n", + "grain_area_scaling = 200. / grain_areas.max()\n", "\n", "# Make an array of mean effective shear strain\n", - "grainStrains = np.array([np.mean(dicMap[grain].maxShearList) for grain in dicGrainIDs])\n", + "grain_strains = np.array([\n", + " np.mean(dic_map[grain].data.max_shear) for grain in dic_grain_ids\n", + "])\n", "\n", - "plot = Quat.plotIPF(grainOris, direction=[1,0,0], symGroup='cubic', marker='o', \n", - " s=grainAreas*grainAreaScaling, vmin=0, vmax=0.018, cmap='viridis', c=grainStrains)\n", - "plot.addColourBar(label='Mean Effective Shear Strain')\n", - "plot.addLegend(scaling=grainAreaScaling)" + "plot = Quat.plot_ipf(\n", + " grain_oris, direction=[1,0,0], sym_group='cubic', \n", + " marker='o', s=grain_areas*grain_area_scaling, \n", + " c=grain_strains, vmin=0, vmax=0.018, cmap='viridis'\n", + ")\n", + "plot.add_colour_bar(label='Mean effective shear strain')\n", + "plot.add_legend(scaling=grain_area_scaling)" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Create your own" ] @@ -742,7 +1162,11 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "from defdap.plotting import MapPlot, GrainPlot, HistPlot" @@ -751,31 +1175,32 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "mapData = dicMap.e11\n", - "mapData = dicMap.crop(mapData)\n", + "map_data = dic_map.data['e'][0,0]\n", + "map_data = dic_map.crop(map_data)\n", "\n", "plot = MapPlot.create(\n", - " dicMap, mapData,\n", - " vmin=-0.1, vmax=0.1, plotColourBar=True, cmap=\"seismic\",\n", - " plotGBs=True, dilateBoundaries=True, boundaryColour='black'\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "plot.addScaleBar()" + " dic_map, map_data,\n", + " vmin=-0.1, vmax=0.1, plot_colour_bar=True, cmap=\"seismic\",\n", + " plot_gbs=True, dilate_boundaries=True, boundary_colour='black'\n", + ")\n", + "\n", + "plot.add_scale_bar()" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Functions for grain averaging and grain segmentation" ] @@ -783,35 +1208,36 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "plot = dicMap.plotGrainDataMap(\n", - " mapData,\n", - " vmin=-0.06, vmax=0.06, plotColourBar=True,\n", + "plot = dic_map.plot_grain_data_map(\n", + " map_data,\n", + " vmin=-0.06, vmax=0.06, plot_colour_bar=True,\n", " cmap=\"seismic\", clabel=\"Axial strain ($e_11$)\",\n", - " plotScaleBar=True\n", - ")\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "plot.addGrainBoundaries(dilate=True, colour=\"white\")" + " plot_scale_bar=True\n", + ")\n", + "\n", + "plot.add_grain_boundaries(dilate=True, colour=\"white\")" ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "plot = dicMap.plotGrainDataIPF(\n", - " np.array((1,0,0)), mapData, marker='o',\n", - " vmin=-0.06, vmax=0.06, plotColourBar=True, \n", + "plot = dic_map.plot_grain_data_ipf(\n", + " np.array((1,0,0)), map_data, marker='o', \n", + " vmin=-0.06, vmax=0.06, plot_colour_bar=True, \n", " clabel=\"Axial strain ($e_11$)\", cmap=\"seismic\",\n", ")\n" ] @@ -819,39 +1245,44 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "dicGrainID = 41\n", - "dicGrain = dicMap[dicGrainID]\n", + "dic_grain_id = 42\n", + "dic_grain = dic_map[dic_grain_id]\n", "\n", - "plot = dicGrain.plotGrainData(\n", - " mapData, \n", - " vmin=-0.1, vmax=0.1, plotColourBar=True, \n", + "plot = dic_grain.plot_grain_data(\n", + " map_data, \n", + " vmin=-0.1, vmax=0.1, plot_colour_bar=True, \n", " clabel=\"Axial strain ($e_11$)\", cmap=\"seismic\",\n", - " plotScaleBar=True\n", - ")\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "plot.addSlipTraces()" + " plot_scale_bar=True\n", + ")\n", + "\n", + "plot.add_slip_traces()" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Composite plots" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "By utilising some additional functionality within matplotlib, composite plots can be produced." ] @@ -859,7 +1290,11 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "from matplotlib import gridspec" @@ -868,7 +1303,11 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# Create a figure with 3 sets of axes\n", @@ -883,34 +1322,39 @@ "\n", "\n", "# add a strain map\n", - "plot0 = dicMap.plotMaxShear(\n", + "plot0 = dic_map.plot_map(\n", + " map_name='max_shear',\n", " ax=ax0, fig=fig, \n", - " vmin=0, vmax=0.08, plotScaleBar=True, \n", - " plotGBs=True, dilateBoundaries=True\n", + " vmin=0, vmax=0.08, plot_scale_bar=True, \n", + " plot_gbs=True, dilate_boundaries=True\n", ")\n", "\n", "# add an IPF of grain orientations\n", - "dicOris = []\n", - "for grain in dicMap:\n", + "dic_oris = []\n", + "for grain in dic_map:\n", " if len(grain) > 20:\n", - " dicOris.append(grain.refOri)\n", - "plot1 = Quat.plotIPF(\n", - " dicOris, np.array((1,0,0)), 'cubic', \n", + " dic_oris.append(grain.ref_ori)\n", + "plot1 = Quat.plot_ipf(\n", + " dic_oris, np.array((1,0,0)), 'cubic', \n", " ax=ax1, fig=fig, s=10\n", ")\n", "\n", "# add histrogram of strain values\n", "plot2 = HistPlot.create(\n", - " dicMap.crop(dicMap.eMaxShear),\n", + " dic_map.crop(dic_map.data.max_shear),\n", " ax=ax2, fig=fig, marker='o', markersize=2,\n", - " axesType=\"logy\", bins=50, range=(0,0.06)\n", + " axes_type=\"logy\", bins=50, range=(0,0.06)\n", ")\n", "plot2.ax.set_xlabel(\"Effective shear strain\")" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Figures can be saved to raster (png, jpg, ..) and vector formats (eps, svg), the format is guessed from the file extension given. The last displayed figure can be saved using:" ] @@ -918,51 +1362,60 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "plt.savefig(\"test_save_fig.png\", dpi=200)\n", - "plt.savefig(\"test_save_fig.eps\", dpi=200)" + "#plt.savefig(\"test_save_fig.png\", dpi=200)\n", + "#plt.savefig(\"test_save_fig.eps\", dpi=200)" ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "fig, ((ax0, ax1), (ax2, ax3)) = plt.subplots(2, 2, figsize=(8, 6))\n", "\n", - "dicGrainID = 41\n", - "dicGrain = dicMap[dicGrainID]\n", + "dic_grain_id = 42\n", + "dic_grain = dic_map[dic_grain_id]\n", "\n", "# add a strain map\n", - "plot0 = dicGrain.plotMaxShear(\n", + "plot0 = dic_grain.plot_map(\n", + " 'max_shear',\n", " ax=ax0, fig=fig, \n", - " vmin=0, vmax=0.08, plotScaleBar=True,\n", - " plotSlipTraces=True\n", + " vmin=0, vmax=0.08, plot_scale_bar=True,\n", + " plot_slip_traces=True\n", ")\n", "\n", "\n", "# add a misorientation\n", - "ebsdGrain = dicGrain.ebsdGrain\n", - "plot1 = ebsdGrain.plotMisOri(component=0, ax=ax1, fig=fig, vmin=0, vmax=1, clabel=\"GROD\", plotScaleBar=True)\n", + "ebsd_grain = dic_grain.ebsd_grain\n", + "plot1 = ebsd_grain.plot_mis_ori(component=0, ax=ax1, fig=fig, vmin=0, vmax=1, clabel=\"GROD\", plot_scale_bar=True)\n", "\n", "\n", "# add an IPF\n", - "plot2 = ebsdGrain.plotOriSpread(\n", + "plot2 = ebsd_grain.plot_ori_spread(\n", " direction=np.array((1,0,0)), c='b', s=1, alpha=0.2,\n", " ax=ax2, fig=fig\n", ")\n", - "ebsdGrain.plotRefOri(\n", + "ebsd_grain.plot_ref_ori(\n", " direction=np.array((1,0,0)), c='k', s=100, plot=plot2\n", ")\n", "\n", "# add histrogram of strain values\n", "plot3 = HistPlot.create(\n", - " dicMap.crop(dicMap.eMaxShear),\n", + " dic_map.crop(dic_map.data.max_shear),\n", " ax=ax3, fig=fig,\n", - " axesType=\"logy\", bins=50, range=(0,0.06))\n", + " axes_type=\"logy\", bins=50, range=(0,0.06))\n", " \n", "plot3.ax.set_xlabel(\"Effective shear strain\")\n", "\n", @@ -970,17 +1423,78 @@ "plt.tight_layout()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Calculate the z component of rigid body rotation, $$ \\omega_3 = \\frac{F_{12}-F_{21}}{2}, $$ for the HRDIC map. (HINT: the components of deformation gradient (F) are stores in a dic map as f11, f12, etc.)" + ] + }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot $\\omega_3$ as a map with grain boundaries and a scale bar. Choose an appropiate colourmap (see https://matplotlib.org/stable/gallery/color/colormap_reference.html) and scale. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Make a figure containing a map of $\\omega_3$ and a map of misorientaion for a single grain in the DIC map." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Calculate grain average $\\omega_3$ and then plot these on a IPF." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + }, + "tags": [] + }, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "defdap", "language": "python", "name": "python3" }, @@ -994,7 +1508,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.11.13" } }, "nbformat": 4, diff --git a/notebooks/experiment.ipynb b/notebooks/experiment.ipynb new file mode 100644 index 0000000..4e9e5b9 --- /dev/null +++ b/notebooks/experiment.ipynb @@ -0,0 +1,145 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "77d3e73e-6783-40db-a52f-144e301440e5", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import defdap.hrdic as hrdic\n", + "import defdap.ebsd as ebsd\n", + "import defdap.experiment as experiment\n", + "\n", + "from pathlib import Path\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6888c481-eb38-410d-9869-0f17944f9dfc", + "metadata": {}, + "outputs": [], + "source": [ + "exp = experiment.Experiment()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2ae42113-e960-4c0c-b800-62604bfefc9f", + "metadata": {}, + "outputs": [], + "source": [ + "data_dir = Path('/Users/user/Downloads/small_DIC_data_set/')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d31f7404-43fc-4f5d-b677-53e0ea92d0ae", + "metadata": {}, + "outputs": [], + "source": [ + "dic_frame = experiment.Frame()\n", + "for dic_file in sorted(data_dir.glob('B*.txt')):\n", + " hrdic.Map(dic_file, experiment=exp, frame=dic_frame)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "668198bc-0f2d-4121-95e4-ff7cdf9bc1c1", + "metadata": {}, + "outputs": [], + "source": [ + "ebsd_frame = experiment.Frame()\n", + "ebsd.Map(\n", + " data_dir / 'A3_zone1.cpr',\n", + " increment=exp.increments[0], frame=experiment.Frame()\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7cbd31ce-6ac5-4890-bdf4-f8bbc7dd4cd6", + "metadata": {}, + "outputs": [], + "source": [ + "dic_map = exp.increments[0].maps['hrdic']\n", + "dic_map.frame.homog_points = [\n", + " (259, 225), \n", + " (322, 376), \n", + " (91, 21), \n", + " (365, 97)\n", + "]\n", + "ebsd_map = exp.increments[0].maps['ebsd']\n", + "ebsd_map.frame.homog_points = [\n", + " (90, 84), \n", + " (110, 141), \n", + " (31, 10), \n", + " (128, 40)\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2fd94bd2-5485-485a-812a-33628c575a29", + "metadata": {}, + "outputs": [], + "source": [ + "for inc, dic_map in exp.iter_over_maps('hrdic'):\n", + " dic_map.link_ebsd_map(ebsd_map, transform_type=\"affine\")\n", + " dic_map.plot_map(\n", + " 'max_shear', vmin=0, vmax=0.10, \n", + " plot_scale_bar=False, plot_gbs='line'\n", + " )\n", + " plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7fef2016-c924-41a4-8036-8240f46cc1fc", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "457eba02-2eda-4fe3-b70a-40f73aae3bf1", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:defdap]", + "language": "python", + "name": "conda-env-defdap-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/test_ipf.ipynb b/notebooks/test_ipf.ipynb new file mode 100644 index 0000000..209505c --- /dev/null +++ b/notebooks/test_ipf.ipynb @@ -0,0 +1,204 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from defdap.quat import Quat\n", + "from defdap import defaults\n", + "from defdap.plotting import PolePlot\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "e1 = np.array([20., 30., 10.]) * np.pi / 180\n", + "q1 = Quat.from_euler_angles(*e1)\n", + "\n", + "defaults['ipf_triangle_convention'] = 'down'\n", + "q1.plot_ipf([0,0,1], 'hexagonal')\n", + "defaults['ipf_triangle_convention'] = 'up'\n", + "q1.plot_ipf([0,0,1], 'hexagonal')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "e1 = np.array([20., 30., 10.]) * np.pi / 180\n", + "q1 = Quat.from_euler_angles(*e1)\n", + "\n", + "sym = 'hexagonal'\n", + "# sym = 'cubic'\n", + "defaults['ipf_triangle_convention'] = 'down'\n", + "fig, axes = plt.subplots(1, 3, figsize=(10, 4))\n", + "q1.plot_ipf([1,0,0], sym, ax=axes[0])\n", + "q1.plot_ipf([0,1,0], sym, ax=axes[1])\n", + "q1.plot_ipf([0,0,1], sym, ax=axes[2])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "e1 = np.array([20., 30., 10.]) * np.pi / 180\n", + "q1 = Quat.from_euler_angles(*e1)\n", + "\n", + "sym = 'hexagonal'\n", + "# sym = 'cubic'\n", + "\n", + "fig, axes = plt.subplots(1, 3, figsize=(10, 4))\n", + "q1.plot_ipf([1,0,0], sym, ax=axes[0])\n", + "q1.plot_ipf([0,1,0], sym, ax=axes[1])\n", + "q1.plot_ipf([0,0,1], sym, ax=axes[2])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot = PolePlot('IPF', 'hexagonal')\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot = PolePlot('IPF', 'cubic')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot = PolePlot('IPF', 'cubic')\n", + "\n", + "plot.add_line((0, 0, 1), (1, 1, 1), plot_syms=True)\n", + "plot.add_line((0, 0, 1), (1, 0, 1), plot_syms=True)\n", + "plot.add_line((1, 0, 1), (1, 1, 1), plot_syms=True)\n", + "\n", + "plot.label_point((0,0,1), plot_syms=True)\n", + "plot.label_point((1, 1, 1), plot_syms=True)\n", + "plot.label_point((1, 0, 1), plot_syms=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot = PolePlot('IPF', 'hexagonal')\n", + "\n", + "plot.add_line((0, 0, 0, 1), (-1, 2, -1, 0), plot_syms=True)\n", + "plot.add_line((0, 0, 0, 1), (-1, 1, 0, 0), plot_syms=True)\n", + "plot.add_line((-1, 2, -1, 0), (-1, 1, 0, 0), plot_syms=True)\n", + "\n", + "plot.label_point((0, 0, 0, 1), plot_syms=True)\n", + "plot.label_point((-1, 2, -1, 0), plot_syms=True)\n", + "plot.label_point((-1, 1, 0, 0), plot_syms=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "n_oris = 500000\n", + "sym = 'cubic'\n", + "\n", + "eulers = np.random.uniform(size=(n_oris, 3)) * [2*np.pi, 1, 2*np.pi]\n", + "eulers[:, 1] = np.acos(2*eulers[:, 1]-1)\n", + "quats = Quat.create_many_quats(eulers.T)\n", + "ipf_colours = Quat.calc_ipf_colours(quats, [0,0,1], sym)\n", + "\n", + "Quat.plot_ipf(quats, [0,0,1], sym, marker=None, color=ipf_colours.T, s=0.5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "n_oris = 500000\n", + "sym = 'hexagonal'\n", + "defaults['ipf_triangle_convention'] = 'down'\n", + "\n", + "eulers = np.random.uniform(size=(n_oris, 3)) * [2*np.pi, 1, 2*np.pi]\n", + "eulers[:, 1] = np.acos(2*eulers[:, 1]-1)\n", + "quats = Quat.create_many_quats(eulers.T)\n", + "ipf_colours = Quat.calc_ipf_colours(quats, [0,0,1], sym)\n", + "\n", + "Quat.plot_ipf(quats, [0,0,1], sym, marker=None, color=ipf_colours.T, s=0.5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "n_oris = 500000\n", + "sym = 'hexagonal'\n", + "defaults['ipf_triangle_convention'] = 'up'\n", + "\n", + "eulers = np.random.uniform(size=(n_oris, 3)) * [2*np.pi, 1, 2*np.pi]\n", + "eulers[:, 1] = np.acos(2*eulers[:, 1]-1)\n", + "quats = Quat.create_many_quats(eulers.T)\n", + "ipf_colours = Quat.calc_ipf_colours(quats, [0,0,1], sym)\n", + "\n", + "Quat.plot_ipf(quats, [0,0,1], sym, marker=None, color=ipf_colours.T, s=0.5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "defdap", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/scripts/nCorrToDavis.m b/scripts/nCorrToDavis.m index 0d56724..e5eeaed 100644 --- a/scripts/nCorrToDavis.m +++ b/scripts/nCorrToDavis.m @@ -19,7 +19,7 @@ %Make header string header = ['#nCorr 1.2 2D-vector ', ... - int2str(subset_size), ... + int2str(subset_spacing), ... ' ', ... int2str(y_len), ... ' ', ... @@ -39,7 +39,7 @@ for y=1:y_len waitbar(y/y_len, f, 'Exporting data to txt file...') for x=1:x_len - fprintf(fileID,'%1.1f\t%1.1f\t%6.6f\t%6.6f\t\n', ... + fprintf(fileID,'%1.1f\t%1.1f\t%6.6f\t%6.6f\n', ... [((x-1)*subset_spacing)+subset_spacing./2, ... ((y-1)*subset_spacing)+subset_spacing./2, ... u(y,x), ... diff --git a/setup.py b/setup.py index 78c797c..4878f07 100644 --- a/setup.py +++ b/setup.py @@ -41,31 +41,34 @@ def get_version(): 'Natural Language :: English', 'Operating System :: OS Independent', 'Programming Language :: Python :: 3', - 'Programming Language :: Python :: 3.6', - 'Programming Language :: Python :: 3.7', 'Programming Language :: Python :: 3.8', 'Programming Language :: Python :: 3.9', + 'Programming Language :: Python :: 3.10', + 'Programming Language :: Python :: 3.11', 'Framework :: IPython', 'Framework :: Jupyter', 'Framework :: Matplotlib' ], packages=find_packages(exclude=['tests']), package_data={'defdap': ['slip_systems/*.txt']}, - python_requires='>=3.6', + python_requires='>=3.8', install_requires=[ 'scipy>=1.9', 'numpy', 'matplotlib>=3.0.0', - 'scikit-image', + 'scikit-image>=0.19', 'pandas', 'peakutils', 'matplotlib_scalebar', 'networkx', + 'numba', ], extras_require={ - 'testing': ['pytest', 'coverage', 'pytest-cov', 'pytest_cases'], - 'docs': ['sphinx==5.0.2', 'sphinx_rtd_theme==0.5.0', 'sphinx_autodoc_typehints==1.11.1', - 'nbsphinx==0.9.3', 'ipykernel', 'pandoc', 'ipympl'] + 'testing': ['pytest<8', 'coverage', 'pytest-cov', 'pytest_cases'], + 'docs': [ + 'sphinx==5.0.2', 'sphinx_rtd_theme==0.5.0', + 'sphinx_autodoc_typehints==1.11.1', 'nbsphinx==0.9.3', + 'ipykernel', 'pandoc', 'ipympl' + ] } - ) diff --git a/tests/data/expected_output/boundaries_10deg.txt b/tests/data/expected_output/boundaries_10deg.txt deleted file mode 100644 index 75dae84..0000000 --- a/tests/data/expected_output/boundaries_10deg.txt +++ /dev/null @@ -1,243 +0,0 @@ -1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 -0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 -0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 -0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 1 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 1 1 0 1 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 1 1 1 1 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 1 1 1 1 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 1 1 1 1 1 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 1 1 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 1 0 0 0 1 1 0 0 0 1 1 1 1 1 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 1 0 0 0 0 0 1 1 0 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 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 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 1 1 1 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 0 0 1 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 1 1 0 0 0 0 0 1 1 1 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 1 1 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 1 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 1 1 1 1 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 1 1 1 1 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 1 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 1 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 1 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 -0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 -0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 -0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 -0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 -0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 -0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 1 0 1 1 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 1 0 0 0 0 0 0 1 1 1 0 0 0 0 1 1 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 1 1 1 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 1 1 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 1 1 1 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 1 1 0 0 1 1 1 0 1 1 1 0 1 1 1 1 1 1 1 0 0 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 0 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 1 1 1 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 1 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 1 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 1 0 1 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 1 1 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 1 1 1 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 1 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 1 1 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 1 1 0 0 0 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 -1 0 1 1 1 1 1 1 1 1 0 1 1 0 1 1 0 0 0 0 1 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 -1 1 0 0 0 0 0 0 0 1 1 0 1 1 0 1 1 1 1 1 1 1 1 1 0 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 1 0 1 1 1 1 0 0 0 0 0 0 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 1 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 1 0 0 0 0 0 1 1 1 1 0 0 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 1 1 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 diff --git a/tests/data/expected_output/boundaries_5deg.txt b/tests/data/expected_output/boundaries_5deg.txt deleted file mode 100644 index ea34664..0000000 --- a/tests/data/expected_output/boundaries_5deg.txt +++ /dev/null @@ -1,243 +0,0 @@ -1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 -0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 -0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 -0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 1 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 1 1 0 1 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 1 1 1 1 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 1 1 1 1 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 1 1 1 1 1 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 1 1 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 1 0 0 0 1 1 0 0 0 1 1 1 1 1 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 1 0 0 0 0 0 1 1 0 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 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 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 1 1 1 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 0 0 1 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 1 1 0 0 0 0 0 1 1 1 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 1 1 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 1 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 1 1 1 1 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 1 1 1 1 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 1 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 1 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 1 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 -0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 -0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 -0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 -0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 -0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 -0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 1 0 1 1 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 1 0 0 0 0 0 0 1 1 1 0 0 0 0 1 1 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 1 1 1 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 1 1 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 1 1 1 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 1 1 0 0 1 1 1 0 1 1 1 0 1 1 1 1 1 1 1 0 0 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 0 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 1 1 1 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 1 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 1 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 1 0 1 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 1 1 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 1 1 1 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 1 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 1 1 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 1 1 0 0 0 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 -1 0 1 1 1 1 1 1 1 1 0 1 1 0 1 1 0 0 0 0 1 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 -1 1 0 0 0 0 0 0 0 1 1 0 1 1 0 1 1 1 1 1 1 1 1 1 0 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 1 0 1 1 1 1 0 0 0 0 0 0 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 1 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 1 0 0 0 0 0 1 1 1 1 0 0 1 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 1 1 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 diff --git a/tests/data/expected_output/ebsd_grain_boundaries_10deg.npz b/tests/data/expected_output/ebsd_grain_boundaries_10deg.npz new file mode 100644 index 0000000..63d4f8f Binary files /dev/null and b/tests/data/expected_output/ebsd_grain_boundaries_10deg.npz differ diff --git a/tests/data/expected_output/ebsd_grain_boundaries_5deg.npz b/tests/data/expected_output/ebsd_grain_boundaries_5deg.npz new file mode 100644 index 0000000..505878b Binary files /dev/null and b/tests/data/expected_output/ebsd_grain_boundaries_5deg.npz differ diff --git a/tests/data/expected_output/ebsd_grains_5deg_0.npz b/tests/data/expected_output/ebsd_grains_5deg_0.npz new file mode 100644 index 0000000..8afccd6 Binary files /dev/null and b/tests/data/expected_output/ebsd_grains_5deg_0.npz differ diff --git a/tests/data/expected_output/ebsd_grains_5deg_10.npz b/tests/data/expected_output/ebsd_grains_5deg_10.npz new file mode 100644 index 0000000..6babcee Binary files /dev/null and b/tests/data/expected_output/ebsd_grains_5deg_10.npz differ diff --git a/tests/data/expected_output/ebsd_grains_5deg_100.npz b/tests/data/expected_output/ebsd_grains_5deg_100.npz new file mode 100644 index 0000000..d478c6a Binary files /dev/null and b/tests/data/expected_output/ebsd_grains_5deg_100.npz differ diff --git a/tests/data/expected_output/ebsd_grains_warped_5deg_0.npz b/tests/data/expected_output/ebsd_grains_warped_5deg_0.npz new file mode 100644 index 0000000..df1261c Binary files /dev/null and b/tests/data/expected_output/ebsd_grains_warped_5deg_0.npz differ diff --git a/tests/data/expected_output/ebsd_proxigram.npz b/tests/data/expected_output/ebsd_proxigram.npz new file mode 100644 index 0000000..1bfafa0 Binary files /dev/null and b/tests/data/expected_output/ebsd_proxigram.npz differ diff --git a/tests/data/expected_output/hrdic_grain_boundaries_5deg.npz b/tests/data/expected_output/hrdic_grain_boundaries_5deg.npz new file mode 100644 index 0000000..4535de3 Binary files /dev/null and b/tests/data/expected_output/hrdic_grain_boundaries_5deg.npz differ diff --git a/tests/data/expected_output/hrdic_grains_floodfill_0.npz b/tests/data/expected_output/hrdic_grains_floodfill_0.npz new file mode 100644 index 0000000..2a23636 Binary files /dev/null and b/tests/data/expected_output/hrdic_grains_floodfill_0.npz differ diff --git a/tests/data/expected_output/hrdic_grains_floodfill_10.npz b/tests/data/expected_output/hrdic_grains_floodfill_10.npz new file mode 100644 index 0000000..1b5492e Binary files /dev/null and b/tests/data/expected_output/hrdic_grains_floodfill_10.npz differ diff --git a/tests/data/expected_output/hrdic_grains_floodfill_100.npz b/tests/data/expected_output/hrdic_grains_floodfill_100.npz new file mode 100644 index 0000000..79bfc8f Binary files /dev/null and b/tests/data/expected_output/hrdic_grains_floodfill_100.npz differ diff --git a/tests/data/expected_output/hrdic_grains_warp.npz b/tests/data/expected_output/hrdic_grains_warp.npz new file mode 100644 index 0000000..9f6c3a1 Binary files /dev/null and b/tests/data/expected_output/hrdic_grains_warp.npz differ diff --git a/tests/data/expected_output/hrdic_grains_warped-old.npz b/tests/data/expected_output/hrdic_grains_warped-old.npz new file mode 100644 index 0000000..9556a24 Binary files /dev/null and b/tests/data/expected_output/hrdic_grains_warped-old.npz differ diff --git a/tests/data/expected_output/hrdic_grains_warped.npz b/tests/data/expected_output/hrdic_grains_warped.npz new file mode 100644 index 0000000..c7268cc Binary files /dev/null and b/tests/data/expected_output/hrdic_grains_warped.npz differ diff --git a/tests/test_ebsd.py b/tests/test_ebsd.py index ce88ef6..483d7c6 100644 --- a/tests/test_ebsd.py +++ b/tests/test_ebsd.py @@ -1,10 +1,11 @@ import pytest -from pytest import approx -from unittest.mock import Mock +from unittest.mock import Mock, MagicMock import numpy as np import defdap.ebsd as ebsd import defdap.crystal as crystal +from defdap.quat import Quat +from defdap.utils import Datastore DATA_DIR = "tests/data/" @@ -21,81 +22,252 @@ def good_map(): @pytest.fixture(scope="module") def good_map_with_quats(good_map): - good_map.buildQuatArray() + good_map.calc_quat_array() return good_map @pytest.fixture(scope="module") def good_quat_array(good_map_with_quats): - return good_map_with_quats.quatArray + return good_map_with_quats.data.orientation @pytest.fixture(scope="module") def good_phase_array(good_map_with_quats): - return good_map_with_quats.phaseArray + return good_map_with_quats.data.phase + + +@pytest.fixture(scope="module") +def good_grain_boundaries(good_map): + expected = np.load( + f'{EXPECTED_RESULTS_DIR}/ebsd_grain_boundaries_5deg.npz' + ) + return ebsd.BoundarySet( + good_map, + [tuple(row) for row in expected['points_x']], + [tuple(row) for row in expected['points_y']] + ) + + +@pytest.fixture(scope="module") +def good_symmetries(): + over_root2 = np.sqrt(2) / 2 + return [ + Quat(1.0, 0.0, 0.0, 0.0), + Quat(over_root2, over_root2, 0.0, 0.0), + Quat(0.0, 1.0, 0.0, 0.0), + Quat(over_root2, -over_root2, 0.0, 0.0), + Quat(over_root2, 0.0, over_root2, 0.0), + Quat(0.0, 0.0, 1.0, 0.0), + Quat(over_root2, 0.0, -over_root2, 0.0), + Quat(over_root2, 0.0, 0.0, over_root2), + Quat(0.0, 0.0, 0.0, 1.0), + Quat(over_root2, 0.0, 0.0, -over_root2), + Quat(0.0, over_root2, over_root2, 0.0), + Quat(0.0, -over_root2, over_root2, 0.0), + Quat(0.0, over_root2, 0.0, over_root2), + Quat(0.0, -over_root2, 0.0, over_root2), + Quat(0.0, 0.0, over_root2, over_root2), + Quat(0.0, 0.0, -over_root2, over_root2), + Quat(0.5, 0.5, 0.5, 0.5), + Quat(0.5, -0.5, -0.5, -0.5), + Quat(0.5, -0.5, 0.5, 0.5), + Quat(0.5, 0.5, -0.5, -0.5), + Quat(0.5, 0.5, -0.5, 0.5), + Quat(0.5, -0.5, 0.5, -0.5), + Quat(0.5, 0.5, 0.5, -0.5), + Quat(0.5, -0.5, -0.5, 0.5) + ] class TestMapFindBoundaries: - # Depends on Quat.symEqv, self.crystalSym, self.yDim, self.xDim, + # Depends on Quat.sym_eqv, self.crystal_sym, self.y_dim, self.x_dim, # self.quatArray, self.phaseArray # Affects self.boundaries @staticmethod @pytest.fixture - def mock_map(good_quat_array, good_phase_array): + def mock_map(good_quat_array, good_phase_array, good_symmetries): # create stub object mock_map = Mock(spec=ebsd.Map) - mock_map.quatArray = good_quat_array - mock_map.phaseArray = good_phase_array - mock_map.yDim, mock_map.xDim = good_quat_array.shape + mock_datastore = Mock(spec=Datastore) + mock_datastore.orientation = good_quat_array + mock_datastore.phase = good_phase_array + mock_map.data = mock_datastore + mock_map.shape = good_quat_array.shape + + mock_crystal_structure = Mock(spec=crystal.CrystalStructure) + mock_crystal_structure.symmetries = good_symmetries mock_phase = Mock(spec=crystal.Phase) - mock_phase.crystalStructure = crystal.crystalStructures['cubic'] - mock_map.primaryPhase = mock_phase + mock_phase.crystal_structure = mock_crystal_structure + mock_map.primary_phase = mock_phase return mock_map @staticmethod def test_return_type(mock_map): # run test and collect result - ebsd.Map.findBoundaries(mock_map, boundDef=10) - result = mock_map.boundaries + result = ebsd.Map.find_boundaries(mock_map, misori_tol=10) - assert type(result) is np.ndarray - assert result.dtype is np.dtype(np.int64) - assert result.shape == mock_map.quatArray.shape - assert result.max() == 0 - assert result.min() == -1 + assert isinstance(result, tuple) + assert len(result) == 2 + for boundaries in result: + assert isinstance(boundaries, ebsd.BoundarySet) @staticmethod @pytest.mark.parametrize('bound_def', [5, 10]) def test_calc(mock_map, bound_def): # run test and collect result - ebsd.Map.findBoundaries(mock_map, boundDef=bound_def) - result = mock_map.boundaries + _, result = ebsd.Map.find_boundaries( + mock_map, misori_tol=bound_def + ) # load expected - expected = -np.loadtxt( - "{:}boundaries_{:}deg.txt".format(EXPECTED_RESULTS_DIR, bound_def), - dtype=int + expected = np.load( + f'{EXPECTED_RESULTS_DIR}/ebsd_grain_boundaries_{bound_def}deg.npz' ) + expected_x = set([tuple(row) for row in expected['points_x']]) + expected_y = set([tuple(row) for row in expected['points_y']]) + + assert result.points_x == expected_x + assert result.points_y == expected_y + + +class TestMapFindGrains: + # Depends on self.data.grain_boundaries.image_*, self.data.phase, + # self.flood_fill, self.num_phases, self.phases + # Affects self.boundaries + + @staticmethod + @pytest.fixture + def mock_map(good_grain_boundaries, good_phase_array): + # create stub object + mock_map = Mock(spec=ebsd.Map) + mock_datastore = MagicMock(spec=Datastore) + mock_datastore.phase = good_phase_array + mock_datastore.grain_boundaries = good_grain_boundaries + mock_datastore.generate_id = Mock(return_value=1) + mock_map.data = mock_datastore + mock_map.shape = good_phase_array.shape + mock_map.num_phases = 1 + mock_map.phases = [Mock(crystal.Phase)] + + return mock_map + + @staticmethod + def test_return_type(mock_map): + # run test and collect result + result = ebsd.Map.find_grains(mock_map, min_grain_size=10) + + assert isinstance(result, np.ndarray) + assert result.shape == mock_map.shape + assert result.dtype == np.int64 + + @staticmethod + @pytest.mark.parametrize('min_grain_size', [0, 10, 100]) + def test_calc(mock_map, min_grain_size): + # run test and collect result + result = ebsd.Map.find_grains(mock_map, min_grain_size=min_grain_size) + + # load expected + expected = np.load( + f'{EXPECTED_RESULTS_DIR}/ebsd_grains_5deg_{min_grain_size}.npz' + )['grains'] + + assert np.all(result == expected) + + @staticmethod + def test_add_derivative(mock_map): + mock_add_derivative = Mock() + mock_map.data.add_derivative = mock_add_derivative + # run test and collect result + ebsd.Map.find_grains(mock_map, min_grain_size=10) + + mock_add_derivative.assert_called_once() + + @staticmethod + def test_grain_list_type(mock_map): + ebsd.Map.find_grains(mock_map, min_grain_size=10) + result = mock_map._grains + + assert isinstance(result, list) + for g in result: + assert isinstance(g, ebsd.Grain) + + @staticmethod + @pytest.mark.parametrize('min_grain_size, expected_len', [ + (0, 141), (10, 109), (100, 76) + ]) + def test_grain_list_size(mock_map, min_grain_size, expected_len): + ebsd.Map.find_grains(mock_map, min_grain_size=min_grain_size) + result = mock_map._grains - assert np.allclose(result, expected) + assert len(result) == expected_len + @staticmethod + @pytest.mark.parametrize('min_grain_size', [0, 10, 100]) + def test_grain_points(mock_map, min_grain_size): + ebsd.Map.find_grains(mock_map, min_grain_size=min_grain_size) + result = mock_map._grains + + # load expected + expected_grains = np.load( + f'{EXPECTED_RESULTS_DIR}/ebsd_grains_5deg_{min_grain_size}.npz' + )['grains'] + + # transform both to set of tuples so order of points is ignored + for i in range(expected_grains.max()): + expected_point = set(zip(*np.nonzero(expected_grains == i+1)[::-1])) + + assert set([(*r, ) for r in result[i].data.point]) == expected_point + + +class TestMapCalcProxigram: + @staticmethod + @pytest.fixture + def mock_map(good_grain_boundaries, good_phase_array): + # create stub object + mock_map = Mock(spec=ebsd.Map) + mock_datastore = MagicMock(spec=Datastore) + mock_datastore.grain_boundaries = good_grain_boundaries + mock_map.data = mock_datastore + mock_map.shape = good_grain_boundaries.ebsd_map.shape + + return mock_map + + @staticmethod + def test_return_type(mock_map): + # run test and collect result + result = ebsd.Map.calc_proxigram(mock_map) + + assert isinstance(result, np.ndarray) + assert result.shape == mock_map.shape + assert result.dtype == float + + @staticmethod + def test_calc(mock_map): + # run test and collect result + result = ebsd.Map.calc_proxigram(mock_map) + + # load expected + expected = np.load( + f'{EXPECTED_RESULTS_DIR}/ebsd_proxigram.npz' + )['proxigram'] + np.testing.assert_array_equal(result, expected) ''' Functions left to test Map: __init__ -plotDefault -loadData +plot_default +load_data scale transformData plotBandContrastMap -plotEulerMap -plotIPFMap -plotPhaseMap +plot_euler_map +plot_ipf_map +plot_phase_map calcKam plotKamMap calcNye @@ -103,31 +275,30 @@ def test_calc(mock_map, bound_def): checkDataLoaded buildQuatArray findPhaseBoundaries -plotPhaseBoundaryMap -plotBoundaryMap -findGrains -plotGrainMap +plot_phase_boundary_map +plot_boundary_map +plot_grain_map floodFill -calcGrainAvOris -calcGrainMisOri -plotMisOriMap +calc_grain_av_oris +calc_grain_mis_ori +plot_mis_ori_map loadSlipSystems -printSlipSystems -calcAverageGrainSchmidFactors -plotAverageGrainSchmidFactorsMap +print_slip_systems +calc_average_grain_schmid_factors +plot_average_grain_schmid_factors_map Grain: __init__ -addPoint -calcAverageOri -buildMisOriList -plotRefOri -plotOriSpread +add_point +calc_average_ori +build_mis_ori_list +plot_ref_ori +plot_ori_spread plotUnitCell -plotMisOri -calcAverageSchmidFactors -slipTraces -printSlipTraces -calcSlipTraces +plot_mis_ori +calc_average_schmid_factors +slip_traces +print_slip_traces +calc_slip_traces ''' \ No newline at end of file diff --git a/tests/test_hrdic.py b/tests/test_hrdic.py index cbb0546..267646c 100644 --- a/tests/test_hrdic.py +++ b/tests/test_hrdic.py @@ -1,3 +1,228 @@ +import pytest +from unittest.mock import Mock, MagicMock + +import numpy as np + +import defdap.ebsd as ebsd +import defdap.hrdic as hrdic +from defdap.utils import Datastore + + +DATA_DIR = "tests/data/" +EXPECTED_RESULTS_DIR = DATA_DIR + "expected_output/" +EXAMPLE_EBSD = DATA_DIR + "testDataEBSD" + + +@pytest.fixture(scope="module") +def good_grain_boundaries(): + expected = np.load( + f'{EXPECTED_RESULTS_DIR}/hrdic_grain_boundaries_5deg.npz' + ) + mock_map = Mock(spec=hrdic.Map) + mock_map.shape = (200, 300) + return hrdic.BoundarySet( + mock_map, + [tuple(row) for row in expected['points']], + None + ) + + +@pytest.fixture(scope="module") +def good_warped_ebsd_grains(): + return np.load( + f'{EXPECTED_RESULTS_DIR}/ebsd_grains_warped_5deg_0.npz' + )['grains'] + + +@pytest.fixture(scope="module") +def good_warped_dic_grains(): + return np.load( + f'{EXPECTED_RESULTS_DIR}/hrdic_grains_warped.npz' + )['grains'] + + +@pytest.fixture(scope="module") +def good_ebsd_grains(): + return np.load( + f'{EXPECTED_RESULTS_DIR}/ebsd_grains_5deg_0.npz' + )['grains'] + + +class TestMapFindGrains: + # for warp depends on + # check_ebsd_linked, warp_to_dic_frame, shape, ebsd_map + # does not depend on min_grain_size + + # Affects self.boundaries + + @staticmethod + @pytest.fixture + def mock_map(good_warped_ebsd_grains, good_grain_boundaries, + good_warped_dic_grains, good_ebsd_grains): + # create stub object + mock_map = Mock(spec=hrdic.Map) + mock_map.check_ebsd_linked = Mock(return_value=True) + mock_map.warp_to_dic_frame = Mock(return_value=good_warped_ebsd_grains) + mock_map.shape = good_warped_ebsd_grains.shape + mock_map.data = MagicMock(spec=Datastore) + mock_map.data.generate_id = Mock(return_value=1) + mock_map.ebsd_map = MagicMock(spec=ebsd.Map) + mock_map.ebsd_map.__getitem__ = lambda self, k: k + mock_map.ebsd_map.data = Mock(spec=Datastore) + + mock_map.data.grain_boundaries = good_grain_boundaries + + mock_map.experiment = Mock() + mock_map.experiment.warp_image = Mock( + return_value=good_warped_dic_grains + ) + mock_map.frame = Mock() + mock_map.ebsd_map.frame = Mock() + mock_map.ebsd_map.shape = good_warped_dic_grains.shape + mock_map.ebsd_map.data.grains = good_ebsd_grains + + return mock_map + + @staticmethod + @pytest.mark.parametrize('algorithm', ['warp', 'floodfill']) + def test_return_type(mock_map, algorithm): + # algorithm = 'warp' + # run test and collect result + result = hrdic.Map.find_grains(mock_map, algorithm=algorithm) + + assert isinstance(result, np.ndarray) + assert result.shape == mock_map.shape + assert result.dtype == np.int64 + + @staticmethod + @pytest.mark.parametrize('algorithm, min_grain_size', [ + ('warp', None), + ('floodfill', 0), + ('floodfill', 10), + ('floodfill', 100), + ]) + def test_calc_warp(mock_map, algorithm, min_grain_size): + # algorithm = 'warp' + # run test and collect result + result = hrdic.Map.find_grains( + mock_map, algorithm=algorithm, min_grain_size=min_grain_size + ) + + # load expected + min_grain_size = '' if min_grain_size is None else f'_{min_grain_size}' + expected = np.load( + f'{EXPECTED_RESULTS_DIR}/hrdic_grains_{algorithm}{min_grain_size}.npz' + )['grains'] + + assert np.all(result == expected) + + @staticmethod + def test_add_derivative(mock_map): + algorithm = 'warp' + mock_add_derivative = Mock() + mock_map.data.add_derivative = mock_add_derivative + # run test and collect result + hrdic.Map.find_grains(mock_map, algorithm=algorithm) + + mock_add_derivative.assert_called_once() + + @staticmethod + @pytest.mark.parametrize('algorithm', ['warp', 'floodfill']) + def test_grain_list_type(mock_map, algorithm): + algorithm = 'warp' + hrdic.Map.find_grains(mock_map, algorithm=algorithm) + result = mock_map._grains + + assert isinstance(result, list) + for g in result: + assert isinstance(g, hrdic.Grain) + + @staticmethod + @pytest.mark.parametrize('algorithm, expected', [ + ('warp', 111), ('floodfill', 80) + ]) + def test_grain_list_size(mock_map, algorithm, expected): + hrdic.Map.find_grains(mock_map, algorithm=algorithm, min_grain_size=10) + result = mock_map._grains + + assert len(result) == expected + + @staticmethod + @pytest.mark.parametrize('algorithm, min_grain_size', [ + ('warp', None), + ('floodfill', 0), + ('floodfill', 10), + ('floodfill', 100), + ]) + def test_grain_points(mock_map, algorithm, min_grain_size): + hrdic.Map.find_grains( + mock_map, algorithm=algorithm, min_grain_size=min_grain_size + ) + result = mock_map._grains + + # load expected + min_grain_size = '' if min_grain_size is None else f'_{min_grain_size}' + expected_grains = np.load( + f'{EXPECTED_RESULTS_DIR}/hrdic_grains_{algorithm}{min_grain_size}.npz' + )['grains'] + + # transform both to set of tuples so order of points is ignored + for i in range(expected_grains.max()): + expected_point = set(zip(*np.nonzero(expected_grains == i+1)[::-1])) + + assert set([(*r, ) for r in result[i].data.point]) == expected_point + + @staticmethod + def test_call_warp_to_dic_frame(mock_map, good_ebsd_grains): + hrdic.Map.find_grains(mock_map, algorithm='warp') + + mock_map.warp_to_dic_frame.assert_called_once() + mock_map.warp_to_dic_frame.assert_called_with( + good_ebsd_grains, order=0, preserve_range=True + ) + + @staticmethod + def test_call_experiment_warp_image(mock_map, good_ebsd_grains): + hrdic.Map.find_grains(mock_map, algorithm='floodfill', min_grain_size=10) + + good_grains = np.load( + f'{EXPECTED_RESULTS_DIR}/hrdic_grains_floodfill_10.npz' + )['grains'] + + mock_map.experiment.warp_image.assert_called_once() + call_args = mock_map.experiment.warp_image.call_args + np.testing.assert_array_equal( + good_grains.astype(float), call_args[0][0] + ) + assert call_args[0][1] == mock_map.frame + assert call_args[0][2] == mock_map.ebsd_map.frame + assert call_args[1]['output_shape'] == mock_map.ebsd_map.shape + assert call_args[1]['order'] == 0 + + @staticmethod + @pytest.mark.parametrize('algorithm, expected', [ + ('warp', [ + 1, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, 59, 60, 61, 62, 63, 64, 65, 67, 68, 69, 71, 72, 75, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 89, 90, 91, 92, 93, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 105, 106, 107, 108, 109, 111, 112, 113, + 114, 115, 116, 117, 119, 120, 121, 122, 123, 125, 126 + ]), + ('floodfill', [ + 1, 13, 5, 6, 7, 8, 9, 11, 15, 14, 16, 17, 20, 21, 22, 18, 23, 25, + 19, 24, 28, 29, 32, 31, 30, 34, 35, 36, 33, 38, 39, 41, 40, 50, 44, + 39, 52, 47, 51, 48, 37, 57, 58, 65, 61, 62, 64, 72, 77, 79, 81, 80, + 75, 86, 90, 85, 87, 57, 91, 93, 92, 99, 99, 95, 97, 96, 100, 106, + 102, 97, 107, 108, 111, 112, 115, 117, 114, 120, 122, 123 + ]) + ]) + def test_grain_assigned_ebsd_grains(mock_map, algorithm, expected): + hrdic.Map.find_grains(mock_map, algorithm=algorithm, min_grain_size=10) + result = [g.ebsd_grain for g in mock_map._grains] + + assert result == expected # methods to test # '_grad', @@ -6,19 +231,19 @@ # 'boundaries', # 'bseScale', # 'buildNeighbourNetwork', -# 'calcGrainAv', -# 'calcProxigram', +# 'calc_grain_average', +# 'calc_proxigram', # 'checkEbsdLinked', -# 'checkGrainsDetected', -# 'clickGrainID', -# 'clickGrainNeighbours', +# 'check_grains_detected', +# 'click_grain_id', +# 'click_grain_neighbours', # 'clickHomog', # 'clickSaveHomog', # 'crop', # 'cropDists', -# 'crystalSym', +# 'crystal_sym', # 'currGrainId', -# 'displayNeighbours', +# 'display_neighbours', # 'ebsdGrainIds', # 'ebsdMap', # 'ebsdTransform', @@ -34,28 +259,28 @@ # 'grainList', # 'grainPlot', # 'grains', -# 'highlightAlpha', +# 'highlight_alpha', # 'homogPoints', # 'linkEbsdMap', -# 'loadData', +# 'load_data', # 'locateGrainID', # 'mapshape', # 'max_shear', # 'patScale', # 'path', # 'patternImPath', -# 'plotDefault', -# 'plotGrainAvMaxShear', -# 'plotGrainDataIPF', -# 'plotGrainDataMap', -# 'plotGrainNumbers', +# 'plot_default', +# 'plot_grain_av_max_shear', +# 'plot_grain_data_ipf', +# 'plot_grain_data_map', +# 'plot_grain_numbers', # 'plotHomog', -# 'plotMaxShear', +# 'plot_max_shear', # 'plotPattern', -# 'printStatsTable', +# 'print_stats_table', # 'proxigram', # 'proxigramArr', -# 'retrieveName', +# 'retrieve_name', # 'scale', # 'setCrop', # 'setHomogPoint', @@ -64,12 +289,12 @@ # 'updateHomogPoint', # 'version', # 'warpToDicFrame', -# 'xDim', +# 'x_dim', # 'x_map', # 'xc', # 'xd', # 'xdim', -# 'yDim', +# 'y_dim', # 'y_map', # 'yc', # 'yd', diff --git a/tests/test_io.py b/tests/test_io.py index 67dc85d..4fa72e6 100644 --- a/tests/test_io.py +++ b/tests/test_io.py @@ -1,12 +1,14 @@ import pytest import numpy as np +from pathlib import Path import defdap.file_readers from defdap.crystal import crystalStructures, Phase +from defdap.utils import Datastore -DATA_DIR = "tests/data/" -EXAMPLE_EBSD = DATA_DIR + "testDataEBSD" -EXAMPLE_DIC = DATA_DIR + "testDataDIC.txt" +DATA_DIR = Path("tests/data/") +EXAMPLE_EBSD = DATA_DIR / "testDataEBSD" +EXAMPLE_DIC = DATA_DIR / "testDataDIC.txt" class TestEBSDDataLoader: @@ -19,144 +21,165 @@ def data_loader_oxford_binary(): @staticmethod @pytest.fixture def metadata_loaded_oxford_binary(data_loader_oxford_binary): - data_loader_oxford_binary.loadOxfordCPR(EXAMPLE_EBSD) + data_loader_oxford_binary.load_oxford_cpr(EXAMPLE_EBSD) return data_loader_oxford_binary @staticmethod def test_init(data_loader_oxford_binary): - assert isinstance(data_loader_oxford_binary.loadedMetadata, dict) - assert isinstance(data_loader_oxford_binary.loadedData, dict) + assert isinstance(data_loader_oxford_binary.loaded_metadata, dict) + assert isinstance(data_loader_oxford_binary.loaded_data, Datastore) @staticmethod def test_check_metadata_good(data_loader_oxford_binary): """The check_metadata method should pass silently if each phase is of `Phase` type.""" - data_loader_oxford_binary.loadedMetadata["phases"] = [ - Phase("test", 9, ()), - Phase("tester", 11, ()), - Phase("testist", 11, ()), + lattice_params = (1., 1., 1., np.pi / 2, np.pi / 2, 2 * np.pi / 3) + data_loader_oxford_binary.loaded_metadata["phases"] = [ + Phase("test", 9, None, lattice_params), # hex phase needs lattice params + Phase("tester", 11, 225, ()), + Phase("testist", 11, 225, ()), ] - assert data_loader_oxford_binary.checkMetadata() is None + assert data_loader_oxford_binary.check_metadata() is None @staticmethod def test_check_metadata_bad(data_loader_oxford_binary): """The check_metadata method should fail if a phase is is not of `Phase` type.""" - data_loader_oxford_binary.loadedMetadata["phases"] = [ - Phase("test", 9, ()), + data_loader_oxford_binary.loaded_metadata["phases"] = [ + Phase("test", 11, 225, ()), "2" ] with pytest.raises(AssertionError): - data_loader_oxford_binary.checkMetadata() + data_loader_oxford_binary.check_metadata() @staticmethod def test_load_oxford_cpr_good_file(data_loader_oxford_binary): - data_loader_oxford_binary.loadOxfordCPR(EXAMPLE_EBSD) - metadata = data_loader_oxford_binary.loadedMetadata - assert metadata["xDim"] == 359 - assert metadata["yDim"] == 243 + data_loader_oxford_binary.load_oxford_cpr(EXAMPLE_EBSD) + metadata = data_loader_oxford_binary.loaded_metadata + assert metadata["shape"] == (243, 359) # Testing for floating point equality so use approx - assert metadata["stepSize"] == pytest.approx(0.12) - assert metadata["acquisitionRotation"].quatCoef == \ + assert metadata["step_size"] == pytest.approx(0.12) + assert metadata["acquisition_rotation"].quat_coef == \ pytest.approx((1., 0., 0., 0.)) + assert isinstance(metadata['edx'], dict) + assert metadata['edx']['Count'] == 0 + assert type(metadata["phases"]) is list assert len(metadata["phases"]) == 1 loaded_phase = metadata["phases"][0] assert loaded_phase.name == "Ni-superalloy" - assert loaded_phase.latticeParams == \ + assert loaded_phase.lattice_params == \ pytest.approx((3.57, 3.57, 3.57, np.pi/2, np.pi/2, np.pi/2)) - assert loaded_phase.crystalStructure is crystalStructures['cubic'] + assert loaded_phase.crystal_structure is crystalStructures['cubic'] @staticmethod def test_load_oxford_cpr_bad_file(data_loader_oxford_binary): with pytest.raises(FileNotFoundError): - data_loader_oxford_binary.loadOxfordCPR("badger") + data_loader_oxford_binary.load_oxford_cpr(Path("badger")) @staticmethod def test_load_oxford_crc_good_file(metadata_loaded_oxford_binary): - metadata_loaded_oxford_binary.loadOxfordCRC(EXAMPLE_EBSD) - x_dim = metadata_loaded_oxford_binary.loadedMetadata["xDim"] - y_dim = metadata_loaded_oxford_binary.loadedMetadata["yDim"] - assert isinstance(metadata_loaded_oxford_binary.loadedData['bandContrast'], np.ndarray) - assert metadata_loaded_oxford_binary.loadedData['bandContrast'].shape == (y_dim, x_dim) - assert isinstance(metadata_loaded_oxford_binary.loadedData['bandContrast'][0, 0], np.uint8) + metadata_loaded_oxford_binary.load_oxford_crc(EXAMPLE_EBSD) + shape = metadata_loaded_oxford_binary.loaded_metadata["shape"] + + data = metadata_loaded_oxford_binary.loaded_data['phase'] + assert isinstance(data, np.ndarray) + assert data.shape == shape + assert isinstance(data[0, 0], np.uint8) + + data = metadata_loaded_oxford_binary.loaded_data['euler_angle'] + assert isinstance(data, np.ndarray) + assert data.shape == (3, ) + shape + assert isinstance(data[0, 0, 0], np.float32) + + data = metadata_loaded_oxford_binary.loaded_data['band_contrast'] + assert isinstance(data, np.ndarray) + assert data.shape == shape + assert isinstance(data[0, 0], np.uint8) - assert isinstance(metadata_loaded_oxford_binary.loadedData['phase'], np.ndarray) - assert metadata_loaded_oxford_binary.loadedData['phase'].shape == (y_dim, x_dim) - assert isinstance(metadata_loaded_oxford_binary.loadedData['phase'][0, 0], np.uint8) + data = metadata_loaded_oxford_binary.loaded_data['band_slope'] + assert isinstance(data, np.ndarray) + assert data.shape == shape + assert isinstance(data[0, 0], np.uint8) - assert isinstance(metadata_loaded_oxford_binary.loadedData['eulerAngle'], np.ndarray) - assert metadata_loaded_oxford_binary.loadedData['eulerAngle'].shape == (3, y_dim, x_dim) - assert isinstance(metadata_loaded_oxford_binary.loadedData['eulerAngle'][0, 0, 0], np.float64) + data = metadata_loaded_oxford_binary.loaded_data['mean_angular_deviation'] + assert isinstance(data, np.ndarray) + assert data.shape == shape + assert isinstance(data[0, 0], np.float32) @staticmethod def test_load_oxford_crc_bad(metadata_loaded_oxford_binary): with pytest.raises(FileNotFoundError): - metadata_loaded_oxford_binary.loadOxfordCRC("badger") + metadata_loaded_oxford_binary.load_oxford_crc(Path("badger")) class TestDICDataLoader: + # TODO: test openpiv loader + @staticmethod @pytest.fixture - def dic_loader(): - return defdap.file_readers.DICDataLoader() + def davis_loader(): + return defdap.file_readers.DavisLoader() @staticmethod @pytest.fixture - def dic_metadata_loaded(dic_loader): - dic_loader.loadDavisMetadata(EXAMPLE_DIC) - return dic_loader + def dic_metadata_loaded(davis_loader): + davis_loader.load(EXAMPLE_DIC) + return davis_loader @staticmethod @pytest.fixture def dic_data_loaded(dic_metadata_loaded): - dic_metadata_loaded.loadDavisData(EXAMPLE_DIC) + dic_metadata_loaded.load(EXAMPLE_DIC) return dic_metadata_loaded @staticmethod - def test_init(dic_loader): - assert isinstance(dic_loader.loadedMetadata, dict) - assert isinstance(dic_loader.loadedData, dict) + def test_init(davis_loader): + assert isinstance(davis_loader.loaded_metadata, dict) + assert isinstance(davis_loader.loaded_data, Datastore) @staticmethod - def test_load_davis_metadata(dic_loader): - dic_loader.loadDavisMetadata(EXAMPLE_DIC) - metadata = dic_loader.loadedMetadata + def test_load_davis_metadata(davis_loader): + davis_loader.load(EXAMPLE_DIC) + metadata = davis_loader.loaded_metadata assert metadata['format'] == "DaVis" assert metadata['version'] == "8.4.0" assert metadata['binning'] == 12 - assert metadata['xDim'] == 300 - assert metadata['yDim'] == 200 + assert metadata['shape'] == (200, 300) @staticmethod - def test_load_davis_metadata_bad_file(dic_loader): + def test_load_davis_metadata_bad_file(davis_loader): with pytest.raises(FileNotFoundError): - dic_loader.loadDavisMetadata("badger") + davis_loader.load(Path("badger")) @staticmethod def test_load_davis_data(dic_metadata_loaded): - dic_metadata_loaded.loadDavisData(EXAMPLE_DIC) - data = dic_metadata_loaded.loadedData - num_elements = dic_metadata_loaded.loadedMetadata["xDim"] * \ - dic_metadata_loaded.loadedMetadata["yDim"] - assert data['xc'].shape[0] == num_elements - assert data['yc'].shape[0] == num_elements - assert data['xd'].shape[0] == num_elements - assert data['yd'].shape[0] == num_elements + dic_metadata_loaded.load(EXAMPLE_DIC) + shape = dic_metadata_loaded.loaded_metadata["shape"] + + data = dic_metadata_loaded.loaded_data['coordinate'] + assert isinstance(data, np.ndarray) + assert data.shape == (2, ) + shape + assert isinstance(data[0, 0, 0], np.float64) + + data = dic_metadata_loaded.loaded_data['displacement'] + assert isinstance(data, np.ndarray) + assert data.shape == (2, ) + shape + assert isinstance(data[0, 0, 0], np.float64) @staticmethod def test_load_davis_data_bad_file(dic_metadata_loaded): with pytest.raises(FileNotFoundError): - dic_metadata_loaded.loadDavisData("badger") + dic_metadata_loaded.load(Path("badger")) @staticmethod def test_check_davis_data(dic_data_loaded): - assert dic_data_loaded.checkData() is None + assert dic_data_loaded.check_data() is None @staticmethod def test_check__bad_davis_data(dic_data_loaded): - dic_data_loaded.loadedMetadata["xDim"] = 42 - with pytest.raises(AssertionError): - dic_data_loaded.checkData() \ No newline at end of file + dic_data_loaded.loaded_metadata['shape'] = (42, 20) + with pytest.raises(ValueError): + dic_data_loaded.check_data() \ No newline at end of file diff --git a/tests/test_quat.py b/tests/test_quat.py index 8060951..6fba6ef 100644 --- a/tests/test_quat.py +++ b/tests/test_quat.py @@ -9,8 +9,7 @@ # Initialisation tests -@pytest.mark.parametrize('inputLength', - [2, 5, 6]) +@pytest.mark.parametrize('inputLength', [2, 5, 6]) def testInitDimension(inputLength): """Quat initialisation should raise a DimensionError if not length 1, 3, 4""" @@ -33,35 +32,35 @@ def testInitDimension(inputLength): (-np.pi, -np.pi, -np.pi, [0, -1., 0, 0]), ]) def testInitEuler(ph1, phi, ph2, expectedOutput): - """Check quatCoef is correct after initialisation with Eulers""" - returnedQuat = Quat.fromEulerAngles(ph1, phi, ph2) - assert np.allclose(returnedQuat.quatCoef, expectedOutput, atol=1e-4) + """Check quat_coef is correct after initialisation with Eulers""" + returnedQuat = Quat.from_euler_angles(ph1, phi, ph2) + assert np.allclose(returnedQuat.quat_coef, expectedOutput, atol=1e-4) -# Check quatCoef is correct after initialisation with quat array +# Check quat_coef is correct after initialisation with quat array @pytest.mark.parametrize('testValues, expectedOutput', [ ([0, 0, 0, 0], [0, 0, 0, 0]), ([1., 2., 3., 4.], [1., 2., 3., 4.]) ]) def testInitArray(testValues, expectedOutput): - returnedQuat = Quat(testValues).quatCoef + returnedQuat = Quat(testValues).quat_coef assert np.allclose(returnedQuat, expectedOutput, atol=1e-4) -# Check quatCoef is correct after initialisation with quat coeffs +# Check quat_coef is correct after initialisation with quat coeffs @pytest.mark.parametrize('a1, a2, a3, a4, expectedOutput', [ (0, 0, 0, 0, [0, 0, 0, 0]), (1, 2, 3, 4, [1, 2, 3, 4]) ]) def testInitCoeffs(a1, a2, a3, a4, expectedOutput): returnedQuat = Quat(a1, a2, a3, a4) - assert np.allclose(returnedQuat.quatCoef, expectedOutput, atol=1e-4) + assert np.allclose(returnedQuat.quat_coef, expectedOutput, atol=1e-4) def testFlipToNorthernHemisphere(): expectedOutput = [0.5, 0.5, -0.5, 0.5] returnedQuat = Quat(-0.5, -0.5, 0.5, -0.5) - assert np.allclose(returnedQuat.quatCoef, expectedOutput, atol=1e-4) + assert np.allclose(returnedQuat.quat_coef, expectedOutput, atol=1e-4) # Check quat initialisation with an array that's too short @@ -92,8 +91,8 @@ def testInitStrEul(ph1, phi, ph2): Quat(ph1, phi, ph2) -## fromAxisAngle -# Check quatCoef is correct for given axis and angle +## from_axis_angle +# Check quat_coef is correct for given axis and angle @pytest.mark.parametrize('axis, angle, expectedOutput', [ ([1, 0, 0], np.pi, [0, -1, 0, 0]), ([1, 1, 0], -np.pi/2, [np.sin(np.pi/4), 0.5, 0.5, 0]), @@ -101,7 +100,7 @@ def testInitStrEul(ph1, phi, ph2): ([1, -1, -1], -np.pi/2, [np.sin(np.pi/4), 0.4082483, -0.4082483, -0.4082483]) ]) def testFromAxisAngle(axis, angle, expectedOutput): - returnedQuat = Quat.fromAxisAngle(axis, angle).quatCoef + returnedQuat = Quat.from_axis_angle(axis, angle).quat_coef assert np.allclose(returnedQuat, expectedOutput, atol=1e-4) @@ -111,7 +110,7 @@ def testFromAxisAngle(axis, angle, expectedOutput): ]) def testFromAxisAngleStr(axis, angle): with pytest.raises(ValueError): - Quat.fromAxisAngle(axis, angle) + Quat.from_axis_angle(axis, angle) # String in angle should give error @@ -120,7 +119,7 @@ def testFromAxisAngleStr(axis, angle): ]) def testFromAxisAngleStr2(axis, angle): with pytest.raises(TypeError): - Quat.fromAxisAngle(axis, angle) + Quat.from_axis_angle(axis, angle) @pytest.fixture @@ -157,28 +156,28 @@ class TestEulerAngles: @staticmethod def test_return_type(single_quat): - returnEulers = single_quat.eulerAngles() + returnEulers = single_quat.euler_angles() assert type(returnEulers) is np.ndarray assert returnEulers.shape == (3, ) @staticmethod def test_calc(single_quat): - returnEulers = single_quat.eulerAngles() + returnEulers = single_quat.euler_angles() assert np.allclose(returnEulers*180/np.pi, [20., 10., 40.]) @staticmethod def test_calc_chi_q12_0(): in_quat = Quat(0.70710678, 0., 0., 0.70710678) - returnEulers = in_quat.eulerAngles() + returnEulers = in_quat.euler_angles() assert np.allclose(returnEulers, [4.71238898, 0., 0.]) @staticmethod def test_calc_chi_q03_0(): in_quat = Quat(0., 0.70710678, 0.70710678, 0.) - returnEulers = in_quat.eulerAngles() + returnEulers = in_quat.euler_angles() assert np.allclose(returnEulers, [1.57079633, 3.14159265, 0.]) @@ -187,14 +186,14 @@ class TestRotMatrix: @staticmethod def test_return_type(single_quat): - returnMatrix = single_quat.rotMatrix() + returnMatrix = single_quat.rot_matrix() assert type(returnMatrix) is np.ndarray assert returnMatrix.shape == (3, 3) @staticmethod def test_calc(single_quat): - returnMatrix = single_quat.rotMatrix() + returnMatrix = single_quat.rot_matrix() expectedMatrix = np.array([ [ 0.50333996, 0.85684894, 0.1116189 ], @@ -221,7 +220,7 @@ def test_return_type(single_quat, single_quat2): def test_calc(single_quat, single_quat2): result = single_quat * single_quat2 - assert np.allclose(result.quatCoef, + assert np.allclose(result.quat_coef, [0.8365163, 0.28678822, -0.40957602, 0.22414387]) @staticmethod @@ -263,7 +262,7 @@ def test_return_type(single_quat, single_quat2): def test__calc(single_quat, single_quat2): result = single_quat + single_quat2 - assert np.allclose(result.quatCoef, + assert np.allclose(result.quat_coef, [1.44195788, 0.43400514, -0.22726944, 0.08113062]) @staticmethod @@ -286,7 +285,7 @@ def test_return_type(single_quat, single_quat2): def test_calc(single_quat, single_quat2): single_quat += single_quat2 - assert np.allclose(single_quat.quatCoef, + assert np.allclose(single_quat.quat_coef, [1.44195788, 0.43400514, -0.22726944, 0.08113062]) @staticmethod @@ -315,19 +314,19 @@ class TestSetitem: @staticmethod def test_val(single_quat): single_quat[0] = 0.1 - assert np.allclose(single_quat.quatCoef, + assert np.allclose(single_quat.quat_coef, [0.1, -0.08583165, 0.01513444, -0.49809735]) single_quat[1] = 0.2 - assert np.allclose(single_quat.quatCoef, + assert np.allclose(single_quat.quat_coef, [0.1, 0.2, 0.01513444, -0.49809735]) single_quat[2] = 0.3 - assert np.allclose(single_quat.quatCoef, + assert np.allclose(single_quat.quat_coef, [0.1, 0.2, 0.3, -0.49809735]) single_quat[3] = 0.4 - assert np.allclose(single_quat.quatCoef, [0.1, 0.2, 0.3, 0.4]) + assert np.allclose(single_quat.quat_coef, [0.1, 0.2, 0.3, 0.4]) class TestNorm: @@ -351,7 +350,7 @@ class TestNormalise: def test_calc(single_quat_not_unit): single_quat_not_unit.normalise() - assert np.allclose(single_quat_not_unit.quatCoef, + assert np.allclose(single_quat_not_unit.quat_coef, [0.18257419, 0.36514837, -0.54772256, 0.73029674]) @@ -368,7 +367,7 @@ def test_return_type(single_quat): def test_calc(single_quat): result = single_quat.conjugate - assert np.allclose(result.quatCoef, + assert np.allclose(result.quat_coef, [0.86272992, 0.08583165, -0.01513444, 0.49809735]) @@ -376,24 +375,24 @@ class TestTransformVector: @staticmethod def test_return_type(single_quat): - result = single_quat.transformVector(np.array([1., 2., 3.])) + result = single_quat.transform_vector(np.array([1., 2., 3.])) assert type(result) is np.ndarray assert result.shape == (3,) @staticmethod def test_calc(single_quat): - result = single_quat.transformVector(np.array([1., 2., 3.])) + result = single_quat.transform_vector(np.array([1., 2., 3.])) assert np.allclose(result, [2.55189453, 0.5151495, 2.68746261]) @staticmethod def test_bad_in_type(single_quat): with pytest.raises(TypeError): - single_quat.transformVector(10) + single_quat.transform_vector(10) with pytest.raises(TypeError): - single_quat.transformVector(np.array([1., 2., 3., 4.])) + single_quat.transform_vector(np.array([1., 2., 3., 4.])) class TestMisOriCases: @@ -439,7 +438,7 @@ class TestMisOri: @staticmethod @parametrize_with_cases("ins, outs", cases=TestMisOriCases) def test_return_type(ins, outs): - result = ins[0].misOri(*ins[1:]) + result = ins[0].mis_ori(*ins[1:]) if ins[3] == 1: assert type(result) is Quat @@ -454,41 +453,41 @@ def test_return_type(ins, outs): @staticmethod @parametrize_with_cases("ins, outs", cases=TestMisOriCases) def test_calc(ins, outs): - result = ins[0].misOri(*ins[1:]) + result = ins[0].mis_ori(*ins[1:]) if ins[3] == 1: - assert np.allclose(result.quatCoef, outs[1]) + assert np.allclose(result.quat_coef, outs[1]) elif ins[3] == 2: assert result[0] == approx(outs[0]) - assert np.allclose(result[1].quatCoef, outs[1]) + assert np.allclose(result[1].quat_coef, outs[1]) else: assert result == approx(outs[0]) @staticmethod def test_bad_in_type(single_quat): with pytest.raises(TypeError): - single_quat.misOri(4, "blah") + single_quat.mis_ori(4, "blah") class TestMisOriAxis: @staticmethod def test_return_type(single_quat, single_quat2): - result = single_quat.misOriAxis(single_quat2) + result = single_quat.mis_ori_axis(single_quat2) assert type(result) is np.ndarray assert result.shape == (3,) @staticmethod def test_calc(single_quat, single_quat2): - result = single_quat.misOriAxis(single_quat2) + result = single_quat.mis_ori_axis(single_quat2) assert np.allclose(result, [1.10165762, -1.21828737, 2.285256]) @staticmethod def test_bad_in_type(single_quat): with pytest.raises(TypeError): - single_quat.misOriAxis(4) + single_quat.mis_ori_axis(4) class TestExtractQuatComps: @@ -579,7 +578,7 @@ class TestSymEqv: @staticmethod @parametrize_with_cases("ins, outs", cases=TestSymEqvCases) def test_return_type(ins, outs): - syms = Quat.symEqv(*ins) + syms = Quat.sym_eqv(*ins) assert type(syms) is list assert len(syms) == len(outs[0]) @@ -588,30 +587,154 @@ def test_return_type(ins, outs): @staticmethod @parametrize_with_cases("ins, outs", cases=TestSymEqvCases) def test_calc(ins, outs): - syms = Quat.symEqv(*ins) + syms = Quat.sym_eqv(*ins) - assert all([np.allclose(sym.quatCoef, row) for sym, row + assert all([np.allclose(sym.quat_coef, row) for sym, row in zip(syms, outs[0])]) +class TestIpfColour: + + @staticmethod + def test_return_type(ori_quat_list_valid): + ipfColours = Quat.calc_ipf_colours(quats=ori_quat_list_valid, + sym_group='cubic', + direction=[1,0,0]) + + assert type(ipfColours) is np.ndarray + assert ipfColours.shape == (3, len(ori_quat_list_valid)) + + @staticmethod + @pytest.mark.parametrize("direction, expectedOutput", [ + ([1, 0, 0], np.array([[0.35420787, 0.12277055, 1. ], + [0.15471244, 0.48918578, 1. ]])), + ([0, 1, 0], np.array([[0.64776397, 1. , 0.31802678], + [0.44914624, 0.09666619, 1. ]])), + ([0, 0 ,1], np.array([[1. , 0.8721636 , 0.4601925 ], + [0.46039796, 1. , 0.3333338 ]])), + ([1, 1, 0], np.array([[1. , 0.06317326, 0.43581754], + [1. , 0.2596875 , 0.04771856]])), + ([0, 1, 1], np.array([[0.07652159, 0.06402589, 1. ], + [0.6563855, 1. , 0.17397234]])), + ([1, 0 ,1], np.array([[1. , 0.01245505, 0.60290754], + [0.9608291, 0.04005751, 1. ]])) + ]) + def test_calc_cubic(ori_quat_list_valid, direction, expectedOutput): + returnColours = Quat.calc_ipf_colours(quats=ori_quat_list_valid, + sym_group='cubic', + direction=direction) + assert np.allclose(returnColours, expectedOutput.T, atol=1e-4) + + @staticmethod + @pytest.mark.parametrize("direction, expectedOutput", [ + ([1, 0, 0], np.array([[1. , 0.5744279 , 0.35764635], + [1. , 0.95659405, 0.08325193]])), + ([0, 1, 0], np.array([[0.5724089 , 0.32813743, 1. ], + [0.4527689 , 1. , 0.11840012]])), + ([0, 0 ,1], np.array([[0.46313933, 1. , 0.39832234], + [0.7022287 , 1. , 0.40724975]])), + ([1, 1, 0], np.array([[0.2315231 , 0.79978704, 1. ], + [0.1326262 , 0.05264888, 1. ]])), + ([0, 1, 1], np.array([[1. , 0.64148784, 0.8374021 ], + [0.04142377, 0.05431259, 1. ]])), + ([1, 0 ,1], np.array([[0.33415037, 0.9863902 , 1. ], + [1. , 0.27872643, 0.23925099]])) + ]) + def test_calc_hexagonal(ori_quat_list_valid, direction, expectedOutput): + returnColours = Quat.calc_ipf_colours(quats=ori_quat_list_valid, + sym_group='hexagonal', + direction=direction) + assert np.allclose(returnColours, expectedOutput.T, atol=1e-4) +class TestFundDirs: + @staticmethod + def test_return_type(ori_quat_list_valid): + fundDirs = Quat.calc_fund_dirs(quats=ori_quat_list_valid, + direction=[1,0,0], + sym_group='cubic') + + assert type(fundDirs) is tuple + assert len(fundDirs) == 2 + + @staticmethod + @pytest.mark.parametrize("direction, expectedOutput", [ + ([1, 0, 0], (np.array([0.69952609, 0.78403021]), + np.array([2.2874346 , 2.12872533]))), + ([0, 1, 0], (np.array([0.52608403, 0.65695865]), + np.array([1.7791031 , 2.30187058]))), + ([0, 0 ,1], (np.array([0.45057319, 0.58619799]), + np.array([1.86989854, 1.78713809]))), + ([1, 1, 0], (np.array([0.30188751, 0.18179439]), + np.array([2.28007559, 1.70378284]))), + ([0, 1, 1], (np.array([0.8741375 , 0.5004212]), + np.array([2.31714169, 1.69736755]))), + ([1, 0 ,1], (np.array([0.36088574, 0.48914496]), + np.array([2.3446426 , 2.33373084]))) + ]) + def test_calc_cubic(ori_quat_list_valid, direction, expectedOutput): + returnDirs = Quat.calc_fund_dirs(quats=ori_quat_list_valid, + sym_group='cubic', + direction=direction) + assert np.allclose(returnDirs, expectedOutput, atol=1e-4) + + @staticmethod + @pytest.mark.parametrize("direction, expectedOutput", [ + ([1, 0, 0], (np.array([0.69952609, 0.78403021]), + np.array([1.76383582, 1.60512655]))), + ([0, 1, 0], (np.array([1.05721982, 1.09881856]), + np.array([1.97488301, 1.61887046]))), + ([0, 0 ,1], (np.array([1.14159266, 0.99999999]), + np.array([1.71238897, 1.71238897]))), + ([1, 1, 0], (np.array([1.37592272, 1.39062481]), + np.array([1.8623474 , 2.07002582]))), + ([0, 1, 1], (np.array([0.8741375 , 1.510193 ]), + np.array([1.87164852, 2.06784385]))), + ([1, 0 ,1], (np.array([1.32143956, 0.48914496]), + np.array([1.83444972, 1.81013206]))) + ]) + def test_calc_hexagonal_up(ori_quat_list_valid, direction, expectedOutput): + returnColours = Quat.calc_fund_dirs(quats=ori_quat_list_valid, + sym_group='hexagonal', + direction=direction, + triangle='up') + assert np.allclose(returnColours, expectedOutput, atol=1e-4) + + @staticmethod + @pytest.mark.parametrize("direction, expectedOutput", [ + ([1, 0, 0], (np.array([0.69952609, 0.78403021]), + np.array([1.37775683, 1.5364661 ]))), + ([0, 1, 0], (np.array([1.05721982, 1.09881856]), + np.array([1.16670964, 1.5227222 ]))), + ([0, 0 ,1], (np.array([1.14159266, 0.99999999]), + np.array([1.42920368, 1.42920368]))), + ([1, 1, 0], (np.array([1.37592272, 1.39062481]), + np.array([1.27924525, 1.07156684]))), + ([0, 1, 1], (np.array([0.8741375, 1.510193 ]), + np.array([1.26994414, 1.0737488 ]))), + ([1, 0 ,1], (np.array([1.32143956, 0.48914496]), + np.array([1.30714293, 1.33146059]))) + ]) + def test_calc_hexagonal_down(ori_quat_list_valid, direction, expectedOutput): + returnColours = Quat.calc_fund_dirs(quats=ori_quat_list_valid, + sym_group='hexagonal', + direction=direction, + triangle='down') + assert np.allclose(returnColours, expectedOutput, atol=1e-4) ''' Functions left to test __repr__(self): __str__(self): -plotIPF +plot_ipf plotUnitCell -createManyQuats(eulerArray) -calcSymEqvs(quats, symGroup, dtype=np.float) -calcAverageOri(quatComps) +create_many_quats(eulerArray) +calc_sym_eqvs(quats, symGroup, dtype=np.float) +calc_average_ori(quatComps) calcMisOri(quatComps, refOri) -polarAngles(x, y, z) -calcIPFcolours(quats, direction, symGroup) -calcFundDirs(quats, direction, symGroup, dtype=np.float) +polar_angles(x, y, z) '''