Index: C:/workspaces/eclipse3/base/ui/src/org/tigris/subversion/subclipse/ui/dialogs/CommitDialog.java =================================================================== --- C:/workspaces/eclipse3/base/ui/src/org/tigris/subversion/subclipse/ui/dialogs/CommitDialog.java (revision 0) +++ C:/workspaces/eclipse3/base/ui/src/org/tigris/subversion/subclipse/ui/dialogs/CommitDialog.java (revision 0) @@ -0,0 +1,434 @@ +package org.tigris.subversion.subclipse.ui.dialogs; + +import java.util.Arrays; +import java.util.List; + +import org.eclipse.core.resources.IResource; +import org.eclipse.core.runtime.IAdaptable; +import org.eclipse.jface.dialogs.Dialog; +import org.eclipse.jface.dialogs.IDialogConstants; +import org.eclipse.jface.resource.ImageDescriptor; +import org.eclipse.jface.util.IPropertyChangeListener; +import org.eclipse.jface.util.PropertyChangeEvent; +import org.eclipse.jface.viewers.CheckboxTableViewer; +import org.eclipse.jface.viewers.ColumnPixelData; +import org.eclipse.jface.viewers.ColumnWeightData; +import org.eclipse.jface.viewers.ILabelProviderListener; +import org.eclipse.jface.viewers.ISelectionChangedListener; +import org.eclipse.jface.viewers.IStructuredContentProvider; +import org.eclipse.jface.viewers.ITableLabelProvider; +import org.eclipse.jface.viewers.SelectionChangedEvent; +import org.eclipse.jface.viewers.TableLayout; +import org.eclipse.jface.viewers.Viewer; +import org.eclipse.jface.viewers.ViewerSorter; +import org.eclipse.swt.SWT; +import org.eclipse.swt.events.SelectionAdapter; +import org.eclipse.swt.events.SelectionEvent; +import org.eclipse.swt.events.SelectionListener; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.layout.GridData; +import org.eclipse.swt.layout.GridLayout; +import org.eclipse.swt.widgets.Button; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Control; +import org.eclipse.swt.widgets.Label; +import org.eclipse.swt.widgets.Shell; +import org.eclipse.swt.widgets.Table; +import org.eclipse.swt.widgets.TableColumn; +import org.eclipse.swt.widgets.TableItem; +import org.eclipse.team.core.TeamException; +import org.eclipse.ui.help.WorkbenchHelp; +import org.eclipse.ui.internal.util.SWTResourceUtil; +import org.eclipse.ui.model.IWorkbenchAdapter; +import org.tigris.subversion.subclipse.core.ISVNLocalResource; +import org.tigris.subversion.subclipse.core.SVNException; +import org.tigris.subversion.subclipse.core.resources.LocalResourceStatus; +import org.tigris.subversion.subclipse.core.resources.SVNWorkspaceRoot; +import org.tigris.subversion.subclipse.ui.IHelpContextIds; +import org.tigris.subversion.subclipse.ui.Policy; +import org.tigris.subversion.subclipse.ui.comments.CommitCommentArea; +import org.tigris.subversion.svnclientadapter.SVNStatusKind; + +public class CommitDialog extends Dialog { + + private static final int WIDTH_HINT = 500; + private final static int SELECTION_HEIGHT_HINT = 100; + + private CommitCommentArea commitCommentArea; + private IResource[] resourcesToCommit; + private String url; + private boolean unaddedResources; + private Object[] selectedResources; + private CheckboxTableViewer listViewer; + + public CommitDialog(Shell parentShell, IResource[] resourcesToCommit, String url, boolean unaddedResources) { + super(parentShell); + int shellStyle = getShellStyle(); + setShellStyle(shellStyle | SWT.RESIZE); + commitCommentArea = new CommitCommentArea(this, null); + this.resourcesToCommit = resourcesToCommit; + this.url = url; + this.unaddedResources = unaddedResources; + } + + /* + * @see Dialog#createDialogArea(Composite) + */ + protected Control createDialogArea(Composite parent) { + getShell().setText(Policy.bind("CommitDialog.title")); //$NON-NLS-1$ + Composite composite = new Composite(parent, SWT.NULL); + composite.setLayout(new GridLayout()); + composite.setLayoutData(new GridData(GridData.FILL_BOTH)); + + Label label = createWrappingLabel(composite); + if (url == null) label.setText(Policy.bind("CommitDialog.commitTo") + " " + Policy.bind("CommitDialog.multiple")); //$NON-NLS-1$ + else label.setText(Policy.bind("CommitDialog.commitTo") + " " + url); //$NON-NLS-1$ + commitCommentArea.createArea(composite); + commitCommentArea.addPropertyChangeListener(new IPropertyChangeListener() { + public void propertyChange(PropertyChangeEvent event) { + if (event.getProperty() == CommitCommentArea.OK_REQUESTED) + okPressed(); + } + }); + + addResourcesArea(composite); + + // set F1 help + WorkbenchHelp.setHelp(composite, IHelpContextIds.RELEASE_COMMENT_DIALOG); + + return composite; + } + + private void addResourcesArea(Composite composite) { + + // add a description label + Label label = createWrappingLabel(composite); + label.setText(Policy.bind("CommitDialog.resources")); //$NON-NLS-1$ + // add the selectable checkbox list + Table table = new Table(composite, SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.MULTI | SWT.CHECK); + table.setHeaderVisible(true); + table.setLinesVisible(true); + TableLayout layout = new TableLayout(); + table.setLayout(layout); + + listViewer = new CheckboxTableViewer(table); + GridData data = new GridData(GridData.FILL_BOTH); + data.heightHint = SELECTION_HEIGHT_HINT; + data.widthHint = WIDTH_HINT; + listViewer.getTable().setLayoutData(data); + createColumns(table, layout); + // set the contents of the list + listViewer.setLabelProvider(new ITableLabelProvider() { + public String getColumnText(Object element, int columnIndex) { + String result = null; + switch (columnIndex) { + case 0 : + result = ""; + break; + case 1: + if (url == null) result = ((IResource)element).getFullPath().toString(); + else result = getResource((IResource)element); + break; + case 2: + result = getStatus((IResource)element); + break; + default: + result = ""; + break; + } + + return result; + } + // Strip off segments of path that are included in URL. + private String getResource(IResource resource) { + String[] segments = resource.getFullPath().segments(); + StringBuffer path = new StringBuffer(); + for (int i = 0; i < segments.length; i++) { + path.append("/" + segments[i]); + if (url.endsWith(path.toString())) { + if (i == (segments.length - 2)) + return resource.getFullPath().toString().substring(path.length() + 1); + else + return resource.getFullPath().toString().substring(path.length()); + } + } + return resource.getFullPath().toString(); + } + public Image getColumnImage(Object element, int columnIndex) { + if (columnIndex == 1) { + if (element instanceof IAdaptable) { + IWorkbenchAdapter adapter = (IWorkbenchAdapter) ((IAdaptable) element).getAdapter( + IWorkbenchAdapter.class); + if (adapter == null) { + return null; + } + ImageDescriptor descriptor = adapter.getImageDescriptor(element); + if (descriptor == null) return null; + Image image = (Image) SWTResourceUtil.getImageTable().get(descriptor); + if (image == null) { + image = descriptor.createImage(); + SWTResourceUtil.getImageTable().put(descriptor, image); + } + return image; + } + } + return null; + } + public void addListener(ILabelProviderListener listener) { + } + public void dispose() { + } + public boolean isLabelProperty(Object element, String property) { + return false; + } + public void removeListener(ILabelProviderListener listener) { + } + }); + + listViewer.setSorter(new CommitSorter(1)); + + listViewer.setContentProvider(new IStructuredContentProvider() { + public Object[] getElements(Object inputElement) { + return resourcesToCommit; + } + public void dispose() { + } + public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { + } + }); + listViewer.setInput(new AdaptableResourceList(resourcesToCommit)); + if (selectedResources == null) { + setChecks(); + } else { + listViewer.setCheckedElements(selectedResources); + } + listViewer.addSelectionChangedListener(new ISelectionChangedListener() { + public void selectionChanged(SelectionChangedEvent event) { + selectedResources = listViewer.getCheckedElements(); + } + }); + + addSelectionButtons(composite); + + } + + private static String getStatus(IResource resource) { + ISVNLocalResource svnResource = SVNWorkspaceRoot.getSVNResourceFor(resource); + String result = null; + try { + LocalResourceStatus status = svnResource.getStatus(); + if (status.isAdded()) + result = Policy.bind("CommitDialog.added"); //$NON-NLS-1$ + else + if (status.isDeleted()) + result = Policy.bind("CommitDialog.deleted"); //$NON-NLS-1$ + else + if (status.isTextModified()) + result = Policy.bind("CommitDialog.modified"); //$NON-NLS-1$ + else + if (svnResource.getStatus().getPropStatus().equals(SVNStatusKind.MODIFIED)) + result = Policy.bind("CommitDialog.propertiesModified"); //$NON-NLS-1$ + else + if (!status.isManaged()) + result = Policy.bind("CommitDialog.unversioned"); //$NON-NLS-1$ + else + result = ""; + } catch (TeamException e) { + result = ""; + } + return result; + } + + /** + * Method createColumns. + * @param table + * @param layout + * @param viewer + */ + private void createColumns(Table table, TableLayout layout) { + // sortable table + SelectionListener headerListener = new SelectionAdapter() { + public void widgetSelected(SelectionEvent e) { + // column selected - need to sort + int column = listViewer.getTable().indexOf((TableColumn) e.widget); + CommitSorter oldSorter = (CommitSorter) listViewer.getSorter(); + if (oldSorter != null && column == oldSorter.getColumnNumber()) { + oldSorter.setReversed(!oldSorter.isReversed()); + listViewer.refresh(); + } else { + listViewer.setSorter(new CommitSorter(column)); + } + } + }; + + TableColumn col; + // check + col = new TableColumn(table, SWT.NONE); + col.setResizable(false); + layout.addColumnData(new ColumnPixelData(20, false)); + col.addSelectionListener(headerListener); + + // resource + col = new TableColumn(table, SWT.NONE); + col.setResizable(true); + col.setText(Policy.bind("PendingOperationsView.resource")); //$NON-NLS-1$ + layout.addColumnData(new ColumnWeightData(120, true)); + col.addSelectionListener(headerListener); + + // status + col = new TableColumn(table, SWT.NONE); + col.setResizable(true); + col.setText(Policy.bind("ResourcePropertiesPage.status")); //$NON-NLS-1$ + layout.addColumnData(new ColumnWeightData(50, true)); + col.addSelectionListener(headerListener); + + } + + /** + * Add the selection and deselection buttons to the dialog. + * @param composite org.eclipse.swt.widgets.Composite + */ + private void addSelectionButtons(Composite composite) { + + Composite buttonComposite = new Composite(composite, SWT.RIGHT); + GridLayout layout = new GridLayout(); + layout.numColumns = 3; + buttonComposite.setLayout(layout); + GridData data = + new GridData(GridData.HORIZONTAL_ALIGN_END | GridData.GRAB_HORIZONTAL); + data.grabExcessHorizontalSpace = true; + composite.setData(data); + + Button selectButton = createButton(buttonComposite, IDialogConstants.SELECT_ALL_ID, Policy.bind("ReleaseCommentDialog.selectAll"), false); //$NON-NLS-1$ + SelectionListener listener = new SelectionAdapter() { + public void widgetSelected(SelectionEvent e) { + listViewer.setAllChecked(true); + selectedResources = null; + } + }; + selectButton.addSelectionListener(listener); + + Button deselectButton = createButton(buttonComposite, IDialogConstants.DESELECT_ALL_ID, Policy.bind("ReleaseCommentDialog.deselectAll"), false); //$NON-NLS-1$ + listener = new SelectionAdapter() { + public void widgetSelected(SelectionEvent e) { + listViewer.setAllChecked(false); + selectedResources = new Object[0]; + } + }; + deselectButton.addSelectionListener(listener); + + if (unaddedResources) { + Button deselectUnaddedButton = new Button(buttonComposite, SWT.PUSH); + deselectUnaddedButton.setText(Policy.bind("CommitDialog.deselectUnadded")); //$NON-NLS-1$ + deselectUnaddedButton.addSelectionListener(new SelectionAdapter() { + public void widgetSelected(SelectionEvent e) { + TableItem[] items = listViewer.getTable().getItems(); + for (int i = 0; i < items.length; i++) { + IResource resource = (IResource)items[i].getData(); + ISVNLocalResource svnResource = SVNWorkspaceRoot.getSVNResourceFor(resource); + try { + if (!svnResource.isManaged()) items[i].setChecked(false); + } catch (SVNException e1) {} + } + selectedResources = listViewer.getCheckedElements(); + } + }); + } + } + + /** + * Returns the comment. + * @return String + */ + public String getComment() { + return commitCommentArea.getComment(); + } + + /** + * Returns the selected resources. + * @return IResource[] + */ + public IResource[] getSelectedResources() { + if (selectedResources == null) { + return resourcesToCommit; + } else { + List result = Arrays.asList(selectedResources); + return (IResource[]) result.toArray(new IResource[result.size()]); + } + } + + protected static final int LABEL_WIDTH_HINT = 400; + protected Label createWrappingLabel(Composite parent) { + Label label = new Label(parent, SWT.LEFT | SWT.WRAP); + GridData data = new GridData(); + data.horizontalSpan = 1; + data.horizontalAlignment = GridData.FILL; + data.horizontalIndent = 0; + data.grabExcessHorizontalSpace = true; + data.widthHint = LABEL_WIDTH_HINT; + label.setLayoutData(data); + return label; + } + + private void setChecks() { + listViewer.setAllChecked(true); + selectedResources = listViewer.getCheckedElements(); + } + + private static class CommitSorter extends ViewerSorter { + private boolean reversed = false; + private int columnNumber; + private static final int NUM_COLUMNS = 3; + private static final int[][] SORT_ORDERS_BY_COLUMN = { + {0, 1, 2}, /* check */ + {1, 0, 2}, /* resource */ + {2, 0, 1} /* status */ + }; + + public CommitSorter(int columnNumber) { + this.columnNumber = columnNumber; + } + + public int compare(Viewer viewer, Object e1, Object e2) { + IResource r1 = (IResource)e1; + IResource r2 = (IResource)e2; + int[] columnSortOrder = SORT_ORDERS_BY_COLUMN[columnNumber]; + int result = 0; + for (int i = 0; i < NUM_COLUMNS; ++i) { + result = compareColumnValue(columnSortOrder[i], r1, r2); + if (result != 0) + break; + } + if (reversed) + result = -result; + return result; + } + + private int compareColumnValue(int columnNumber, IResource r1, IResource r2) { + switch (columnNumber) { + case 0: /* check */ + return 0; + case 1: /* resource */ + return collator.compare(r1.getFullPath().toString(), r2.getFullPath().toString()); + case 2: /* status */ + return collator.compare(getStatus(r1), getStatus(r2)); + default: + return 0; + } + } + + public int getColumnNumber() { + return columnNumber; + } + + public boolean isReversed() { + return reversed; + } + + public void setReversed(boolean newReversed) { + reversed = newReversed; + } + + } + +} Index: C:/workspaces/eclipse3/base/ui/src/org/tigris/subversion/subclipse/ui/actions/CommitAction.java =================================================================== --- C:/workspaces/eclipse3/base/ui/src/org/tigris/subversion/subclipse/ui/actions/CommitAction.java (revision 1060) +++ C:/workspaces/eclipse3/base/ui/src/org/tigris/subversion/subclipse/ui/actions/CommitAction.java (working copy) @@ -17,26 +17,43 @@ import org.eclipse.core.resources.IResource; import org.eclipse.core.resources.IResourceVisitor; +import org.eclipse.core.resources.IWorkspaceRoot; +import org.eclipse.core.resources.ResourcesPlugin; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.jface.action.IAction; +import org.eclipse.jface.dialogs.MessageDialog; import org.eclipse.jface.operation.IRunnableWithProgress; import org.eclipse.team.core.TeamException; import org.eclipse.ui.actions.WorkspaceModifyOperation; +import org.tigris.subversion.subclipse.core.ISVNLocalFolder; import org.tigris.subversion.subclipse.core.ISVNLocalResource; import org.tigris.subversion.subclipse.core.ISVNRunnable; import org.tigris.subversion.subclipse.core.SVNException; import org.tigris.subversion.subclipse.core.SVNProviderPlugin; +import org.tigris.subversion.subclipse.core.commands.GetStatusCommand; +import org.tigris.subversion.subclipse.core.resources.LocalResourceStatus; import org.tigris.subversion.subclipse.core.resources.SVNWorkspaceRoot; import org.tigris.subversion.subclipse.ui.Policy; import org.tigris.subversion.subclipse.ui.SVNUIPlugin; +import org.tigris.subversion.subclipse.ui.dialogs.CommitDialog; import org.tigris.subversion.subclipse.ui.repository.RepositoryManager; +import org.tigris.subversion.svnclientadapter.SVNStatusKind; +import org.tigris.subversion.svnclientadapter.SVNUrl; /** * Action for checking in files to a subversion provider - * Prompts the user for a release comment. + * Prompts the user for a release comment, and shows a selection + * list of added and modified resources, including unversioned resources. + * If selected, unversioned resources will be added to version control, + * and committed. */ public class CommitAction extends WorkspaceAction { + private String commitComment; + private IResource[] resourcesToCommit; + private String url; + private boolean unaddedResources; + private boolean commit; /* * get non added resources and prompts for resources to be added @@ -48,25 +65,39 @@ public void execute(IAction action) throws InvocationTargetException, InterruptedException { final IResource[] resources = getSelectedResources(); final RepositoryManager manager = SVNUIPlugin.getPlugin().getRepositoryManager(); - final String[] comment = new String[] {null}; final IResource[][] resourcesToBeAdded = new IResource[][] { null }; run(new IRunnableWithProgress() { public void run(IProgressMonitor monitor) throws InvocationTargetException { try { - // search for any non-added, non-ignored resources in the selection - IResource[] unadded = getUnaddedResources(resources, monitor); - resourcesToBeAdded[0] = promptForResourcesToBeAdded(manager, unadded); - if (resourcesToBeAdded[0] == null) { - return; + // search for modified or added, non-ignored resources in the selection. + IResource[] modified = getModifiedResources(resources, monitor); + + // if no changes since last commit, do not show commit dialog. + if (modified.length == 0) { + MessageDialog.openInformation(getShell(), Policy.bind("CommitDialog.title"), Policy.bind("CommitDialog.noChanges")); //$NON-NLS-1$ + commit = false; + } else + commit = confirmCommit(modified); + + // if commit was not canceled, create a list of any + // unversioned resources that were selected. + if (commit) { + List toBeAddedList = new ArrayList(); + for (int i = 0; i < resourcesToCommit.length; i++) { + IResource resource = resourcesToCommit[i]; + ISVNLocalResource svnResource = SVNWorkspaceRoot.getSVNResourceFor(resource); + if (!svnResource.isManaged()) toBeAddedList.add(resource); + } + resourcesToBeAdded[0] = new IResource[toBeAddedList.size()]; + toBeAddedList.toArray(resourcesToBeAdded[0]); } - comment[0] = promptForComment(manager, resources); } catch (TeamException e) { throw new InvocationTargetException(e); } } }, true /* cancelable */, PROGRESS_BUSYCURSOR); //$NON-NLS-1$ - if (comment[0] == null) { + if (!commit) { return; // user canceled } @@ -80,16 +111,16 @@ try { int ticks=100; monitor.beginTask(null, ticks); + + // add unversioned resources. if (resourcesToBeAdded[0].length > 0) { int addTicks = 20; manager.add(resourcesToBeAdded[0], Policy.subMonitorFor(monitor, addTicks)); ticks-=addTicks; } - IResource[] shared = getSharedResources(resources); - if (shared.length == 0) { - return; - } - manager.commit(shared, comment[0], Policy.subMonitorFor(monitor,ticks)); + + // commit resources. + manager.commit(resourcesToCommit, commitComment, Policy.subMonitorFor(monitor,ticks)); for (int i = 0; i < resources.length; i++) { IResource projectHandle = resources[i].getProject(); projectHandle.refreshLocal(IResource.DEPTH_INFINITE, monitor); @@ -109,7 +140,7 @@ } }, true /* cancelable */, PROGRESS_DIALOG); //$NON-NLS-1$ } - + /** * get the unadded resources in resources parameter */ @@ -145,42 +176,72 @@ if (exception[0] != null) throw exception[0]; } } + unaddedResources = unadded.size() > 0; return (IResource[]) unadded.toArray(new IResource[unadded.size()]); - } + } - - /* - * Return all resources in the provided collection that are shared with a repo - * @param resources - * @return IResource[] - */ - private IResource[] getSharedResources(IResource[] resources) throws SVNException { - List shared = new ArrayList(); - for (int i = 0; i < resources.length; i++) { - IResource resource = resources[i]; - ISVNLocalResource svnResource = SVNWorkspaceRoot.getSVNResourceFor(resource); - if (svnResource.isManaged()) { - shared.add(resource); - } + /** + * get the modified and unadded resources in resources parameter + */ + private IResource[] getModifiedResources(IResource[] resources, IProgressMonitor iProgressMonitor) throws SVNException { + IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot(); + final List modified = new ArrayList(); + final SVNException[] exception = new SVNException[] { null }; + for (int i = 0; i < resources.length; i++) { + IResource resource = resources[i]; + ISVNLocalResource svnResource = SVNWorkspaceRoot.getSVNResourceFor(resource); + + // if only one resource selected, get url. Commit dialog displays this. + if (resources.length == 1) { + SVNUrl svnUrl = svnResource.getStatus().getUrl(); + if (svnUrl == null) url = getParentUrl(svnResource); + else url = svnResource.getStatus().getUrl().toString(); + } + + // get adds, deletes, updates and property updates. + GetStatusCommand command = new GetStatusCommand(svnResource); + command.run(iProgressMonitor); + LocalResourceStatus[] statuses = command.getStatuses(); + for (int j = 0; j < statuses.length; j++) { + if (statuses[j].isTextModified() || statuses[j].isAdded() || statuses[j].isDeleted() || statuses[j].getPropStatus().equals(SVNStatusKind.MODIFIED)) { + IResource currentResource = null; + currentResource = GetStatusCommand.getResource(statuses[j]); + if (currentResource != null) + modified.add(currentResource); + } + } } - return (IResource[]) shared.toArray(new IResource[shared.size()]); + // get unadded resources and add them to the list. + IResource[] unaddedResources = getUnaddedResources(resources, iProgressMonitor); + for (int i = 0; i < unaddedResources.length; i++) + modified.add(unaddedResources[i]); + return (IResource[]) modified.toArray(new IResource[modified.size()]); } - + /** - * Prompts the user for a release comment. - * @return the comment, or null to cancel - */ - protected String promptForComment(RepositoryManager manager, IResource[] resourcesToCommit) { - return manager.promptForComment(getShell(), resourcesToCommit); + * for an unadded resource, get url from parent. + */ + private String getParentUrl(ISVNLocalResource svnResource) throws SVNException { + ISVNLocalFolder parent = svnResource.getParent(); + while (parent != null) { + SVNUrl url = parent.getStatus().getUrl(); + if (url != null) return url.toString(); + parent = parent.getParent(); + } + return null; + } + + /** + * prompt commit of selected resources. + */ + protected boolean confirmCommit(IResource[] modifiedResources) { + CommitDialog dialog = new CommitDialog(getShell(), modifiedResources, url, unaddedResources); + boolean commit = (dialog.open() == CommitDialog.OK); + commitComment = dialog.getComment(); + resourcesToCommit = dialog.getSelectedResources(); + return commit; } - - /** - * Prompt to add all or some of the provided resources to version control. - * The value null is returned if the dialog is cancelled. - */ - private IResource[] promptForResourcesToBeAdded(RepositoryManager manager, IResource[] unadded) { - return manager.promptForResourcesToBeAdded(getShell(), unadded); - } + /** * @see org.tigris.subversion.subclipse.ui.actions.SVNAction#getErrorTitle() */ Index: C:/workspaces/eclipse3/base/ui/src/org/tigris/subversion/subclipse/ui/messages.properties =================================================================== --- C:/workspaces/eclipse3/base/ui/src/org/tigris/subversion/subclipse/ui/messages.properties (revision 1060) +++ C:/workspaces/eclipse3/base/ui/src/org/tigris/subversion/subclipse/ui/messages.properties (working copy) @@ -329,6 +329,17 @@ ReleaseCommentDialog.selectAll=&Select All ReleaseCommentDialog.title=Commit ReleaseCommentDialog.unaddedResources=Checked resources will be &added to SVN version control. +CommitDialog.title=Commit +CommitDialog.commitTo=Commit to: +CommitDialog.multiple=Multiple targets selected +CommitDialog.noChanges=No files were changed or added since the last commit. +CommitDialog.resources=Checked resources will be &committed to SVN version control. +CommitDialog.added=added +CommitDialog.unversioned=unversioned +CommitDialog.deleted=deleted +CommitDialog.modified=modified +CommitDialog.propertiesModified=properties modified +CommitDialog.deselectUnadded=Deselect Unversioned RemoteFileEditorInput.fullPathAndRevision={0} {1} RemoteFolderElement.nameAndTag={0} {1} RemoteRootAction.Projects_in_the_local_workspace_are_shared_with__2=Projects in the local workspace are shared with {0}. This location cannot be discarded until all local projects are disconnected from it. --=_mixed 006B36E485256F4D_Content-Type: application/octet-stream; name="commit.PNG" Content-Disposition: attachment; filename="commit.PNG" Content-Transfer-Encoding: base64 iVBORw0KGgoAAAANSUhEUgAAAhcAAAITCAIAAAA7KqkJAAAAAXNSR0IArs4c6QAAAARnQU1BAACx jwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAWg1JREFU eF7tvQucHUWd990hQiKr+6jRvES5CERHuagBVBTC1cAAyUy4DCQYICIRjJFswARFVFZEXY1rfFxX MMYFdxcxhhU1u8+6D+vzmhVe2cU3LNcBEwlJJpNJQkhIQq6Qp6qrL9XVl9OnT59zuvt851Of5Eyf 6rp86/Kr+ldP/4dtGuq3tJ83X71j2LDh4sL+vSPk5eHDnC8PGik/jxhuvWa4te8V8e+w4cP3v7Lf 2veqdcAB1gGW9aqbyj7xCz+VJCA7Bj8VJDBsTwUrRZX26wNWfH4lgGS3+k00/UHWnn3WQfYMvucA 66DXyGvWPhn22vP/gfst6zV25NdYe/dbu9dvWnxQICmhIioMm/ioCAddu33EDa+Munn/W78sw9G3 7+/61v5x8/eP+5v9H/6ODOO/J8Pp348NKgKhegQSGp2vSk2gen2VGkVO1OKimsO9f9WsHg5yzg8G oQUiCGk4aNY+6/THrHEPedpheRJywBVDQkIOmLV1xGdeFVE9ITnyr/aLILTk2AV+EKKign6RzxCA AAQgUBACYtJWQZVHfVZioLYHam73grio/6o2El5QoiDCiNmviGBN2Wad8piSD6ki1pn/aU1ebV38 7LAZG0Wwrn1BBaEow6/fMXz2HqEr1o2vDL9hvwjqs/jXu6g+qIsHzXlVbGVUTAIEIFAKAsNmvUqo HgHR90Sl1NStpmgVhs3cc8CM3cOv2z58xtZh03dYV71kXW7/+9GXxK/OlembLRWmbZL/im/7NlhT NsogrohwyRrr7Met8Ss0FbngD9blz/nhykHr6iGlKEJLVJCKEhPkt6JMXpixVZSPAAEIQAACBSLw 8U3DRfjYxmEf2yCMTyJYlw9aU9bJ0DfgBCEPKlz8vAyTV4kwbNIK63wR+q1zn5ZBfBAS8sH/sg75 mX2yfsJv5ddCRS5+1glKTmwh8bTE2aB88iXLC+6WRXwl9UbXLiVWhKoRGLKmESAAgfIQECJhBCUY IZFwdcJVC6ETKijZEJohgjgOGf+IE4SECO0Q4S132Soiwpn/KY7W41REWbp0Y5dSDnlFbFk+tsG6 ckgGMcWoEitxI0AAAhCAQLsIeLsKtc9Qv05efeBFqz7xncGBTXv31/nzia89d+Apj8gtyLiHpGoc 87+sdy6xVWTsPVEqslbfi3gq4imHJh6DMqYnd8bmyNsl8aECBLxOyYeKEVC2C0JVCXgWKnH+PVlK yJ7nV2z85o1Dn58+OKdv3cxJA5/oXvuxs9Z+/CNrrzpNhDXTThFh9aUnynDx+1ZNeteKCUc8evFJ L/Y/JoRESohSkaN+LeXjz79gCcOW/H38IwdMcPYiF5yyoK5g7j8qNsCoDgQqT6Cqsyf1kqca4skp cbwh9ENKiAhiB7LpW/Ne/PsFW+75m80/uH3jt+Zu+Nr1G/7yuqEvfWLolqvXf+6q9Z+7cv3cqYM3 XLru+skD1523dvrpq/pOePSco//lgvcNbNjj7EWO+32Eikjjlzgaufw5ISFd777u7YfPPPKtN3Yd /vljj7r1mENuOemwL53y9ltOeuuN73vrp4475Jqut3x07Fsued/RU0VkU0UqsOimCpEEKj+ZdmwF mW0rScBRDqUfropcIFVk6Esztvz0+1uX/GDzor/a9J2bN37zhg23f3roL69b/8UZQkiGPv+x9Tdd sf4zU9fNvmhg5sS1Hz/7+akffOz8dy0+8S3iXqkiIggVefvvtb2I2J6IYxNxkCKU6pI1QhgOPeza tx8655ADbz7EunXC6L+eduIPrzzxb857x9fGj/nsh8bMee8br37nn1161Osuevf/02eqCPMvBCAA AQgUgcCFA5p+rLYmrZHBVpH1n5ki9OPFu7/1wve+tPEbczbcNnPoC9es/+yVgzdOHZx9ybpPXzhw 3QUD150vbVzTT18z7cOrLj3psYnHLPnAIVJFPvCYDEpFxLmIY9EKqcjoI64ffcC8q87/4b8t/MOv b/vjv/zt4K1zfn7h2Qu6P/zVCSfcctpRn37/m6cf++d9x4+5DBXxn5ArQr+hDBCAAAQUgXgVGZx9 0abvfG7Td28RErLzkWVCGwZvmDr46YsHrpu09ppz1l515pqPfnjN1JPF9W3/+77VfeOeu/h9j/cc d9+HD4tRkbc+ILcnp4i9yAppPusbEMJw9Ie/OMy6/p/n/07c8/Lg/suv+ofzLrrj0ot+0Nfz/cnd 3zx//C2nv3vWuDdOOWF0jIrMeekJ7/T/oc1NnWf7HpJl7KPfQAACmQmI6YZQYQJqF6LtRcSJ+sav Xb/xG38hdiHeVG1LyLlrrzpDSMjqS0/yrq++6PjnLnrP45OiVMQ5XRcqIrYnZ9iPCQu7sK0ip5/+ V9PPXPiz6/7/fdv3z5n708uu/uHHp//jx6b8+MqLF13e871Lu79xwak3nXrUVR8aY5+LTF3vBPWA 1l+/LLJ/4h9/O/KQ2w4+5I7b+zfc3vu75gmJrSJPTTvkH4b3DcjPa146NvNY4kYIQAAClSHg6WJI RQZmnCNOQaQh64sz1t90pScYaz929torxq+Z8gFfQnq6Vk8+ZtWFxz0+6Zj7PnSo3Iuc3C8l492P ahYtXUVErraKvO51E6/4Hzc/86N9s+c8MG78LZ+8dvG10+/5+NS7r7r4h9Mmf//yiX998UdunXDC jNOPvkpEHn6F+APDIVdINi8W+Tz32ImH3Dbyg0/a4vHkgUd998AL3D+MbEILDT9OyJVQETvrFb89 8ailBzQhl+YJISlDAAIQaBYBMav7GxHnXESoyPqbp68XT2SJfz/z0cHrL/FkQ5yC+BIyaezqC45a Pekdqya/+4mJ7/6nD73NUZH398eoiDjEFzuJqeuFMNzyrT1fmL/763e+8rmvb7/pq1s+/1c7bv76 tpu/tvWzt79401deuOkrG266beCGL6749NynXRXZJN+vIjYlC3aKbJbMuO3go/7XAeK9K3qYs8Mz cy3+a/sreWXvrYt3qUI/sXjzsYudP4QRn9NEsDci4mdXX9/mW9d4dd+//6GtgayNkvArBCAAgQ4h 4O1ILhhUciImyjVXnCoewZIPYs27QpyIrJt98cCnerQJVH5ce2HX2t6j10x8+5pJRz3f+44nz3/H zz84xlcRtR0Rf3goT9fFObvYoZyzVhpG7fdtCWGYefodP/7qf//DP7587sQfXzb159dc+atrrvj5 x6fdd/VH751++Y+vuPSOqZO/PmnC5yaccpNSEXs7IoXk2CX79u/fcvvpt404235vlxc+IyXkiXv+ Q5i5Tpy/QSrNlzda9sX9/f/53pPvURef+uGqA07+G/vzhq9MfbZ2hCmb/3KFsmjdM3zKuiUytd+K bdDBIhz/+0AB9MLwORuBDhl1VBMCVSJw4UYrEAakikz94OCnL1x/w2XrxUNZcy5bd/1F8m8Prz3X E5KBy44buPidA5OPGph0+MCkI1b3HPnUeUf+/P2jpYqMX2F9+BlLbUfEM1qjvhlUEft9jUIYZt28 6oYvDNxxzys3fXnT7M/+ce6X1s/90rrPfHHNjV94/sZbVs655cnrP7vs2tn/Pn3GMqki07eKl0HK MGWzrSIv3H769w6ctFn86gX7+ravnH7byJNXWFO2/0yU5ZdLRly9U6jIU/PvOPjoXx+wYLe4dt8M O4Lz+XsHfqpWhElb7S2IUJGfDJ+yXVq0hIqI1LSs9WLwGQIQgEAHEegTVhk3uFoipsnVl5ww8MkL Bv/iksE5l67/iz7xyNa6WZOMvchg3zsHLzpyXc+h6yYdumbioU+dc+j9J75Jqsgpq61TVkkVOfop uReRKnKEeMHWCrkXEWcJrooc1/WJS8/5yn/+dN2tn156xJ+dP+W8b06buOCKid/4aM/tUybdfGH3 xyecdub7jzv/uEOvkCrysZfly4TFu4VF+J/SJHXfjL89cLKtK27o+724vGLaIer6y3K6/+WSgy9c p1Rk5Iefc2+8bcSEl/zP1+yuEWHC9lvXKhW5d7hKVqrI/z5Ay1ovBp8hAIEIAsJXBKHaBHwt2SKm yed7jxV/C7LuUz1CPwZnX7zu+gs9CRmcMV59fnXH1vWXHLl+8tsGJx2y9vxDnj5r9C/H/Q+pImeu t854XgrJe1ZIFXnL/7RVRPwuVWSDtEpd9ZIQhvMunn/YURcdN2ra/3f/Kx+78DsTTvr41HNvu/z8 v5xy/ucuOve67jMuPPmEy951xLTjj5quVEQF+930u5RCjOiW76n3wrH3vyKMVLef/tPXaHEOvnjw SaUip64e9j2xWZF7EXmj9/naPTUidO90VUSkbGctVGTsA8O1rPVi8LkRAs5CQS0XCBCAQIkIKI20 tURMk6sueMeaK8cPXNu9blbPuk9P9iXkurMGZ5y6/mr/Ga2hyWPWTxy99txR/ae/4RfHH+yoiBAS sSPxVUTsSqSKbJC2M+GKxFaR173ug5Z16IRTb/npHY/+3Rce+dxHf3Th6fMmn/7pnrM+ftYpU086 /rKjx1z6ttdPPuaIy0Vk4fBEhGHXyGBN333s/fKA/b65j4nP1vQ9YpZf/L3d1uf32Xpw74GXiAiv 7t+/87bTbzv44iFnq3HqgPU9ITNKRXb7n6/dVyNCt0zf3ossHm7nZavIbw6QWRMgAAEIdDCBabst LyjBk0KyXcyYz004fPWUD6y9+qyBa8/zJGTddRMGrz1z8JpT1l/9/g1XHu9dHzr/jes+8vqnT/mz Xxx7kFSRc1+UeqGERL4ZXuxFlIqI43thzrpK+roSwnDwwe896f3z5t2w0LI+cObxN335ql9d+IEv n/yuGe8ZO+2dh0059I0Xv+HAc99y0Fljx0ySKjLzVeE8SwRrxisiCC05/u82aya2l287744RF+we 9u0h7+LPvvj9gw/5/kE3Kmm5Y+RpA8PucFVExPQ+f7JWhAv23CrPiqSKvEbI2B3yT1Xkz8C+Y21V I0AAAjUJWNP3EapIQCmoaFz7g1KUqfKZ2D+dccjzF75HPNQrhGTHb/9ZXFk34+x1M85cd834watP Xj/9hKFpx2yYOlZc3/mvdw91//nAGa99+gMH3t91gKMiQkiEipy8Qb4HxbVorbYuEM9TSbeISkU+ dOqnzrjgq6973Qmve92ZR4yectioy8e84bK3vWHqmDdcOuaNF73tTRPf9qYJh40667gjJ0qL1vXS L6MIQk68MPzMO+SDUk5YctC0IflV7xLv4oheO/K03772kNtee6b/rXPdjik/14wwc+igd4qMlhyo cveyeOdvh2vl0cvGZwhAQCeg1n+EKhPwFgrT5HNMK099szBqPX/JuDUf/dDaK8evvWr82itPGbjy QwNXfnDdFScMfvS49Ze9Y+iSI4Q5S2xE1n/kz9aOP/CpEw/4+TuHSRWZuM3ZjggVEW/Pkiry1uVy Y2KriJAQcbxR12vhpYooF+vX+4EhCgEIQAACRSAQkEZbS+Tx8Qf//I9nH7py4rv+dNF7n+s7cdVl J63qG7fq0nHPX/qe1X3HrL34HWsnHzEwccxA96iBs1+/9rQRq04+4L/fay0+2nJURAmJUBHHohVU ESUkw6/bI8JBs/aNmP2KDDfY4TOvGuGgOa+K4KhIUEh0UeFzNQgUYUhQBghAoF4ChpAMvPDKH857 1yMnj3rktLct/8iRy899x/Jz37n8nLGPnnv0f59z5GMTDn9ywtuePGv0U2eMenL8nz/1odc++f7X /Pf7hi07xvrZqUdIFblwu7MdUSoin/TVVEQ8AqhURB2YSyGZudvUkhteUeIRJyH11pD4EIAABCDQ JAKmmW76vk/cuWPzU4/+80fedc+xr1/yvjf+bNybfnrCm3/6vjctOWHUfSeM+qdxb/jF+17/y/cc vPT4kb845qBfvGv40q5h/zTWWnLqERueWP6J726NUxFxum6fi9h/OSj+FX9IKIPclGx3tETIia0o Kgz/1N5wUBTUPoZQPQJVthpzKgCBqhJwTkTcZ9Wm7T7wyp2f+Ntt2gNQqT4ObNonJOTA3pcC5yLa XsRWEfGKFfFOX8fRvPwjdmu6PG8fPmOrE6SieEE+lGUE9YCWet6XUEUCPMlTVQIM2CoSEE9kCQmx n8tyHvO97GVryk4ZxIe+7XJXof5VH7xw4RZr4ouW+Fd9K05B1EGIEYIWrVX2w76rhPd16+zlwz7y qPDBLt2wC++Hdhg2aYUK0hmiEBvP/6Lvztf1yKi/gpjPEIBAKQicI/5ijFA5AmJKv2BNdMuevUJ6 AxFBvLhEhdOedX5V10VQV8S/4q1ZIojXLarXZ4kP4l8hGdEqcvZyqSK2kHhaohTFCCqCDF587Ub/ Wy8aH8pPQPQNQiUJOKNYDWFChQg0sbuqN6A4z2iNWT7ipGdHz9w8sm/lpqF+AgQgAAEIQCCZgNW9 1TrlWevIn1qj5lsWKoJ2QgACEIBAPQRQEbZcEIAABCCQnQAqkp0d+1wIQAACEEBFUBEIQAACEMhO ABXJzo41CAQgAAEIoCKoCAQgAAEIZCeAioTYLZvV1TXrQfWIgv65nocWopcnRmo5Jp5jUpmr2WAZ 4m5vMNnM1cn3xgy1yHBLvmUmNQikI1CPiizstryfngU57OO8cRI5YNo0ih6cO7Zr7lJVO/1z4/U1 U8uvgjLlnu4up3W6F0W2fX7ZReqrU7vMucTc2M6qGesJa+y8ZWrNsaDX6l4kvvXHg/g0dt7CwJXe hf4CxamFvjoxUgs3WRzJbMOw3napN3666abxQUQKBSSQVkXEMLDEyHH7yqKemKkqW2cqkoos6vEm i379c+ONZ6aW30B1Uk5OML/sIlUkVRkSukdM8VIl26yq2WrhrSe6xjrCoLILZxq/i7VrkZhaOhXJ PgzrRVRv/GwDn7sqQSCtiszr8udWfz71l2P2YJM9r7vXXqH1Llw6z/mQfF3YjpyY4i5vE7DJuGhk pPLyV3POos8eY/aPGuS+7LmLx65Z83qcKP6MEEjHH+rOklMriV0vlbX6sZlEzR2BkjgdxU1ZX8Oq xWlEglEYAzF1FddS9hI0a6pBFrsW51uZiF9UrTpRlLQqRzSZKkNMLmFE9pVALl4cudYOrvp102L4 xrhM86iaJ/xy2bSw2+mf6kOyioha+Pt1p4GSUkvsBi4QgTflMDT6eXCIRXXgYItHDsnsdvPGV2Ck UGQCaVVEm5G9ziTGhj2rquEqxow3s3sTgfjgTOh27w9f12Y95yjCE2d/lIYyilQRTTbUVmlRj1M8 ma9TPO2KP4NrI1Mf/IGJwC68vEWTmfCa1LviCpi/aXNS8+viTkNRCapp1MAlsw4CV6y8cnrE7GnC kUmn2Jra6d/qS6FYSqES6tN6mjJEqohRwhC6IlTNNUIunddjN73dZ5x+pa8G/IWLZ+SK6FRJqUX2 K1dN5fgyF0bJwzC+9aMzSoiPeECgBoHUKuKZdCNmebWati3FhioY86wRIRxfn9Qivw3sMIy6yUlW N7t502uEVSS8kLSz9oUn+NkXSGPu0Gvtz62hkuhTj3F0n5BgHC5HRJ3tiF/mOGKRjaK3ozf1GYYa f2bXTwC8faf7DILOKrkMHqIYXQk0X/pk4zqSzjZb1UQKav0hNxZiha72WxEETCufVsFAAyWkFjhl 0UaT19yRndYgGd0hzTWEllUoo4SFXSXML0Ve1Je0bGlVpDdkPjItOe1XEe/k09MSNeCdJWSk6SnY bLrFwPjsLtbCIzk8IfomLL0kMeavhARTqYhWzgwqIudZd9VsSH7kjB+5hpATazARY7MSqRlhNe2a tUhtap1cUicbu+BovGr2Pmxht7vn7pbHG3HzbKApvQ2c3pGypuYsnsTtIYtWBhUxVoSRHThmmVXS aY5iN5VAWhWJOtaLsmhl3otoR/dOhf1tR1qLVq/zbJU/bkWxe8UxgLoeN1qMaVRNYVpkx16naYP+ +I2zD7O/9SwPZkn81PyJwIms2an8ikfvHmI4hJ9Ljq1paBFtVDNywR4uYXAzFLGeCNPWjqkd40yU iih7UY32iqyvSj9G0X2LkHmvZmAMbM70B0nGdnkaKU5EutxH+JLXE2FDorPZjUktoRt4FmPnpMd4 yCV+GOpAokaT2d+i42PPgUBOFi1nijSe9PUtBsExHLeIjl9ci7kjeLru2Jeci0ZGkeci9jh0Dtfd R3X1Kb6misQ84+sn69hb/MLYx/jaKa583NY5OwmUJPCMr/ukphtZP113nwuIs0GFOPgp61/FTKYO ZKeQTs9QFyVndT1WgTy4jiHLazLjCebIXLwz/NhcAkIrhaQIVfNXBt7awjvO0buBetQi8KSv9nCX 1xu9dUY4NadLa5BD3UxN+trTEJazb4sbhkFZ9YeYkXJyb9EK39T1LImXl4C5F3ltB/sXiT0Uadgc rKecb19pXsrpy9mkMjQp2fT1yiVmNWqRCwoSqSoBqSLCQ+Jhdzn+RTpYRcLP+Oa1k9VTzitN7c/f Gha5xjp3k2rXpGTz5V8ztWrUomY1idDRBFCRjm7+xvQDdBCAAAT6URE6AQQgAAEIZCeAimRnx0Ie AhCAAARQEVQEAhCAAASyE0BFsrNjDQIBCEAAAqgIKgIBCEAAAtkJoCLZ2bEGgQAEIAABVAQVgQAE IACB7ARQkezsWINAAAIQgAAqgopAAAIQgEB2AqhIdnasQSAAAQhAABVBRSAAAQhAIDuBJqhIXf5t 6orc5tcOZqfMagUCEIBAVQlkVBHh1lv7CfpfU8JguBIxBCD525apRUGKodcXWW1Z65MRBCCQBwFT RUaOe2b0zM0j+1Ymy6bjXz2yBMY8GDktFm36Ls7cXZyS5NG9qrr4ol4QgIBHID8ViXagJpzXhvwP SjfdAf9681x3e44nWj+pkJdpzaGhjBzh5a271068d6GTixOtK+668NwXWUhhv/K9HOaQV8CZne+D PVj3YElk7cIEMKxBAAIQKBCBrCqiG7RcH7G+BtRl0fJckDquqjXHPubCXE6yms/zKI/TatqVXmnd D6owcdcN37T+AjzvvKQmuR6zPaOfWfeQ53BUhC0RBCBQbAJZVURNvl4Iu27OcC6iza2aSLkzb9CJ tMzayFTM0eFM4w5pah7eJNjlpCZlyitwmKSloNcFi1axBwx2DAhAwCBQSBUxJCpSq8qoIjWlN6yU TKkQgAAEik0gJxWR5hrHgv/g3LGWYdHyLDm6HqiL4U2MfRqhma10818KK5NhoUq/FzELmXde4XpF 1F2d9GiGLyxaxR4/LEshAIGsKhJ+0lceRcifrp7uwJO+Q/2L7MPzrrlLddzORRVZzRS6PcpLP7x+ d7+KOfG2UzNMWzUtXZGF1J4XyCGvwOm6wKE9DB1UUx8Xp+tICAQgUHgCGVUE+YUABCAAAQgIAqhI 7ANzge2WZdFdIAABCEAgTAAVKdBj13RQCEAAAqUjgIqgIhCAAAQgkJ0AKpKdXemWDBQYAhCAQO4E UBFUBAIQgAAEshNARbKzy13SSRACEIBA6QhkVJEl995JgAAEIACByhPYv39/srBlV5E5s68hQAAC EIBAhQlsfXF13SoyYlx/Gv8iQn4FOJE6PxCAAAQgUAoCm18Y2LdvT/qibto0UIeKHH6XNWq+ZY1Z joqkR0xMCEAAAiUiIFRElHbnzu1bt27cvHlQiMTGjWs2bFi9fv1zIgwO/kmEdetWrl37zLZtm0XM gYE/oiIlal+KCgEIQKC5BJSKCAnZuXPbjh1bhVS89NILW7dussPGLVs2vPjikK0ua4WWiJjPPfcY KtLcJpGpP3Hrscfe+kSGfBb3qTes9C0O3Zw5zQzFaO8tyTXtHA7tbQVy7xgCSkWETggJ2b59iysh jn4oCXnhhXWeivT3P9xCFTEGfIPjv8HbW9knMhZVaEhIfLykMqbZymrXyitlXVS0uPpWgEMtTnwP gVYSUCoiDFnuLkTqhwq2eAy4Ya0wbYmYjz++rLQq0kquDeaVbaYTd4U3ISln3gYL3OLbG9ltZGPb 4gqSHQTKQ0CpiDgI0a1YQkIefniZrR9rvaBUZPny3xRAReR0qX7spbc9L9wqbTm2Icf41msMd/pI +N594a6RbJSNyExF2pKcjYD8Sn70o/jl7Ouzi9632PlSllgWzLnu1EGf+vWa6h3LT12Zr1xjlkvF jquVUuTgUNKqk8jKRhofOVBIVQZxybCl+aVyaqonqVU8DkjoeoBrYOel4Za8w82t9RZpLTQB6le8 tizPUKakEGgTAU1FNqqDECUhKggJEYft6l+lIn/4wwOtVRHjRepy2hATkztVebYL/yQg9K2hItqC fXFfxPGBMyGLb+xZxolh2oqicnFSjlrrquiuutgTvj0BqmS9644W2DNnZE39XiKT8GZu/1P4NCUo SMHqJLIy6x6O7FyR0iF+pIws7gvN6xriUJlrAgmDUulHMPYTd74Nx/FawWFrAAyl0KYxSbYQKBcB pSLicSwhHkJFRPAkRH0Q+qGCUpFHHvm31qqIPitpmqGJizfnGovv0DGzPzVHHz/rewd9Messso2S BOTNmSrV6taPGLM69idBr0b+PbawLHYt+1G5mOXxdDFKv8y8VPeMI2kobq3ISjSkGKtNiLEVMcqj /6rKrCucLg/prycX2EvTw+jtURIKE61S5RrXlBYCrSOgVEQohLELEYcinpyoZ3/VM1rFUBFjxW3M CHFPNwUmNWVp0RbK+oYgPLknTIh6Y9mpGnatwKxtLKVrqkiaujSiIinTjzmstlVDSYnzMbC5K4KK xDVrWEX07WakHrduVJITBMpEQKmIUAjxOJYnG+7TvQPeFVtFVtgq8ut270Vse1D8bBX61liuPnFr n/MMbXCq0H5zZp4kcYrMRVlM3NkoIUFjra1n5Nm4glaXUJ+qx6LlHRd5muHkWIuVvhcJY7fX7OKw xVVGadYKPp7s6ZtKKMqilSyrcaCMhJ3Eg/IdUuhgs4YBajKCipRpEqOsbSbgqsgK8USvEhIlIepv RIR4iCvi36GhVcVRkdApaHjNq1swTKOHf95rLMS9L+RRt7H6Dk8rck7SD+O1Gdn9GJtgeHL0LVfu AwKR1hi9t/gFCJ4SRQqO2CGpSgWEIf48OVJBzSorYXAT1dfyOnO3ajGn68FzDmPqj5dbxTbQgi5u o/mSWiH49ID+gEL4kek2j1Syh0BRCSgVEX+RLkxYSjxUUH8jomxZQkLEwYmI0/K9SFGp5VwuVr45 A204Oe1JgobTIgEIVJyApyJCM4RyeEG9CsVTEXFwIl6Cgoo0pzegIs3hWm+q/i416m//602N+BDo EAJKRVavflrsOdRDvWoLou9C1Ku01qzpt1Wklc9odUgjUE0IQAACpSWgVES8+EQYrMTJhxtWep/F dRGEhIiHgEXMxx77bQtP10uLlYJDAAIQ6BACQkXERiRlZZ999g+8GT4lK6JBAAIQ6AgCQkXEG7Se fvr3wlT18MP/8uCDv/jd734eCvc/9NCvHn30/4g3NqIiHdEtqCQEIACBlASkimzdtF2EbZt3bH/x 5R1bxCvid+/avnv3zr17d+3du1uEV17Z8+qre1UQ8bFopWRLNAhAAALVJ4CKVL+NqSEEIACB5hFA RZrHlpQhAAEIVJ8AKlL9NqaGEIAABJpHABVpHltShgAEIFB9AqhI9duYGkIAAhBoHgFUpHlsSRkC EIBA9QmgItVvY2oIAQhAoHkEUJHmsSVlCEAAAtUngIpUv42pIQQgAIHmEUBFmseWlCEAAQhUnwAq Uv02poYQgAAEmkcAFWkeW1KGAAQgUH0CqEj125gaQgACEGgegRapyMhx/aNnbh7Zt3LTUH9CWHLv nXNmX9O82pIyBCAAAQjkS6CJKnLaCuuwu61R8y1rzHJUJN9mIzUIQAACBSGAihSkISgGBCAAgVIS QEVK2WwUGgIQgEBBCKAiBWkIigEBCECglARQkVI2G4WGAAQgUBACqEhBGoJiQAACECglAVSklM1G oSEAAQgUhAAqUpCGoBgQgAAESkkAFSlls1FoCEAAAgUhgIoUpCEoBgQgAIFSEkBFStlsFBoCEIBA QQigIgVpCIoBAQhAoJQEUJFSNhuFhgAEIFAQAqhIQRqCYkAAAhAoJQFUpJTNRqEhAAEIFIRAi1Rk BP5FCtLgFAMCEIBArgSaqCLjV1qHu/5FUJFcW43EIAABCBSFACpSlJagHBCAAATKSAAVKWOrUWYI QAACRSGAihSlJSgHBCAAgTISQEXK2GqUGQIQgEBRCKAiRWkJygEBCECgjARQkTK2GmWGAAQgUBQC qEhRWoJyQAACECgjAVSkjK1GmSEAAQgUhQAqUpSWoBwQgAAEykgAFSljq1FmCEAAAkUhgIoUpSUo BwQgAIEyEkBFythqlBkCEIBAUQigIkVpCcoBAQhAoIwEUJEythplhgAEIFAUAi1SkZH4FylKi1MO CEAAAnkSaKaKrLAOu8saNd+yxixHRfJsNNKCAAQgUBgCqEhhmoKCQAACECghAVSkhI1GkSEAAQgU hgAqUpimoCAQgAAESkgAFSlho1FkCEAAAoUhgIoUpikoCAQgAIESEkBFSthoFBkCEIBAYQigIoVp CgoCAQhAoIQEUJESNhpFhgAEIFAYAqhIYZqCgkAAAhAoIQFUpISNRpEhAAEIFIYAKlKYpqAgEIAA BEpIABUpYaNRZAhAAAKFIYCKFKYpKAgEIACBEhJARUrYaBQZAhCAQGEItExFnhk9c/PIvpWbhvoT wpJ775wz+5rCwKEgEIAABCBQg0BzVeRw378IKkJfhAAEIFBBAqhIBRuVKkEAAhBoGQFUpGWoyQgC EIBABQmgIhVsVKoEAQhAoGUEUJGWoSYjCEAAAhUkgIpUsFGpEgQgAIGWEUBFWoaajCAAAQhUkAAq UsFGpUoQgAAEWkYAFWkZajKCAAQgUEECqEgFG5UqQQACEGgZAVSkZajJCAIQgEAFCaAiFWxUqgQB CECgZQRQkZahJiMIQAACFSSAilSwUakSBCAAgZYRQEVahpqMIAABCFSQQItUZMQJvBm+gr2HKkEA AhBopoqstDz/IqgIXQ0CEIBAJQmgIpVsVioFAQhAoEUEUJEWgSYbCEAAApUkgIpUslmpFAQgAIEW EUBFWgSabCAAAQhUkgAqUslmpVIQgAAEWkQAFWkRaLKBAAQgUEkCqEglm5VKQQACEGgRAVSkRaDJ BgIQgEAlCaAilWxWKgUBCECgRQRQkRaBJhsIQAAClSSAilSyWakUBCAAgRYRQEVaBJpsIAABCFSS ACpSyWalUhCAAARaRAAVaRFosoEABCBQSQItUpGR4/pHz9w8sm/lpqH+hLDk3jvnzL6mkqCpFAQg AIFKEmimiqzw/YugIpXsPVQKAhCAACpCH4AABCAAgewEUJHs7LgTAhCAAARQEfoABCAAAQhkJ4CK ZGfHnRCAAAQggIrQByAAAQhAIDsBVCQ7O+6EAAQgAAFUhD4AAQhAAALZCaAi2dlxJwQgAAEIoCL0 AQhAAAIQyE4AFcnOjjshAAEIQAAVoQ9AAAIQgEB2AqhIdnbcCQEIQAACqAh9AAIQgAAEshNARbKz 404IQAACEGiRiow44Rn8i9DbIAABCFSPACpSvTalRhCAAARaRwAVaR1rcoIABCBQPQKoSPXalBpB AAIQaB0BVKR1rMkJAhCAQPUIoCLVa1NqBAEIQKB1BFCR1rEmJwhAAALVI4CKVK9NqREEIACB1hFA RVrHmpwgAAEIVI+AUJF9+/akr9emTQNbX1wt4m8a6k8IVvdWa/wK6/C7rFHzLWvMcv7qMD1iYkIA AhAoEQGhIqK0O3du37p14+bNg0IkNm5cs2HD6vXrnxNhcPBPIqxbt3Lt2me2bdssYg4M/BEVKVH7 UlQIQAACzSWgVERIyM6d23bs2Cqk4qWXXti6dZMdNm7ZsuHFF4dsdVkrtETEfO65x1CR5jYJqUMA AhAoEQGlIkInhIRs377FlRBHP5SEvPDCOk9F+vsfRkVK1L4UFQIQgEBzCSgVEYYsdxci9UMFWzwG 3LBWmLZEzMcfX4aKNLdJSB0CEIBAiQgoFREHIboVS6mIrR9rvaBUZPny36AiJWpfigoBCECguQQ0 FdkoDkIefniZISHiihASceSuVOQPf3gAFWluk5A6BCAAgRIRUCoiHscS4iEEQwVhyxJBKId3xVOR Rx75tywqMnJcP/5FStQtKCoEIACBlASUioh9htqC6EKiS4gwealntOpQkdPE34vc7fy9CCqSsj2I BgEIQKBcBJSKCIUQj2Op4ImH+iB2IeovSNatW2GryK/T7kVQkXJ1BUoLAQhAIAMBV0VWiCd6w0Ii xEOFoaFVqEgGvNwCAQhAoOIElIqIv0gXByFCSLzgHaorCREHJyIOe5GK9waqBwEIQKBeAp6KiAex 1KG6CupVKMqWJVREHJyIl6CgIvXiJT4EIACBihNQKrJ69dNCLYRmqL8O0fVDvU1LHJysWdNvq0jq Z7Q4F6l436F6EIAABMS7T2wVES8+EQYrcfLhhpXeZ3FdBCEh4q9JRMzHHvstp+t0HAhAAAIQcAgI FREbkZQ4nn32D3W8GZ69SEqsRIMABCBQXgLSS9W2zU8//Xthqnr44X958MFf/O53Pw+F+x966FeP Pvp/xBsbW6EiokwECEAAAhAoBYFkZ1OR3zbdolWX2ywh4PJdkls3ESAAAQhAoEECGabfIqqIEIY4 t1lxnrO2b91EgAAEIACBBglkmH4LqiJxbrPiPGdt37aZAAEIQAACDRIQKlLv9FtQFYl0myX+ElL9 eX3Yc9aO7S8SIAABCECgQQJCRcLTr3rZe9z0W1AVCbvN8l7vFek56+UdWwgQgAAEINAgAeek2fGd Lr0W6u/ojZx+C6oihtusoIREeM4SXuMJEIAABCDQIAGhImGvhdoMHDH9tkxFnqnLv4hdDek2S1dC z+2i+iN73XPW7l3bCRCAAAQg0CABV0Wc6dfzWqh7CjGm34KqiHKbpZwvGp6z1OtZVFD+F8Wfuuze vZMAAQhAAAINEhAzqjf9qqW893ZFXUj06begKhLp8MQzyYV9nuzdu4sAAQhAAAINEhAqok+/3om6 ISG6y6nCqki0wxOxk4r0ebJ3724CBCAAAQg0SMBWkcD0Kx7Z8iQkcvotqIpEOjzxnC+GfZ40CI7b IQABCEBAEBAqYky/+tG65yxEdzlVXBUJOzzR/fcaPk9eeWUPAQIQgAAEGiSgVMSYfm2vhbEupwqq IpEOT3QZNHyevPrqXgIEIAABCDRIQKhIvdNvQVUkweGJsNmFfZ40CI7bIQABCEBAEEj2NxU5/RZR RdI7PBEVVj5PaH4IQAACEGicQIbpt4gqksLhiXCBEvB5Uoq38FNICEAAAgUnkGH6LZyKCO8lBAhA AAIQqDYB+cKuof6EYHVvtYIec1O9AaW8PiMpOQQgAAEI1EWgKSqSYWfELRCAAAQgUD0CGfci1QNB jSAAAQhAIAMBVCTJ3pcBKLdAAAIQ6CgCqAgqAgEIQAAC2QmgItnZddRyg8pCAAIQiCSAiqAiEIAA BCCQnQAqkp0dCxMIQAACEMhPRZbN6uqa9WDiH6dUEHehal2ownRaT6C+EOhUAg2oyMJuy/vpWbCp 1FNY5sJnvtHocLmkk0sijY+EghSj8YqQAgQgkIJARhV5cO5Yy+pe5GawqKd7UWfOHXnVOpd0ckkk RaepsacsSDEarwgpQAACKQhkVJF5XWPnLQueKNhzx7weZ3vSu9D+Vlx0LriSE7piC5L9owxifgQz Cz+mFfxKZt3d6+Yks/YLY+drpCl/9SRwQa/47E18RvH0CdH9HCiwc3HpvC7LqfKQSDBUPKeG9vUI UPJ2h8HcpRGldcBG1SVQO5eh3/CiMFqLRNTO4da70CmDSy/qeiRJs9HDdQl1lRT9soLGT2oNgYoS yKgi2izsaok9QzkzqTB2SUmQU5i6ImdeYfUKX9EmdLmhkRE0vYk7aBHpy9T0rN2pStrZbFXwChOV 5qIerai+OS5U4LCKGAX2InhFMsoWzj0ClCMt9qlSiECNuvhlDhkVdW1TKQebQ6Zsc5PQ3A+Cedz1 uuui9BsV4QkOCFSZQFYVCc/vkROuF01NvkYcKRhqsRzeqagVtG80C+5sgovugAnF3gos1I76/QW4 lqY71y/q8fcHcvZMLrArjYECO7c4s7+vT0rkwrlH7W98AagZ3z+MsvlEpuZlrTdTQu30rZhSEW9f qH+oWTbjroquvNgnQQACOoGMKmIabdR0qU/B+mTkTKaRKqIk2tWSgB6ELGbeqtaIVlNFIvY0Yp1u a5gxS9ZWkdgC2/qh7SQip/JIUPrFMIEEnYhLrXkqYpBMVkRUBAIQ6AACGVWkxum6M7mksmj1ipMA CVpM62JboNlnDPrahCVzj1tlK2OaqSveoYWvTCKR3p7uLpV7XIE1+5WT6bJZgQKHNj1OgsGTCffI xN2dGHLrqawrqLHxNauUuxbwj2FMLBKpXvF4e13KvUg49zgVCWwusWhV2ZrBqhwCGVXEOeqIe9JX n5VqnK77x7/+hO4lG1z5isW+cwQtZn9DRXw7j3sEHRfB2G0Yy3bfaOMY07yz9C4n02CBA3KlhDA0 ZeiGoPAWzS2Pqp2EkBA/8izdfeTaLaFWAC0p59hcb44Ey1WkRSuce8w+KVgXVAQVgUCVCWRXkQIp cIIdrJXbSeeZgip3lwI1eitblrwgAIF4AhVRkcCRs/1L6+c781ydbgcBCECgAwhUQkU6oJ1aL4rk CAEIQCANAVQEAxQEIAABCGQngIpkZ5dGpYkDAQhAoNoEUBFUBAIQgAAEshNARbKzq/b6gtpBAAIQ SEMgo4osufdOAgQgAAEIVJ7A/v37k7Uku4rMmX0NAQIQgAAEKkxg64urm6siInV+IAABCECgFASE JNQVhDqiIqVoWQoJAQhAoBUElCSk/BGWOlQkJSuiQQACEOgIAmk2Ft4RCCrSEX2CSkIAAhBITwAV Sc+KmBCAAAQgYBJARegTEIAABCCQnQAqkp0dd0IAAhCAACpCH4AABCAAgewEDBUJO9TQfWpwup4d NHdCAAIQqCSB8F7EEBL9b9RRkUr2ASoFAQhAIDuBSIuWJyTGa05QkeyguRMCEIBAJQnEnYtEOodF RSrZB6gUBCAAgewEOF3Pzo47IQABCEAAFaEPQAACEIBAdgKoSHZ23AkBCEAAAqgIfQACEIAABLIT ECpSl08t3umbnTV3QgACEKgegQzetNJsX7L7OqzL2wmRIQABCECgjASEmjbFY271VJoaQQACEIBA JIGmqEhyonwLAQhAAAIdQiCjRatD6FBNCEAAAhBgL9JPJ4AABCAAgSYRYC+CxkAAAhCAQHYCqEh2 dk0SdpKFAAQgUCICqAgqAgEIQAAC2QmgItnZlWixQFEhAAEINIkAKoKKQAACEIBAdgKoSHZ2TRJ2 koUABCBQIgKoCCoCAQhAAALZCaAi2dmVaLFAUSEAAQg0iQAqgopAAAIQgEB2Ag2oyLJZXV2zHhyq J++6bqkrcl3FaFlkVQWjIuWtV3lL3rIWT5MRGNNQIk55CNSjIgu7Le+nZ8GmDIOhrlvqilw04rp+ FEpFvMLopUqJOhwt/Y1uz+mauzTYc5bO6xo7b+GsLsuSX6l2TJlsykbPN7WETFNmlDJaytoRDQLt JpBWRR6cO9ayuhe5xV3U070ow2Co65a6IrebY7TBsch7kdapyIJea+y8ZWrPuqBXrD+GbOVQV3xE 3b3GxWK2KSpSunahwE0mkFZF/GHvFcge//N6nEVm70J3UnAuaBOHuw7tnesaweS2xo4gEjHi+1fE 6lSzmPnZ2WIWutHWOftH3eVHcON7qWmTu11+pY5istPqUjN9Y9Us46t0xBTpSmysiogZU+WlTaYm N89UGFcwr15Oar0LRdYyFdkWMuu464KPE1PSmrtA3WV/tjcKKVskkIh+o7/acJRDW38ouRWN5ew8 Fnb7uxPRK6TGhPYiPlvVTFEdINg9Ap1B3345VfO7hNmB/fFWE7vR+TWkPd3u0DCKGuqKTR7eTTpN JVkI6ATSqog7RWqnIPZ044iHGP9yjnZHuD8RyKHlxNEXnv7E7c44zlCXQ9cXJENFvK/CGWkTjdwn 2ZKg0pETimF/8yZ3P8FgOWunr0/xsgoil96ebjvHBb3eWUicirjiIcsWzc1LP1ywUL1Uap4wq7aQ QGKueypryKojpalbJDDdh4Br8+MitdRQCqGCKxjiK1fzpPYbv3rxnev+jaGepvdGozOEupbfJcwO XBd2o/Nr4qcXJrkroiIQKD+B1CoSPkgPm0T0bYScNkJWLyeCNk+5y3/7/2B8w6JlZGfc6OwkjBnQ 2x5FpZxg0glXxEg/MEXKydox8Sm58kQrdi/i7rHUfBeRnTud1YCg1UtfcetH+jWv62KQ3IJGYYwb dU0KbT4c5fC1RMmAvW8LpxPOyFcdYwur+oHR09Q2ItgZzP6TurMZeyOvycIabKA2dqvO/jiTKbj8 Ew2L9woTSKsimmk7aoKLnC4jTRNdsxapzUH42/BwDVm0nEfCwrOMM8zc6SPNlJGsItGPnwWnJ9c4 07vQ3n+oOXGhvSPRgaRXgvBkkf7emmphtFFk9RN0Irm9wsCjJz5/D7Goxz5UD/UEuavzLJ9+Ikpv FOeo4/eILhHsDGm6hJddeuyRUhrXtcIKhDxAoPwE0qpIjdN1Z9ho9igHTZRFyzZc2GbxcHz/JNa1 9kSuykM3LpvV6zzho05uoyxa7uLUSTkwU8QajrynhoLpByx74lhYWfkfnNst7FrOeY9h14qaoRzT SgSHekwrxsQapxbh6/pqXTsc8i2QsszxLeItrp1oQVObXl/PlqUztx/5i7Je2rN/SMWVzdB9jiui A/jPnRudQWiVYzasZeQMiJZmiU1jINVpBLpWvHFViUr5J5EKr7KpWhoCaVXEOWDw7EiRJw3OQHIj mafclrbGlEMreJbrThzu88Rd9hGl//co4eWhVxh3jvCPiAMlcQaqd+LqpByfoLOZSE7fH/zaM0jO +VCtvUggZeOphNAEqlmZggWLsgV5S+OwdSW0X1THFWpe9j9r2TlTeVyL2ASibjRmRv/Y2X+awBGe KAuk+MrDqM+wxpxrlDM0cfudQUcROl2P3d2mxB7cGDk0wl03Ml9UBAWtBIE6VCSNKBEHAhCAAAQ6 igAqUs/f3rdj4RB4jMCyOqp3UlkIQKD4BFCRoqtI8fsQJYQABDqZACqCikAAAhCAQHYCqEh2dp28 +qDuEIAABBQBW0VWWofdbY2ab1ljlo8c98zomZtH9q0EEAQgAAEIQKAmAVSEvQgEIAABCGQnkFZF 9mf9mTP7mqy3ch8EIFBlAkwOZWxd0WrG7qQOFdn64up6w5J771Qdpd4biQ8BCFSbAJNDGdtXtVpD KlLTQGZE0DtKvfcSHwIQqDABJocyNi4qkt3wV8b2pswQKDIBVKTIrRNXNlQEFYEABIpCABVBRVL1 xeiOor9Hz/elmirBMnKnzBCAQJhArIpo84PzCueI1/4HXqodeG1rO15T1DntW5i9SFpfFOgKBCBQ WQIxKqK9IVu8kD/OEZHxsudob0CVRddG0Sqkihi+aZ1XDzreyJvtSr2NjUHWEOhwAvEqEutZQGxN /DnBMWOY7u6NV/2bcwg7lcYIFFJFfE8SkZ60nf7UFFfqjdHs8CmA6kOgQQJxFi3lo8Vxh6oGaaRF y3Wi7H8bdjGpeXCx5xB2J40SKJKKJLtpcpxmR3nP9npVpJP2OE+lhvss3Sk3HQsCEGgHgRqn68o3 WtiiFfaiFnbI5gtPhIvrBsWvw28vkor4bhBjvN0FPAmK3tS9KHyaErn08CykYVeGGE/bMVl0+Kij +snPjKo/SY6J49onAt4qHXN3xBYkdhGJljS6BfEaqHgqonyjxnn8brYrdaZUCECgfQRiH+BU+w/d kOUZpjSdkAcexmJUs18535pzSG6TaccuDgqpIkP99vGXvb4w96pqBeH7Btci5OJKnS4FAQi0jUCM Rcs/LXemBVtRHIf2c5c6pyaW1aU5t/e+9c7S3W9Dc0j7VLMawlMYFaEhIQCBjifAXx2WUVdiVWT8 CuvwWv5FEs2XscsZOkoZOwplhkALCDA5tABy7lk0qiLi/gxBvdM3w43cAgEIVJsAk0MZ2zf6nb5p 9iLiTgIEIAABCEDA2OJI/yJpVKQRbyoiy0Zu514IQKCqBJgcytiyGVUkd/saCUIAAhCAQAUIsBcp 41KAMkOgIgTYi5SxITPuRRqpqtdRli4YHxkaSZx7IQCB8hJARcrYdo2qiPcGrOQPOhpdRXbv2WeE J375SSEtZURJmSEAgQYJoCINAmzL7e1Ukfu/fdrO3Xt37d63a/de98O+Z//9licRkrb0BTKFQLsJ oCLtboEs+eejIgk5qz1K5F5kyfwzduza+4Ml//Xdex6a/3fLvvqD37y8a++q339bCMkTv7xOfFuj Qk/ceuyxtz6RpdbuPYv7VPH6FjeSSk73Nl6dnApCMhBoF4F8VCQ8lNKPdIZh/W3fRBVR4pGgIj/5 xlkv7di77eW9L70s/91mf/bCT755VnJ1/OZ2u0idgiBus1Uox37jJVV/ms4ddd0YFzk5kbqyqL9L cQcEMhPIU0UCE0Tqkc7oqL/xmqUinngkqMiPv372lh17lzzw5L3/+viPf7Vc35Rs2b5XfJtcncV9 smeIRtf3Eov7Uu8r5J2pI6ck20AXVNWpT9JQkZTtQrSSEMhTRbwq1zXSGxjCJWGcfzFzUxHdbOWd tCfvRRbdPuGFl/aIsNn+1wji28Tqip2E0ICYNre1xTdW2bFudcxXSjr0/Yul9iRKkZwfcUVPW332 05FpaNHN+4/t63OsbbVLomrpVcfPX8vAsdz5iXkCakcPGvb0WLLS2s2qDloW+fcoUoRAdgKmisgR J8aSsjI4XddZ+hkjK3b8Jo90d+gYYz97DTrxzjxVRDdheaKSsBf5/pfP2bBld+ReRFwX3yY1iD/r hvcTst+oq84qRN+wuHYsX4ActfDvcr6KVJHIQxRVGJWfJyjyQ7qSeCKip+Dois3A0zB38+RsudLs RXwE2oBp8DypE0cKdW4FgQgVUasgOZLcD5EjSxtr5viNGJXupBE39ltR1+rkkbOK6LsQBSlBRb7z pe51m3cPhoK6KL5NwOzM25HTqDH7q0WMN2+aXUqbo404MXsR/zw/vH4xEk9ZEncnYuqQR9M58FGr Kk0106iIu2fyhSPurur0ampSVgJRexHXTqCvz9KMrISRboysyPmhrAjbUO4aKjJi3DOjZ24e2bfS iOeVVBeJsIQkq8j8L5y/dlP0XkRc/9YXzo/n4TW7t7PQ4qbpYeF9g56St/ZP1hXPkpRSmeL0TLfL hZMyKWhakk5FlPUOFWnD8CLLOgm0SEWMvTgqUmczGdHzVBGlGUYGCXuRr9088fkNu+KC+Da2alqr 68YqEd829UTZkWruReRdQZuPYwtydgjyy5jeJiP6JyP2XiG0Uw4blkLmL7u6fqaahU2BeOLWPufB ZrccWgm1G/VEbCRy+xKsXe6PFTTWC7kbAopAWhUJj3GthzvjMW5tp9u+HO7+6PDHMk2SmkDOKhLO N0FFbrtp0nNDu4yns55bv/NPMuwS38bVwliC64Yl7TzEPF13LFGxfSt44u4+MKVScU7Lgxl7x3b+ WbqbRvLpulESozoq2eDxufrdPyf0NDEY2Td2udfl6bpzVVMl/67UHYWIEGgBgdQqoj/c4nZ7d3yY ozVyyHuWEzWWjHtbUNUKZZGPigTMjFG/6MS8jvLFuT0rBneKsDL4r/r1S5/piePsHWY3qyGankGg 4K3NrVnMSBcCjRPI50nfxstBCvUQaKeKfP7GyZ//jAi9N9/Yqz64n3vlVzf2xlSkWbOuv9RvqcGn WdWppxsQFwKFIICKFKIZ6ixEoypSZ3YyOh0lAzRugUAnEGByKGMrZ1QR4zZ+hQAEIAABCAgCppeq mk/6ZlBOlhsZoHELBDqBAJNDGVs5416kkap6HQUvVY1g5F4IVI8AKlLGNm1URWo+nZXwpK9QEbxU lbHTUGYINIkAKtIksE1Ntp0qgpeqpjYtiUOgdARQkdI1mXpgSg91n4uEtxoGhYS9CF6qAqx4vVUZ BxBlzpVAkoqkfN9PhvIw9DJA025pooror/jVC+l1FLxU6VicnlxXhzbfGObYFyPe2JucbF2ZNtbh uBsCCQRyVpGUHTtlNFouhkCzVMTbgiTsRfBSpTdKo16qfP9ctd5QGe4KjCImiGIQQEWK0Q71lSI3 FdHfw6i/3DdBRfBSpb3kXf0Fu/9KsEg3VDW+dpo+rAn6ffitqm+EELuVBCJURH9NXsgbXMA9aHB4 6G/ainbqFk65lVWtUF55qohuwvJEJUFF8FLlv6497Ocqs5eqyI2FafsKuolkL1KhIV3qqoRURHuH qNNLtTcGqStx1wUIv2OH7gp7tSo1uLYWPmcVCbsYSVARvFR5vrP8Pq6/fzTwGLXzxvtaXqqizFmB 4SS7m1qE4XGkrUOPzCMImCpirH4CHp/dl3Z7WmKOl6DvUePbcMo0SFYCUSqy0jrsLmvUfMsas7zm 367rIhGWEFGqBBXBS5WrIlqPDr/F2mzaBC9VMRISUhH8VmUdL9zXXAKpVCTSx1TyFjzSyhv2OdTc ylU29TxVRGmGgSpBRfBSFXTSbpOT2wR1XJLBS1VwePlJ4beqsgO4YhWLsmg5vVp256DHdafuvkUr 9C7uhNEU9mpVMZQtrE7OKhIueYKK4KVKqYixTsrmpUo/KdScXOG3qoWDiawaJhBxuh72H2Wcikca gd0FVfxowjNVw63lJpCPitR8D4peXq+j4KVKYcHBSG7dmYRKToC/XS9jA7ZTRfBShYiUccxQ5uYR QEWax7Z5KTeqIhlKRkfJAI1bINAJBJgcytjKGVXEuI1fIQABCEAAAoKA/TbGep70zaCcLDcyQOMW CHQCASaHMrZyxr1II1X1OgpeqhrByL0QqB4BVKSMbdqoitR8OgsvVWXsFpQZAm0hgIq0BXuDmbZT RfBS1WDjcTsEKkYAFSljg+ajIgk1L7SXKlXufN9FmG9qZexTlBkCWQmUWEU6eOA3UUVa4aWqr0++ VtD90V60HurFCW2ca/M7idWVpvnCXZxNZZ2EuK/kBNqgInUN1QS8eaVTwhZsloq0yEvVYvvV0N6W IvDC22BrtEpFcDZVwlFAkYtCoA0qklfVURHX+3rdT/rqauE1R+u8VBkt5/6qvWgnwq+N+a28y9vU aK9+C24J/LsiXeU4lcfZVF6DknQ6kYCpIuH3t9tXpKs1+0eaH/S3jnqvEzKGq3+Xe4e633dPoju1 so0a4YzURcNSYLzUqxMbbX9uexFj8+G93DfhXCQfL1WB99iGXkkV4f1Ja2d/zjfeGxoZxzGY2a5p w05v7FtwNtWRo4hK50UglYp4JgfXE4I/Gp1PUZ6svLs01ZFj2REq/xXazve2PHhj3n2dsGs1D92V 8/FqXkBbkk60ihxev38R45FfY1+i18XrKE3wUuX2nvACIebsIbAYcdYa7krEq5L7PmrfYKan7y6J dBHxu1RETM1BiGeLM1wmaK+tDnSD4N5LpY2zqZaMFDJpBYFUKhL2C+KOe9+eHJiPPKlQVQgOQDWm zPkheIsXJyFZLFqGRSuDiojG0Q1ZaVQkBy9VkRYtObm6Hc2LoH8wvo3sQOEU9P4X3WO0q+F8zTGI s6lWzErkUS4CGVVErtpsC4FnbY70ZBVg4Q7AulQkIVlUJBcVUUJi9NoEi1YOXqoCLefuSYOTuSMH 3jY2/K1xJeSSXO1X+pxTfBU75EJK7WMCR/04myrXDEZp208gQkVcq5KzODRGmbZc7BOHm84gjfDw po/NwFh2ntCJsmiZm57wqPe9i+pr1/ZzbG0JcrNoxRU7QUVy8FIVsBf56wTXsY0lT81D/mrMb8Pm L9+BjZeCd5O7SQndZaxFcDbV2p5MblUgEH5GyxtnzliOUZHgGbt+DB48QvctCs7hepTx2T9d95// NJ+pcU3JYSdaVWiH+uqQj4oYhyLhX/VCeR2luF6q6mPoxMbZVCZs3AQBn0CJn/Tt4GZsp4oUzUtV Y90AEWmMH3dDYL98ZhQMpSPQqIpkqDAdJQM0boFAJxBgcihjK2dUEeM2foUABCAAAQgIAs7frqd/ 0jeDcrLcyACNWyDQCQSYHMrYyhn3Io1U1esoeKlqBCP3QqB6BFCRMrZpoypS8+mshCd9hYrs3rPP CE/88pPiehlRUmYIQKBBAqhIgwDbcns7VQQvVW1pcjKFQGEJoCKFbZqEguWjIgkZJOxFlsw/Y8eu vT9Y8l/fveeh+X+37Ks/+M3Lu/au+v23n/33W5745XXi2xpA83rlQF7pqOLmm1oZ+xRlhkBWAvWp SHispRl9aeJkLX9n3tdEFVFvQ0lQkZ9846yXduzd9vLel16W/26zP3vhJ988K7lJZGeonpcq51Vx 3muvgwySBwDDozMHcYVqjYqUsTGbpSLGi+J1NF5H+fHXz96yY++SB568918f//Gvluubki3b94pv k4HKV69V2UtVlCagImUcZJQ5NQFUJDWqAkXMTUX09zDqL/dN2Issun3CCy/tEWGz/a8RxLeJnOy/ FTdmVfdX7R1X5fVSFf5jeL9ayk9P0CmK/q3z+p8CdTSKAoEUBMIqEhrLoXdkKTNywI8D7qRSsM4v SoSKnLbCSv/3IuE9h/F+eLxUSbXTj0y8twvLdz6G3vvmHK0IbFFe5CNeGxx8I7HppyS/nkJKEGg+ gaS9iO+BSnvNr+v7xxktzmgIO5HTXseL4TfvdsxZRcIuRhJUBC9VTmtGd2v/pdN+owdjqhUYXqry HhSk1zYCESpi7DPC7/SNvII7qRa2YW4qIsqMlyrfwYjXs2MXPgleqpz2j3i/o5GanQYq0sLxQlbN JWCqiJSQoMe5lCqCO6nmNlQg9TxVRAmJUXi8VImZPmCcMh1eKRuutyN3Peh4TnO1b4NOFJTKaFsW PWYL+xBZQSAvAhEqoomI6/w8eCCoDQFXdHAnlVeDpEonZxUJ54mXqtDRX8jhlesUy/fvrj/oG9QG 1/mVPF13lEcbMr5rrFStTyQIFItA2KIV4XEu7BgqfCV83o47qaY1dT4qUvM9KHr5vY6Cl6qmNSsJ Q6CUBOp70reUVaxgodupInipqmCHokoQaIAAKtIAvLbd2qiKZCg4HSUDNG6BQCcQYHIoYytnVBHj Nn6FAAQgAAEICALSS1Vdf3WYQTlZbmSAxi0Q6AQCTA5lbOWMe5FGqkpHaYQe90KgwgSYHMrYuI2q SM2nsxKe9C0jL8oMAQg0jwAq0jy2zUu5nSryH9/8gBeaV0NShgAEykIAFSlLS+nlzEdFEmoetxe5 b9ZY/S7j1zKipMwQgECDBKqvIuFXIrl/Dhn1+tUgzqK+R7KJKpLgpeo/bv/ArvV3iLClf8H6R7++ 6v/9bP/9fyEu6iG2OxYVZYPjh9shAIE2qEjtV97l2iwqO38Sc99glGZaSxMn18KmTKxZKpLspeqB 20/YteX3CUFESFkBokEAApUh0E4VaQ1EQwnqevddmVRkpXX43dao+ZY1ZvmIcc+Mnrl5ZN9KQ208 4LpaGBcT9iIPfOmEXevvTwg/uurtNfYiEqjjL9d2ViULoraE2ht09Be5uc8BRLitCt6Fi47WDCdy gUCIgKki2jB3Brg9k8q3yKnh7o92z1WP70bbdzrijH57bAdS8O+X00ldk0P8FGSWKjgryXdKOnrg v1JPFjAm9wgfXAXrOVF7kawqosuG93LfyHORpUJFVt3lhftueG9CMIl5W0JFXTaE+8EQgCS3NrU8 RxWsnSgOBDqBQISKeG+GV28dtad9d/T6LyJ11vT6m+SdL0MeqwIpOKIinYP6M3u6ycHLy5yCQqWy J6mAH62wGS0u9/C9xesHOatISi9V991w7K7+BSoI/di16o7III5MxLexKuJJd/iDV46ACdLtKPr7 Pp09jObto3iNRIkg0CEEovYicq1o/9hHCIt9Jz7uvG9/qWQkYPNx4yd4rPLFo/7JIU4J9DKES2Wc ixiJhKcmI7VCWkpyUxHRHOm9VP3jrLG7+r8ugpQQ+0M4REuI1+oJTWi4tdF9BhpNaA5NtKRDJiuq WVACTVGRBI9VkSoSPVOHJocmqUgJ/WvlqSJKSIzuGWnR+tFVh+169LNSQh69NTLESkgaFYl3a6Nt Wmt5jiroKKNYEKgygSQVUctBc7ehnYYKm5H+rbN8DHmsCqSg+YjTzipquJVTLZBklQqWKuxHK8W9 bjP7q2DdXFeoTpCzioTrFqki375ojC0hn40MSRJSU0Vcj0/ysMo7LtMPscwjLHWqEuE5qlDtRGEg 0AkEos5FPBuHd37u2biiTtd9+5V2vBFn4raZOr7dIk7XEyeHWCUIlcrLw5uUUt3rnrcX3r9WPipS 8z0o+gBQHeVHn+hKCM0aMNpJW7OyIF0IQCArgUSLVopEjX1GijuI0jiBtqlI40VPn4K2Fan996Hp kyUmBCCQLwFUJF+erUmtURXJUMo2/GFRhlJyCwQg0HICTA4tR55DhhlVxLiNXyEAAQhAAAKCgO2l qp6/OswgZCw3MkDjFgh0AgEmhzK2csa9SCNVpaM0Qo97IVBhAkwOZWxcVKSMrUaZIVBNAqhIGdsV FSljq1FmCFSTACpSxnZFRcrYapQZAtUkgIqUsV1rqMjIWm+Gz1BnOkoGaNwCgU4gwORQxlaOVpHD 7nL8i6AiZWxUygyBkhJARcrYcKhIGVuNMkOgmgRQkTK2KypSxlajzBCoJgFUpIztioqUsdUoMwSq SQAVKWO7oiJlbDXKDIFqEkBFytiuqEgZW40yQ6CaBFCRMrYrKlLGVqPMEKgmAVSkjO2aUUV4dSUE IAABCEAgTMB5p2/NvxeBHQQgAAEIQAAV6acTQAACEIBAjgTYi6ArEIAABCCQnQAqkp1djmJOUhCA AARKSgAVQUUgAAEIQCA7AVQkO7uSLhwoNgQgAIEcCaAiqAgEIAABCGQnYKrIiHH9o2duHtm3Mkel IikIQAACEKgqAaki41dYh9/t+BdBRara0tQLAhCAQDMIZFSRMv7Vfl1lnjP7GgN3XbeXMXIHVrld zRRG3YyxTZoQaA2B7Cqy9cXVVQ1L7r0zckqtan1FvTqwyu1qzUjUrRnt5AKBZhBoSEWaUaAipJkw pRaheM0oQwdWuRkY06SJiqShRJwSEUBFIp5M6MAptQOr3K5Rioq0izz5NokAKoKKSAKoSJMGWDhZ VKRlqMmoNQRQEVQEFcn+pHyGUYqKZIDGLUUmUBgVWTarq2vWg0P5jWeVYKZk27Ywz1TapO6VGkJL q5x7NXPsNvkmFVVTVKTIEyJly0CgVSoihpPl/HTNXRpR0PQzS2zMpfNEHp4UpZ5AU9ocxFOh4qme aMRa7UQlexdm1cL2QUilIkWopoEoPbG65CGvZFGRurATuZwEWqMiC3qtsfOWqbl1QW/PgqaoiByx 3b1dbkYtVhFdvTILSfrJKy5mVghpVaTt1WyNiuQ1mFGRvEiSToEJtExFuhcZFPyFrT3ve+PNuK6E x93H9C60Nxz2j7GneXDuWHFlUY97vV0qIgocXxdRSLf0tvmuMBDqVpF2VTNSReyL83octHIvKMF6 XU70H/tzFG37LvltoGkiWtBNwcgonGzgirY5dvs/Fq0MNhNuKTKB1qhIv5jc5Y+/C3EHtjcZOeM2 dH1IykbARhS9DBfRbDVa2O0YtdqoIlL2xKQTVUd3alvUExNBLvbbACGLirSlmnEq4u3/3A4gupzT bcQV2fEim8ONo6mObBq/NzoRpMaIRGwd8pONbiy56HHisBcp8Aq6yPNyucrWIhVxoIjxrLQkaGGX i0Fv0ne3Hfb/3njWThoiVcS/6FrP2q4i4To6myp3jVwkCNlVpMXVjN+LOI9meBEc8RArGHezm9S1 1H5Xaxrj0QwlM3ruaXosKoKKdACB1qqIY56K14bwqEtzRTdHeMauNqpIjazdCSuuammqHDU9+TaZ +iFkUZG2VDO9ishdrL3hU2c5aah6Mh+uWoKKGM8WhpUmOI9g0SrXQpvS1iTQEhUR48qzZYVsBU4R 465HWrR8k7faowStXsqm0TYV8QwammVDzSPLZvU6z6cp+1tEBPtx59D15kOoX0XaVU39SQ37MENt bY1n82zg4tvenm73/CyOdlTTLFQJ+rfEZxRuLL+E8q7Q8+uoSM1ZiQjlImCqyMhxz6TxL5L02GvE Ds4/Ere8h7V0S4huPTCuB88qlblZnbL4p+vmMtMexmoiiFqz12yhVFOqXs2AVcd7Gk0/zlWnrP5j Ak7hCwMhVZWLUM3Is+u45b/aQHgtFUc7+ASHbBovQf8W/3TdNJ2Fe6yy3Io2FxqGinSASafmlFLt CK6K3OX4F2mOimT9+4k29b9UU2qbytak7tiBVW4SyZrJshepiYgI5SLQIhUJnGvavxQZU15Taolq nVeVi9ysBSkbKlKQhqAYeRFokYrkVdzWpNOBU2oHVrk1fSmcCyrSLvLk2yQCqAhvY+RtjC21uKIi TZrLSLZdBFARVAQVQUVaSqBdkx35NokAKoKKoCItnUPZizRpLiPZdhHIriJiMFQ4RPpdr3B9485F ql3ldtUu3LvaNf7JFwKNE8ioImIYVD4YcCtf3/DU1glVblcdGx+6pACBghDIqCIFKT3FgAAEIACB 9hJARVpqE29vY5M7BCAAgdwJoCKoCAQgAAEIZCeAimRnl7ukkyAEIACB0hFARVARCEAAAhDITgAV yc6udEsGCgwBCEAgdwKoCCoCAQhAAALZCZgqMuKEVP5FclczEoQABCAAgTISkCpy2grrsLsd/yKo SBlbkTJDAAIQaBcBVCT7Pq5dbUa+EIAABIpDABVBRSAAAQhAIDsBVCQ7u+KsBSgJBCAAgXYRQEVQ EQhAAAIQyE4AFcnOrl3KT74QgAAEikMAFUFFIAABCEAgOwFUJDu74qwFKAkEIACBdhFARVARCEAA AhDITgAVyc6uXcpPvhCAAASKQwAVQUUgAAEIQCA7AVQkO7virAUoCQQgAIF2EUBFUBEIQAACEMhO ABXJzq5dyk++EGgvAavzfgzg+zvsZ87saxK6HCqCikAAAvURECLSObOomEBFfcMqsvXF1R0Sltx7 Z30qMnIc/kXqG1HtXRWSOwRaT0CpSCfMoWoCjVOR1pNvS46pVGT8Cuvwuxz/IqhIW9qJTCFQIgKe ipSozNmKiooIbqgIGwsIQCBnAqiI2oplU6bS3YWK5Dx+StcDKDAEcieAiqAieqcy/a5j0cp9yJEg BCpGABUpuoosm9XVNevBoXzW0OxF8uFYsVmA6kCgEQKtUZEH5471nijumrtUFlifHBd2i297FzZ3 gLfiXMSuiPPTs6CRdvHvRUXy4ZiTDlMYCEDAINACFZES4q+mF/RalhQSb3IUH6yx85Y1V0K8g+Xm PaNlK2X3IneyWtTjf26o16EiDeFDPCAAgSYTaL6KCNkIioSaFr1/WyIhzVeRpfO6IrRQ24TZ39q1 ntfjbFfc7ZdUVvUjr0hZVT/+LVi0mr7KQKsgAIFsBJquIhFLaTFpdi+S18e2ZheiyDTXoiWn/sTN hzB2CRuXrRCOeIgrcosm5Ee35tlw1NJBl9ucFhOci6BGEIBAzgTaqSJirT1XzaQ5VypSUJuuIpEV 8TcWwpDn7sASREKPL7cjSm5zQ4SKtKKrZVvQcRcESkqg6SoylGjRGuqXNp+8DqIT1ai5KhKuptpM ePa68MYicqsR1gxUpKRDi2JDoEMINF9FbJ1IOF23TTrOg1vN3JQ0WUXsahqn65oAOBB0SXA+hy1a wcfVUJEOGYpUEwIlJdACFRFk9Cd9nVOBwOToPrhVZhUxqqk2WIvcg/Sunm7/mQLdouVsWSJP10NG sIb5YNHCogUBCORMoDUqUgSJbfZepAh1rFkGVCTn8VOTOBEgUHkCqEjR/3a94f2H3odREVQEAhDI mQAqgoroMsN7tHIeYJVfh1JBCKAiqEiEihyGf5Fc94BMNBCoMAFUBBVBRdh/QAAC2QkoFRHm8k4I +DpMey7CXqTCK0eqBoF8CQgVEXNr54TItzF2goJ6daztd114zEVF8h1mpAaBChNwXwPYQf8brdk5 CurVNKE/O6frqEiFxzxVgwAEINA8AqhIdutw81qFlCEAAQiUhQAqgopAAAIQgEB2AqhIdnZlWSlQ TghAAALNI4CKoCIQgAAEIJCdACqSnV3ztJ2UIQABCJSFACqCikAAAhCAQHYCqEh2dmVZKVBOCEAA As0jgIqgIhCAAAQgkJ0AKpKdXfO0nZQhAAEIlIUAKoKKQAACEIBAdgIRKvKmiwZGz9w8sm/liN4N aYJMggABCEAAAp1JQLyK8fjfBN7G+Ppzn33DJc8dfN4zrzmzP02wTluZNojM2hJOW2GlDONXWqlC 7hVJma9AnbIubWqU3DtD7gmmat/UzSFTa19nSJl12j4jKpKy4u2qcrvyTT3u0gJM321StkgzEkyZ 9Qrrg49axz1gHf731qj5ljX6n6zD77LD3e4H9WteQSSbJuSVnZuOeNlkviE9kJT5psJio8s9wZR1 OUxknSKkTM3pY2k6Q+o4aYpXV5yUdUmfZvpWThsz75HScfnmDbCOzpAy69T9P23b5Z6gqMjfy6np bQttFXnznfI/AgQgAAEIQKB+Av8XWBUbN7lsAMEAAAAASUVORK5CYII