From e6adb0980a1db8a356a7283c240a95b01a90a472 Mon Sep 17 00:00:00 2001 From: Benjamin Raymond <31401273+7PH@users.noreply.github.com> Date: Wed, 17 Jul 2024 13:49:10 +0200 Subject: SONAR-22492 Implement a helper to convert a position in a raw JSON to a path in a parsed JSON --- .../helpers/__tests__/json-issue-mapper-test.ts | 150 +++++++ .../js/sonar-aligned/helpers/json-issue-mapper.ts | 320 ++++++++++++++ .../mocks/fixtures/json/00-object-simple.json | 15 + .../mocks/fixtures/json/01-object-false-flags.json | 13 + .../fixtures/json/02-object-jupyter-notebook.json | 466 +++++++++++++++++++++ .../mocks/fixtures/json/03-array-simple.json | 9 + .../json/04-object-jupyter-notebook-oneline.json | 1 + 7 files changed, 974 insertions(+) create mode 100644 server/sonar-web/src/main/js/sonar-aligned/helpers/__tests__/json-issue-mapper-test.ts create mode 100644 server/sonar-web/src/main/js/sonar-aligned/helpers/json-issue-mapper.ts create mode 100644 server/sonar-web/src/main/js/sonar-aligned/helpers/mocks/fixtures/json/00-object-simple.json create mode 100644 server/sonar-web/src/main/js/sonar-aligned/helpers/mocks/fixtures/json/01-object-false-flags.json create mode 100644 server/sonar-web/src/main/js/sonar-aligned/helpers/mocks/fixtures/json/02-object-jupyter-notebook.json create mode 100644 server/sonar-web/src/main/js/sonar-aligned/helpers/mocks/fixtures/json/03-array-simple.json create mode 100644 server/sonar-web/src/main/js/sonar-aligned/helpers/mocks/fixtures/json/04-object-jupyter-notebook-oneline.json diff --git a/server/sonar-web/src/main/js/sonar-aligned/helpers/__tests__/json-issue-mapper-test.ts b/server/sonar-web/src/main/js/sonar-aligned/helpers/__tests__/json-issue-mapper-test.ts new file mode 100644 index 00000000000..3bfd497964a --- /dev/null +++ b/server/sonar-web/src/main/js/sonar-aligned/helpers/__tests__/json-issue-mapper-test.ts @@ -0,0 +1,150 @@ +/* + * SonarQube + * Copyright (C) 2009-2024 SonarSource SA + * mailto:info AT sonarsource DOT com + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ +import fs from 'fs'; +import path from 'path'; +import { JsonIssueMapper } from '../json-issue-mapper'; + +const FIXTURES_PATH = path.join(__dirname, '..', 'mocks', 'fixtures', 'json'); + +// Load all json files in fixtures and save them with their file names +function loadFixtures() { + const fixtureFiles = fs.readdirSync(FIXTURES_PATH); + const fixtures: { [filename: string]: string } = {}; + fixtureFiles.forEach((file: string) => { + fixtures[file] = fs.readFileSync(path.join(FIXTURES_PATH, file), 'utf8'); + }); + return fixtures; +} + +const fixtures = loadFixtures(); + +describe('JsonIssueMapper', () => { + it('should return cursor position in file from line offset', () => { + const parser = new JsonIssueMapper(fixtures['00-object-simple.json']); + expect(parser.lineOffsetToCursorPosition(12, 31)).toEqual(224); + }); + + describe('should not fail on invalid json', () => { + it('should not fail on invalid json', () => { + expect(new JsonIssueMapper(`This { is ] not " JSON :`).get(3)).toEqual([]); + expect(new JsonIssueMapper(`AAAAAAAAAAAAAAAAAAA`).get(3)).toEqual([]); + }); + + it('should not fail on non-terminated literals', () => { + const parser = new JsonIssueMapper(`{"key": nul`); + expect(parser.get(150)).toEqual([]); + }); + }); + + describe('should return correct path in strings', () => { + it('gets cursor path in a string value', () => { + const parser = new JsonIssueMapper(fixtures['00-object-simple.json']); + const cursor = 20; + expect(parser.get(cursor)).toEqual([ + { type: 'object', key: 'first-key' }, + { type: 'string', index: 2 }, + ]); + }); + + it('ignores false-flag characters in strings', () => { + const parser = new JsonIssueMapper(fixtures['01-object-false-flags.json']); + const cursor = 111; + expect(parser.get(cursor)).toEqual([ + { type: 'object', key: '\\"{}}[]]].:-]\\\\\\\\' }, + { type: 'array', index: 0 }, + { type: 'array', index: 0 }, + { type: 'object', key: '\\"{}}[]]].:-]\\\\\\\\' }, + { type: 'string', index: 20 }, + ]); + }); + + it('detects cursor in empty strings', () => { + const parser = new JsonIssueMapper(fixtures['01-object-false-flags.json']); + for (let cursor = 180; cursor < 186; cursor++) { + expect(parser.get(cursor)).toEqual([ + { type: 'object', key: 'empty-key-values' }, + { type: 'object', key: '' }, + ]); + } + }); + + it('detects cursor in empty strings in arrays', () => { + const parser = new JsonIssueMapper(fixtures['01-object-false-flags.json']); + for (const cursor of [209, 210, 211, 212]) { + expect(parser.get(cursor)).toEqual([ + { type: 'object', key: 'empty-key-values' }, + { type: 'object', key: 'list' }, + { type: 'array', index: 1 }, + { type: 'array', index: 0 }, + ]); + } + }); + + it('beautify stringified path when key is alphanum', () => { + const parser = new JsonIssueMapper(fixtures['02-object-jupyter-notebook.json']); + const cursor = 233331; + expect(parser.get(cursor)).toEqual([ + { type: 'object', key: 'cells' }, + { type: 'array', index: 21 }, + { type: 'object', key: 'outputs' }, + { type: 'array', index: 1 }, + { type: 'object', key: 'data' }, + { type: 'object', key: 'image/png' }, + { type: 'string', index: 23 }, + ]); + }); + + it('gets cursor in minified jupyter notebook files', () => { + const parser = new JsonIssueMapper(fixtures['04-object-jupyter-notebook-oneline.json']); + const cursor = 77354; + expect(parser.get(cursor)).toEqual([ + { type: 'object', key: 'cells' }, + { type: 'array', index: 1 }, + { type: 'object', key: 'source' }, + { type: 'array', index: 8 }, + { type: 'string', index: 14 }, + ]); + }); + }); + + describe('should return correct path in numbers', () => { + it('gets cursor path in a number value', () => { + const parser = new JsonIssueMapper(fixtures['00-object-simple.json']); + for (let cursor = 126; cursor < 138; cursor++) { + expect(parser.get(cursor)).toEqual([ + { type: 'object', key: 'nested-object' }, + { type: 'object', key: 'second-nested-object' }, + { type: 'object', key: 'foo' }, + ]); + } + }); + + it('gets cursor path in a number value in arrays', () => { + const parser = new JsonIssueMapper(fixtures['03-array-simple.json']); + for (let cursor = 78; cursor < 79; cursor++) { + expect(parser.get(cursor)).toEqual([ + { type: 'array', index: 0 }, + { type: 'array', index: 3 }, + { type: 'array', index: 2 }, + ]); + } + }); + }); +}); diff --git a/server/sonar-web/src/main/js/sonar-aligned/helpers/json-issue-mapper.ts b/server/sonar-web/src/main/js/sonar-aligned/helpers/json-issue-mapper.ts new file mode 100644 index 00000000000..c80d074f19d --- /dev/null +++ b/server/sonar-web/src/main/js/sonar-aligned/helpers/json-issue-mapper.ts @@ -0,0 +1,320 @@ +/* + * SonarQube + * Copyright (C) 2009-2024 SonarSource SA + * mailto:info AT sonarsource DOT com + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ +export type PathEntry = + | { + key: string; + type: 'object'; + } + | { + index: number; + type: 'array'; + } + | { + index: number; + type: 'string'; + }; + +export type PathToCursor = PathEntry[]; + +type ParseStepResult = { + endIndex: number; + found: boolean; + path?: PathToCursor; +}; + +export class JsonIssueMapper { + static readonly TOKEN_LITERAL = 'tfnu'.split(''); + static readonly TOKEN_SCOPE_ENTRY = '{["0123456789tfnu'.split(''); + static readonly TOKEN_SCOPE_EXIT = ',}]'.split(''); + + private readonly code: string; + + private splitCode: string[] | undefined; + + /** + * Internal cursor position, used during parsing + */ + private cursorPosition = 0; + + /** + * Current path to the cursor. used during parsing + */ + private path: PathToCursor = []; + + constructor(code: string) { + this.code = code; + } + + lineOffsetToCursorPosition(startLine: number, startOffset: number): number { + if (!this.splitCode) { + this.splitCode = this.code.split('\n'); + } + const charsBeforeStartLine = this.splitCode.slice(0, startLine - 1).join('\n').length; + return charsBeforeStartLine + startOffset; + } + + get(cursorPosition: number): PathToCursor { + this.cursorPosition = cursorPosition; + this.path = []; + + const result = this.parseValue(0); + + if (!result.found) { + return []; + } + + const path = [...this.path]; + + // Reset internal state for cleanup + this.cursorPosition = 0; + this.path = []; + + return path; + } + + /** + * Parse an array. Place the index at the end square bracket or stop as soon as the cursor is found. + */ + private parseArray(startIndex: number, index = 0): ParseStepResult { + // Check whether the array is empty + if (index === 0) { + const firstTokenIndex = this.parseUntilToken(startIndex + 1, [ + ...JsonIssueMapper.TOKEN_SCOPE_ENTRY, + ']', + ]); + if (this.code[firstTokenIndex] === ']') { + return { + endIndex: firstTokenIndex, + found: this.cursorWithin(startIndex, firstTokenIndex), + }; + } + } + + this.path.push({ + type: 'array', + index, + }); + + // Parse a single value in the array + const result = this.parseValue(startIndex + 1); + if (result.found || this.cursorWithin(startIndex, result.endIndex)) { + return result; + } + + this.path.pop(); + + if (this.code[result.endIndex] === ']') { + return result; + } + + // Parse next value if there is one + return this.parseArray(result.endIndex, index + 1); + } + + /** + * Parse an object. Place the index at the end curly bracket or stop as soon as the cursor is found. + */ + private parseObject(openBracketIndex: number): ParseStepResult { + const keyResult = this.parseObjectKey(openBracketIndex); + if (typeof keyResult.key === 'undefined') { + return keyResult; + } + + this.path.push({ + type: 'object', + key: keyResult.key, + }); + + if (keyResult.found) { + return keyResult; + } + + const result = this.parseValue(keyResult.endIndex + 1); + if (result.found) { + return result; + } + + this.path.pop(); + + if (this.code[result.endIndex] === '}') { + return result; + } + + // Handle next key or stop if there are no more + return this.parseObject(result.endIndex + 1); + } + + /** + * Parse an object key. Place the index at the `:` before the value. + */ + private parseObjectKey(startIndex: number): ParseStepResult & { key?: string } { + const keyStart = this.parseUntilToken(startIndex, '"}'.split('')); + if (this.code[keyStart] === '}' || keyStart >= this.code.length) { + // No entries in the object + return { + endIndex: keyStart, + found: this.cursorWithin(startIndex, keyStart), + }; + } + const keyEnd = this.parseUntilToken(keyStart + 1, '"', true); + const key = this.code.slice(keyStart + 1, keyEnd); + + const colonIndex = this.parseUntilToken(keyEnd, ':'); + + return { + key, + endIndex: colonIndex, + found: this.cursorWithin(keyStart, colonIndex), + }; + } + + /** + * Parse any JSON value. Place the cursor at the separator after the value (could be one of `,]}`). + */ + private parseValue(index: number): ParseStepResult { + // Then, it's either an object, a number or a string + const valueStart = this.parseUntilToken(index, JsonIssueMapper.TOKEN_SCOPE_ENTRY); + const valueChar = this.code[valueStart]; + let valueEnd: number; + if (valueChar === '{') { + // Object + const result = this.parseObject(valueStart); + valueEnd = result.endIndex; + if (result.found) { + return result; + } + } else if (valueChar === '[') { + // Array + const result = this.parseArray(valueStart); + valueEnd = result.endIndex; + if (result.found) { + return result; + } + } else if (valueChar === '"') { + // String + const result = this.parseString(valueStart); + valueEnd = result.endIndex; + if (result.found) { + return result; + } + } else if (JsonIssueMapper.TOKEN_LITERAL.includes(valueChar)) { + // Literal + valueEnd = this.parseAnyLiteral(valueStart); + } else { + // Number + valueEnd = + this.parseUntilToken(valueStart + 1, [...JsonIssueMapper.TOKEN_SCOPE_EXIT, ' ', '\n']) - 1; + } + + // Find the next key or end of object/array + const separatorIndex = this.parseUntilToken(valueEnd + 1, JsonIssueMapper.TOKEN_SCOPE_EXIT); + + // Cursor somewhere within the value? + const found = this.cursorWithin(index, valueEnd); + return { + found, + endIndex: separatorIndex, + }; + } + + /** + * Parse a string value. Place the cursor at the end quote. + */ + private parseString(firstQuoteIndex: number): ParseStepResult { + const endQuoteIndex = this.parseUntilToken(firstQuoteIndex + 1, '"', true); + + // Cursor within string value + if (this.cursorWithin(firstQuoteIndex, endQuoteIndex)) { + if (endQuoteIndex - firstQuoteIndex > 1) { + // We make it such that if the cursor is on a quote, it is considered to be within the string + let index = this.cursorPosition - firstQuoteIndex - 1; + index = Math.min(index, endQuoteIndex - firstQuoteIndex - 2); + index = Math.max(0, index); + + this.path.push({ + type: 'string', + index, + }); + } + + return { + found: true, + endIndex: endQuoteIndex, + }; + } + + return { + found: this.cursorWithin(firstQuoteIndex, endQuoteIndex), + endIndex: endQuoteIndex, + }; + } + + /** + * Parse any literal. Place the cursor at the end of the literal (last char). + */ + private parseAnyLiteral(index: number): number { + while (index < this.code.length - 1) { + ++index; + + const char = this.code[index]; + if (!/[a-zA-Z]/.test(char)) { + return index - 1; + } + } + return index; + } + + /** + * Return the first index of the next/prev specified token. + * If not found, return the index of the end of the code (code.length) or -1 depending on the direction. + */ + private parseUntilToken(index: number, token: string | string[], ignoreEscaped = false): number { + const tokens = Array.isArray(token) ? token : [token]; + + while (index < this.code.length && index >= 0) { + if (tokens.includes(this.code[index])) { + if (!ignoreEscaped) { + return index; + } + // Count number of `\` before the token. If there is an even number, the token is not escaped + // eg \\\\" -> 4 slashes, not escaped + // eg \\\" -> 3 slashes, escaped + let escapeCount = 0; + while (this.code[index - 1 - escapeCount] === '\\') { + escapeCount += 1; + } + if (escapeCount % 2 === 0) { + return index; + } + } + + index += 1; + } + + return index; + } + + /** + * Whether the cursor position in within the specified bounds (includes these bounds) + */ + private cursorWithin(startIndex: number, endIndex: number) { + return startIndex <= this.cursorPosition && this.cursorPosition <= endIndex; + } +} diff --git a/server/sonar-web/src/main/js/sonar-aligned/helpers/mocks/fixtures/json/00-object-simple.json b/server/sonar-web/src/main/js/sonar-aligned/helpers/mocks/fixtures/json/00-object-simple.json new file mode 100644 index 00000000000..27d667d4fd4 --- /dev/null +++ b/server/sonar-web/src/main/js/sonar-aligned/helpers/mocks/fixtures/json/00-object-simple.json @@ -0,0 +1,15 @@ +{ + "first-key": "foo", + "nested-object": { + "boolean": true, + "null-value": null, + "second-nested-object": { + "foo": 13e-4 + } + }, + "empty-object": {}, + "another-object": { + "containing-array": ["with a first string", "with a second string"] + }, + "last-ignored-key": "with some value" +} \ No newline at end of file diff --git a/server/sonar-web/src/main/js/sonar-aligned/helpers/mocks/fixtures/json/01-object-false-flags.json b/server/sonar-web/src/main/js/sonar-aligned/helpers/mocks/fixtures/json/01-object-false-flags.json new file mode 100644 index 00000000000..e8b20dbf5f8 --- /dev/null +++ b/server/sonar-web/src/main/js/sonar-aligned/helpers/mocks/fixtures/json/01-object-false-flags.json @@ -0,0 +1,13 @@ +{ + "\"{}}[]]].:-]\\\\": [ + [ + { + "\"{}}[]]].:-]\\\\": "\"{}}[]]].:-]\\\\value" + } + ] + ], + "empty-key-values": { + "": "", + "list": [[], [""]] + } +} \ No newline at end of file diff --git a/server/sonar-web/src/main/js/sonar-aligned/helpers/mocks/fixtures/json/02-object-jupyter-notebook.json b/server/sonar-web/src/main/js/sonar-aligned/helpers/mocks/fixtures/json/02-object-jupyter-notebook.json new file mode 100644 index 00000000000..19a11a9e41e --- /dev/null +++ b/server/sonar-web/src/main/js/sonar-aligned/helpers/mocks/fixtures/json/02-object-jupyter-notebook.json @@ -0,0 +1,466 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": ["# Learning a cosine with keras"] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import os\n", + "os.environ['THEANO_FLAGS']='mode=FAST_COMPILE,optimizer=None,device=cpu,floatX=float32'" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": ["(7500,)\n", "(2500,)\n"] + } + ], + "source": [ + "import numpy as np\n", + "import sklearn.cross_validation as skcv\n", + "#x = np.linspace(0, 5*np.pi, num=10000, dtype=np.float32)\n", + "x = np.linspace(0, 4*np.pi, num=10000, dtype=np.float32)\n", + "y = np.cos(x)\n", + "\n", + "train, test = skcv.train_test_split(np.arange(x.shape[0]))\n", + "print train.shape\n", + "print test.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": ["[]"] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAEACAYAAABfxaZOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAElFTkSuQmCC\n", + "text/plain": [""] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": ["import pylab as pl\n", "%matplotlib inline\n", "pl.plot(x, y)"] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": ["x_train : 0.0 12.5664\n", "(7500, 1)\n", "y_train : -1.0 1.0\n", "(7500,)\n"] + } + ], + "source": [ + "X_train = x[train].reshape(-1, 1)\n", + "y_train = y[train]\n", + "\n", + "print \"x_train : \", X_train.min(), X_train.max()\n", + "print X_train.shape\n", + "print \"y_train : \", y_train.min(), y_train.max()\n", + "print y_train.shape\n", + "assert X_train.dtype == np.float32\n", + "assert y_train.dtype == np.float32" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "scaler = StandardScaler().fit(X_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[array([[-0.33613324, -1.4662143 , 0.05394468, -0.55310005]], dtype=float32), array([ 0., 0., 0., 0.], dtype=float32), array([[ 0.67240888],\n", + " [-0.77499759],\n", + " [-0.6044634 ],\n", + " [-0.53235888]], dtype=float32), array([ 0.], dtype=float32)]\n", + "Epoch 1/10\n", + "7500/7500 [==============================] - 1s - loss: 0.3473 \n", + "Epoch 2/10\n", + "7500/7500 [==============================] - 1s - loss: 0.0384 \n", + "Epoch 3/10\n", + "7500/7500 [==============================] - 1s - loss: 0.0077 \n", + "Epoch 4/10\n", + "7500/7500 [==============================] - 1s - loss: 0.0068 \n", + "Epoch 5/10\n", + "7500/7500 [==============================] - 1s - loss: 0.0065 \n", + "Epoch 6/10\n", + "7500/7500 [==============================] - 1s - loss: 0.0063 \n", + "Epoch 7/10\n", + "7500/7500 [==============================] - 1s - loss: 0.0062 \n", + "Epoch 8/10\n", + "7500/7500 [==============================] - 1s - loss: 0.0062 \n", + "Epoch 9/10\n", + "7500/7500 [==============================] - 1s - loss: 0.0060 \n", + "Epoch 10/10\n", + "7500/7500 [==============================] - 1s - loss: 0.0060 \n" + ] + } + ], + "source": [ + "from keras.models import Sequential\n", + "from keras.layers.core import Dense, Dropout, Activation\n", + "from keras.optimizers import SGD\n", + "\n", + "model = Sequential()\n", + "model.add(Dense(1, 4, init='lecun_uniform'))\n", + "model.add(Activation('tanh'))\n", + "model.add(Dense(4, 1, init='lecun_uniform'))\n", + "model.add(Activation('tanh'))\n", + "\n", + "sgd = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True)\n", + "model.compile(loss='mean_squared_error', optimizer=sgd)\n", + "\n", + "print model.get_weights()\n", + "history = model.fit(scaler.transform(X_train), y_train, nb_epoch=10, batch_size=64, shuffle=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": ["y_pred = model.predict(scaler.transform(x.reshape(-1, 1)))"] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[array([[-1.74586737, -2.69134307, 2.61606312, -1.8561095 ]], dtype=float32),\n", + " array([-2.22873259, -1.28916156, -1.30692065, 2.32888794], dtype=float32),\n", + " array([[ 2.76829553],\n", + " [-2.36732125],\n", + " [-2.37912202],\n", + " [-2.66938806]], dtype=float32),\n", + " array([ 2.50017142], dtype=float32)]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": ["model.get_weights()"] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [""] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAEACAYAAABfxaZOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRBCRpC+EEEFEkr4QQgSR/w9qImX6dVIwKAAAAABJRU5ErkJggg==\n", + "text/plain": [""] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pl.plot(x, y_pred, c='r', label='y_pred')\n", + "pl.plot(x, y, c='b', label='y')\n", + "pl.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": ["## Playing with the number of hidden units"] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You might want to run the example multiple times as the random initialization influences the result quite a bit." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def train_plot_prediction(n_hidden):\n", + " model = Sequential()\n", + " model.add(Dense(1, n_hidden, init='lecun_uniform'))\n", + " model.add(Activation('tanh'))\n", + " model.add(Dense(n_hidden, 1, init='lecun_uniform'))\n", + " model.add(Activation('tanh'))\n", + " \n", + " sgd = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True)\n", + " model.compile(loss='mean_squared_error', optimizer=sgd)\n", + " \n", + " history = model.fit(scaler.transform(X_train), y_train, nb_epoch=5, batch_size=64, shuffle=True,\n", + " verbose=False)\n", + " \n", + " y_pred = model.predict(scaler.transform(x.reshape(-1, 1)))\n", + " \n", + " pl.figure(figsize=(10, 4))\n", + " pl.subplot(211)\n", + " pl.title('train loss')\n", + " pl.plot(history.epoch, history.history['loss'], label='loss')\n", + " pl.subplot(212)\n", + " pl.title('prediction vs ground truth')\n", + " pl.plot(x, y_pred, c='r', label='y_pred')\n", + " pl.plot(x, y, c='b', label='y')\n", + " pl.legend()\n", + " pl.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAEaCAYAAAAMtaHPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nHE2ocEcAAAAASUVORK5CYII=\n", + "text/plain": [""] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": ["train_plot_prediction(1)"] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAEaCAYAAAAMtaHPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [""] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": ["train_plot_prediction(2)"] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAEaCAYAAAAMtaHPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzs3XeclNX1x/HPoUkH6QooCFiwkiiKiq6KBBTBghFQg92Y\n2GNsUcGuIUajMYoCNlR+YgWsKK5i1xAbYAHpXXpny/n9cWfZ2WV2d3Zndmd29/t+vebFlDvP3H3m\nYebMfc4919wdEREREREJaqS6AyIiIiIi6UQBsoiIiIhIFAXIIiIiIiJRFCCLiIiIiERRgCwiIiIi\nEkUBsoiIiIhIFAXIIiJpwsweMbObyvjcTDM7P9l9EhGpjmqlugMiIlWBmc0FznP3KWXdhrtfkkAX\nPHIREZEEaQRZRCQ5HLCiHjQzDUiIiFQSCpBFRBJkZs8AuwETzWy9mV1jZh3MLNfMzjOzecC7kbbj\nzWyJma0xsw/MrGvUdp40s9sj1zPMbKGZXW1my8xssZmdE2d/zMxuMrO5kec+ZWaNI4/VNbOxZvar\nma02sy/MrFXksXPMbLaZrTOzX8xsSHL3lIhI5aAAWUQkQe5+NjAf6Ofujdz9H1EPHwXsDfwucvt1\noDPQEpgGPBu9KQqmSbQGGgO7AucDD5tZkzi6dC4wFMgA9gAaAv+OPDY0ss12QDPgYmCzmTUA/gX0\ncffGQA/g6zheS0SkylGALCJSvoa7+2Z33wrg7k+6+0Z3zwJuBQ40s0ZR7aPTNLKA29w9x93fBDYA\ne8XxmmcC97n7XHffCNwADDKzmsA2oDnQxYP/ufv6yPNygf3NrJ67L3P3GYn84SIilZUCZBGR8rUg\n74qZ1TCze8xslpmtBeZEHmpRxHNXuntu1O1NhNHgkuwCzIu6PZ8wKbsV8AzwNjDOzBaZ2b1mVisS\nSJ8B/BFYbGaTzCyeYFxEpMpRgCwikhxFVZCIvv9MoD9wnLs3ATpG7rci2pfVYqBD1O3dgGxgmbtn\nu/tt7r4vcDjQD/gDgLu/4+69gTbAD8DjSeiLiEilowBZRCQ5lgGdSmjTENgKrIrk/N5V6HGjmEoY\npfA8cFVkomDDyOuMc/fcyOS//SPpFusJaRw5ZtbKzAZE+pUFbARyktAXEZFKRwGyiEhy3A3cFKkM\ncXXkvsKjwU8TUh8WAd8DnxZqU3iSXllHk8cQUik+BH4hpGZcFnmsDTAeWAvMADIjbWsAV0X6thLo\nCSRSl1lEpNIy98TO5plZH+ABoCYwyt3vLfR4BvAa4UMa4CV3vyOhFxURERERKScJFa6PnKL7N9CL\nMOrwpZlNcPeZhZp+4O79E3ktEREREZGKkGiKRXdgVqSUUBYwDhgQo10ycupERERERMpdogFyW6JK\nGAELI/dFc+BwM/vGzN6IXjVKRERERCTdJJRiQXwTSKYB7d19k5n1BV4F9izcyMySUdpIRERERGQ7\ndy91JkOiI8iLgPZRt9sTRpGjO7Xe3TdFrr8J1DazZrE25u66JOEybNiwlPehqly0L7Uv0/Gifal9\nmY4X7Uvty3S8lFWiAfJXQJdIrc06hFWYJkQ3MLPWZmaR690JlTNWJfi6IiIiIiLlIqEUC3fPNrNL\nCcuW1gRGu/tMM7s48vhIYCBwiZllE2pxDkqwzyIiIiIi5SbRHGQ8pE28Wei+kVHXHwYeTvR1JH4Z\nGRmp7kKVoX2ZPNqXyaN9mTzal8mjfZk82pepl/BCIcliZp4ufRERERGRys/M8BRM0kuqdetS3QMR\nERERqe7SagS5YUPnoIOgd284/ng4+GColXASiIiIiIhUR2UdQU6rAHnTJmfqVHjnnXBZuBCOPTY/\nYO7YMdW9FBEREZHKokoEyIX7smQJvPtuCJYnT4ZGjfKD5WOOgSZNUtRZEREREUl7VTJAjuYO332X\nP7r86adw4IH5AfMhhygdQ0RERETyVfkAubDNm+Gjj/ID5vnzQzrG8ceHoHmPPcqxsyIiIiKS9qpd\ngFzY0qUF0zEaNMgfXT72WKVjiIiIiFQ31T5AjuYO33+fP7r8ySdwwAH5AXP37krHEBEREanqFCAX\nY8uWgukY8+aFSX55AXOnTuXysiIiIiKSQgqQS2HZsvx0jHfegfr1C6ZjNG1aId0QERERkXKUsgDZ\nzPoADwA1gVHufm8R7Q4BPgV+7+4vx3g8JUtNu8P06QXTMfbbLz9gPvRQpWOIiIiIVEYpCZDNrCbw\nI9ALWAR8CQx295kx2k0GNgFPuPtLMbaVkgC5sC1b4OOP8wPmOXN2TMewUu9mEREREaloqQqQewDD\n3L1P5Pb1AO5+T6F2VwLbgEOASekcIBe2fHnB6hg77VQwHWPnnVPdQxERERGJpawBco0EX7ctsCDq\n9sLIfdEdawsMAB6J3JV+UXAxWrWCIUPgySfD0tcTJ8Jee8GoUbD77tCjBwwbFiYBZmWlurciIiIi\nkqhEs2vjCXYfAK53dzczAyptgoIZ7LtvuFx1VUjH+OSTMLp8+eXwyy+QkZG/WEnnzkrHEBEREals\nEg2QFwHto263J4wiR/stMC7ExrQA+ppZlrtPKLyx4cOHb7+ekZFBRkZGgt0rX3XrhjSLY4+Fe+4J\n6RjvvRcC5rvugjp1QqDcu7fSMURERETKW2ZmJpmZmQlvJ9Ec5FqESXrHAYuBL4gxSS+q/RPAxHSq\nYlFe3GHmzPzJfh99BF275ucvH3YY1K6d6l6KiIiIVF2pLPPWl/wyb6Pd/W4zuxjA3UcWalttAuTC\ntm7NT8d45x2YPRuOPjo/YO7SRekYIiIiIsmkhUIqmRUr8tMx3nkn1FrOC5aPOw6aNUt1D0VEREQq\nNwXIlZg7/PBDfrA8dSrss0/BdIw6dVLdSxEREZHKRQFyFbJ1K3z6aX7A/PPPBdMx9txT6RgiIiIi\nJVGAXIX9+mvBdIwaNQqmYzRvnuoeioiIiKQfBcjVhDv8+GN+sPzhh7D33vnl5JSOISIiIhIoQK6m\ntm0rmI7x009w1FH5I8x77aV0DBEREameFCALACtXFkzHgPzRZaVjiIiISHWiAFl24B5GlKPTMfbc\nM390+fDDlY4hIiIiVZcCZCnRtm3w2Wf5AfMPPxRMx9h7b6VjiIiISNWhAFlKbeVKmDIlP2DOzc0P\nlnv1ghYtUt1DERERkbJTgCwJcQ/1lvOC5Q8+CMtfR6dj7LRTqnspIiIiEj8FyJJUWVkF0zFmzoSe\nPfMD5n32UTqGiIiIpDcFyFKuVq0qmI6RnV2wOkbLlqnuoYiIiEhBKQuQzawP8ABQExjl7vcWenwA\ncBuQG7n81d2nxNiOAuRKwh1mzcoPljMzoXPn/IBZ6RgiIiKSDlISIJtZTeBHoBewCPgSGOzuM6Pa\nNHD3jZHr+wOvuHvnGNtSgFxJZWXB55/nB8wzZsCRR+anY3TtqnQMERERqXipCpB7AMPcvU/k9vUA\n7n5PMe3vd/fDYjymALmKWL26YDrGtm35o8u9eikdQ0RERCpGqgLkgcDv3P3CyO2zgEPd/bJC7U4G\n7gZ2AXq7+xcxtqUAuQpyh9mzC6Zj7LFH/ujyEUdA3bqp7qWIiIhURWUNkGsl+LpxRbTu/irwqpn1\nBJ4B9orVbvjw4duvZ2RkkJGRkWD3JNXMQn5y587wpz+FdIwvvgjB8k03wfTpIUjOC5j33VfpGCIi\nIlI2mZmZZGZmJrydREeQDwOGR6VY3ADkFp6oV+g5s4Hu7r6y0P0aQa6GVq+G99/PH2HesqXgYiWt\nW6e6hyIiIlJZpSrFohZhkt5xwGLgC3acpNcJ+MXd3cx+A4x3904xtqUAWQqkY7z/PnTsmB8wH3mk\n0jFEREQkfqks89aX/DJvo939bjO7GMDdR5rZtcAfgCxgA3C1u38ZYzsKkKWA7Oz8dIx33oHvvstP\nx+jdW+kYIiIiUjwtFCJV3po1BdMxNm8OI8t51TGUjiEiIiLRFCBLtTN7NkyenJ+Osfvu+aPLSscQ\nERERBchSrWVnw5df5o8uf/ttWNEvL395//2VjiEiIlLdKEAWibJ2bcF0jI0bC6ZjtGmT6h6KiIhI\neVOALFKMX37JT8eYMgV22y1/dLlnT6hXL9U9FBERkWRTgCwSp+xs+Oqr/NHlb76BHj3yA+YDDlA6\nhoiISFWgAFmkjNauDUtg5wXM69eHQPn446Fbt7A0doMGqe6liIiIlJYCZJEkmTMnpGNMngwzZoTb\nTZqE5bI7dQqXvOudO0OzZqnusYiIiMSiAFmknOTmwuLFoazcrFnh3+jrZgWD5ujru+wCNWqk+i8Q\nERGpnhQgi6SAO6xcuWPQnPfvunUhRaPwqHOnTqFuc61aqf4LREREqi4FyCJpaMOG/OC5cAC9ZAm0\nbx87bWOPPVRZQ0REJFEKkEUqmW3bYO7cHUedZ88Oec/Nm+846px3vWnTVPdeREQk/aUsQDazPsAD\nQE1glLvfW+jxM4FrAQPWA5e4+7cxtqMAWSQiJwcWLYqdtjFrFtSpEztto1OnsAiKytSJiIikKEA2\ns5rAj0AvYBHwJTDY3WdGtekBzHD3tZFgeri7HxZjWwqQReLgDitWFD1pcNOmkKIRa9Jg+/bKexYR\nkeojVQFyD2CYu/eJ3L4ewN3vKaL9zsB37t4uxmMKkEWSYN26oicNLl8eVhGMlbbRsSPUrZvq3ouI\niCRPWQPkRMeS2gILom4vBA4tpv35wBsJvqaIFKNx47DASbduOz62ZUvIb44OoN95J/w7fz60bBk7\nbaNTp1ALWkREpDpINECOe8jXzI4BzgOOKKrN8OHDt1/PyMggIyMjga6JSGF168I++4RLYTk5sGBB\nwVHnL77ID6br1YudttGpE7RqpbxnERFJvczMTDIzMxPeTqIpFocRcorzUixuAHJjTNQ7AHgZ6OPu\ns4rYllIsRNKUOyxbFjvnefZs2Lq16MVS2rWDmjVT/ReIiEh1lKoc5FqESXrHAYuBL9hxkt5uwBTg\nLHf/rJhtKUAWqaTWrCl60uCvv0KHDrGrbnToADvtlOrei4hIVZXKMm99yS/zNtrd7zaziwHcfaSZ\njQJOAeZHnpLl7t1jbEcBskgVtGlTft5z4UmDCxaE5bhjpW106gSNGqW69yIiUplpoRARqXSyssLk\nwFijz7/8EgLkWGkbnTuHhVSU9ywiIsVRgCwiVUpuLixdGnulwVmzwuNF5T23bQs1aqT6LxARkVRT\ngCwi1cqqVbFznmfNCjnRHTsWnfdcu3aqey8iIhVBAbKISMTGjSFFI1YAvWhRGGGONfq8xx7QoEGq\ney8iIsmiAFlEJA7btsG8ebEnDc6ZA02bxl4spXNnaNYs1b0XEZHSUIAsIpKg3NwwwlxUyboaNWKn\nbXTqFKpxKO9ZRCS9KEAWESlH7qGmc6yFUmbNgvXrQ4pGrEmDu+8OtRJdt1REREpNAbKISAqtX58f\nMBdO31i6FNq3LzrvuV69VPdeRKRqUoAsIpKmtm6FuXNjl6ybOxdatIi9WErnziEnWkREykYBsohI\nJZSTAwsXxp40OHs21Kmz4wqD7dtDmzbh0qyZFkwRESmKAmQRkSrGHZYv3zFoXrQopG0sXRpK2rVq\nlR8wt2kDrVsXvJ13X6NGCqZFpHpRgCwiUg1t2RKC6LyAeelSWLZsx9tLloSAu6QgOu9f5UWLSFWQ\nsgDZzPoADwA1gVHufm+hx/cGngC6AX9z9/uK2I4CZBGRcrRhQ/FBdPT1evViB9KFb7dsqZUJRSR9\npSRANrOawI9AL2AR8CUw2N1nRrVpCewOnAysVoAsIpLe3GH16h2D6FiB9cqVYSJhUaPR0bebN1et\naBGpWGUNkBOtzNkdmOXucyOdGAcMALYHyO6+AlhhZicm+FoiIlIBzMLkv2bNYJ99im+bkxPqQxcO\nohcvhmnTCgbV69YVzJcuLs2jcWPlS4tI6iQaILcFFkTdXggcmuA2RUSkkqhZMwS1rVvDgQcW33br\n1vx86eiR6J9+gg8/LHhfdnbJQXTe9fr1K+ZvFZHqI9EAOak5EcOHD99+PSMjg4yMjGRuXkREUmin\nnUKJuvbtS267cWPsFI///W/H0eqddio5V7pNmzB6rXxpkaotMzOTzMzMhLeTaA7yYcBwd+8TuX0D\nkFt4ol7ksWHABuUgi4hIsrjD2rXF50nn3bdiBTRpEl+KR4sWypcWqQpSlYP8FdDFzDoAi4EzgMFF\ntFU2mYiIJJVZmCTYtCnsvXfxbXNywqTCWEH0118XvG/t2lChI540jyZNlC8tUtUko8xbX/LLvI12\n97vN7GIAdx9pZm0I1S0aA7nAeqCru28otB2NIIuISFrYti2MOJdUxWPZspBbXVIQnXe7QYNU/2Ui\n1YsWChEREUmBTZt2rCNdVGBdq1Z8qx62bh2WGReRxChAFhERSWPuodRdSUH00qWh2kfjxvGleLRo\nEaqJiMiOFCCLiIhUEbm5IV+6uBUP8y5r1oQgOZ40j6ZNlS8t1YsCZBERkWooK2vHfOmiAuvNm0su\niZd3u2HDVP9lIolTgCwiIiLF2rw5P1guaXS6Ro34SuK1bh1qUYukIwXIIiIikhTusH59fCkey5eH\n6hyNGoVc6Fq1dryU5v7Ksg2lqlQOCpBFRESkwuXmwqpVoZpHdnb+JSen4O2i7ktG24reRk5OGGFP\nh0A9HbaRzj8WUrVQiIiIiFRjNWqESYLViXv4YZAOQf22ban9ERHrx0I6BftlpQBZREREpBTMQkBW\ns6byr4v6sZCKMwOxfiyUlVIsRERERKRKKmuKRY3y6IyIiIiISGWlAFlEREREJErCAbKZ9TGzH8zs\nZzO7rog2D0Ye/8bMuiX6mlK8zMzMVHehytC+TB7ty+TRvkwe7cvk0b5MHu3L1EsoQDazmsC/gT5A\nV2Cwme1TqM0JQGd37wJcBDySyGtKyfQfK3m0L5NH+zJ5tC+TR/syebQvk0f7MvUSHUHuDsxy97nu\nngWMAwYUatMfeArA3T8HmppZ6wRfV0RERESkXCQaILcFFkTdXhi5r6Q27RJ8XRERERGRcpFQmTcz\nOw3o4+4XRm6fBRzq7pdFtZkI3OPuH0duvwtc6+7TCm1LNd5EREREJKlSsZLeIqB91O32hBHi4tq0\ni9xXQFk6LyIiIiKSbImmWHwFdDGzDmZWBzgDmFCozQTgDwBmdhiwxt2XJfi6IiIiIiLlIqERZHfP\nNrNLgbeBmsBod59pZhdHHh/p7m+Y2QlmNgvYCJybcK9FRERERMpJ2iw1LSIiIiKSDip0JT0tKpI8\nJe1LM8sws7Vm9r/I5aZU9LMyMLMxZrbMzL4rpo2OyziUtC91XMbPzNqb2ftmNt3Mvjezy4top2Oz\nBPHsSx2b8TGzumb2uZl9bWYzzOzuItrpuCxBPPtSx2XpmFnNyH6aWMTjcR+XiU7Si1vUoiK9CJP0\nvjSzCe4+M6rN9kVFzOxQwqIih1VUHyuLePZlxAfu3r/CO1j5PAE8BDwd60Edl6VS7L6M0HEZnyzg\nKnf/2swaAv81s8n6zCyTEvdlhI7NErj7FjM7xt03mVkt4CMzO9LdP8pro+MyPvHsywgdl/G7ApgB\nNCr8QGmPy4ocQdaiIskTz74EUGWQOLj7VGB1MU10XMYpjn0JOi7j4u5L3f3ryPUNwExg10LNdGzG\nIc59CTo24+LumyJX6xDmH60q1ETHZZzi2Jeg4zIuZtYOOAEYRex9VqrjsiIDZC0qkjzx7EsHDo+c\nRnjDzLpWWO+qHh2XyaPjsgzMrAPQDfi80EM6NkupmH2pYzNOZlbDzL4GlgHvu/uMQk10XMYpjn2p\n4zJ+9wN/BXKLeLxUx2VFBsjxzgYsHPVrFuGO4tkn04D27n4g4ZT3q+XbpSpPx2Vy6LgspUhKwIvA\nFZHRzx2aFLqtY7MIJexLHZtxcvdcdz+IEFwcZWYZMZrpuIxDHPtSx2UczKwfsNzd/0fxI+5xH5cV\nGSAnbVERKXlfuvv6vFM37v4mUNvMmlVcF6sUHZdJouOydMysNvASMNbdY30x6tiMU0n7Usdm6bn7\nWuB14OBCD+m4LKWi9qWOy7gdDvQ3sznA88CxZlZ4LkypjsuKDJC1qEjylLgvzay1mVnkendCSb9Y\nuU1SMh2XSaLjMn6R/TQamOHuDxTRTMdmHOLZlzo242NmLcysaeR6PeB44H+Fmum4jEM8+1LHZXzc\n/UZ3b+/uHYFBwBR3/0OhZqU6LiusioUWFUmeePYlMBC4xMyygU2EA0ZiMLPngaOBFma2ABgG1AYd\nl6VV0r5Ex2VpHAGcBXxrZnlfmjcCu4GOzVIqcV+iYzNeuwBPmVkNwiDbM+7+nr7Ly6TEfYmOy7Jy\ngESOSy0UIiIiIiISpUIXChERERERSXcKkEVEREREoihAFhERERGJogBZRERERCSKAmQRERERkSgK\nkEVEREREoihAFhERERGJogBZRERERCSKAmQRERERkSgKkEVEREREoihAFpEqzczmmtmxkes3mtnj\nZdzO92Z2VHJ7V/WZWYaZLUjB6841s+Mq+nVFpGqoleoOiIiUM99+xf2ueJ5gZk8CC9z95qjn7pf8\nromZ5QKd3f2XBLbxJIXeL8L77rGfISJSPI0gi0ilYWb6UZ8gi0h1Pwopsj96z0UkFRQgi0hKRU6F\nX29m081slZmNMbOdIo9lmNlCM7vWzJYAoyPx3fVmNsvMfjWz/zOznaO2d7aZzYs8dmOh1xpuZs9E\n3T7SzD4xs9VmNt/MhprZhcAQ4FozW29mr0X187jI9Z3M7AEzWxS53G9mdQr1+WozW2Zmi83snCL+\n9jPM7MtC910V9ZonRPbLusg2/1LEdmqY2X1mtsLMfjGzS80s18xqRB7PNLM7zOxjYCPQ0cwON7Mv\nzWyNmX1hZj0KvSfHRd3evt/MrENk23+I7OcV0fvZzOqZ2ZOR93I6cEgRbz1m9mHk6jeRfX16jPd8\nTOR9mVroublm1snMLor1fkV0M7NvIn/juLzjSkSkJAqQRSQdDAF6A52APYGboh5rDewM7AZcDFwO\n9AeOAnYBVgMPA5hZV+A/wJnArkBzoF3Utrafcjez3YE3gH8BLYCDgK/d/XHgWeBed2/k7gOinpv3\n/L8B3YEDI5fuMfrcONKH84GHzaxJjL97ArCXmXUutC+ejVwfDVzk7o2BfYEpMbYBcBHQJ9KX3wAn\ns2N6wVnABUBDQpD8OvAA0Az4J/B61A+NwukJsVIVjiC8V8cBt5jZXpH7hwEdgT2A3wFDi3g+7p6X\n031AZF+Pj9yOfs8vougRZnf3x4j9fhlweqQPHYEDgHOK2I6ISAEKkEUk1Rz4t7svcvfVwJ3A4KjH\nc4Fh7p7l7lsIQfJN7r7Y3bOAW4GBZlYTGAhMdPeP3H0bcHPk+XmiA60hwGR3/z93z3H3Ve7+TRFt\nCxsC3Obuv7r7r5E+nB31eFbk8Rx3fxPYAOxVeCPuvhl4Le/vNbMukXYTIk22AfuaWWN3X+vu/yui\nP78HHojskzXA3YX678CT7j7T3XMJP0Z+dPdn3T3X3ccBPwAnFbH9WPviVnff6u7fAt8QgnMIQemd\n7r7G3RcSfoCUNqWj8Hsej8Kv4cCD7r40clxNJPwIEhEpkQJkEUkH0VUO5hNGXvOsiAS7eToAr0TS\nIlYDM4BswqjjLsDCvIbuvglYWcRrtgfKOjFsV2BeMX1eGQlE82wijNzG8hz5PwiGAK9EBYWnAScA\ncyNpEocVsY1dKLgPF8ZoE/34rpE+R5sHtC1i+7Esjboe/fftyo7vZ2kVfs/LKrqPmyn6PRARKUAB\nsoikg90KXV8cdbvw6fn5QB933znqUt/dFwNLCIEvAGZWn5BmEct8QkpHLCVVP1hMCNSL6nNpvAu0\nNLMDgUGEgDl0wv0rdz8ZaAm8CrxQxDYK/N2Frm/fXNT1RcDuhR7fPXI/hBSMBlGPtSnhbyjcl8Lv\nZ2kV3v8bgfp5N8yscH/iqVahihYiEjcFyCKSagb8yczamlkzQn7vuGLaPwrcZWa7AZhZSzPrH3ns\nRaCfmR0RmTR3G0V/zj0H9IpMDKtlZs0jQSrAMkIObVGeB24ysxZm1gK4BXimmPZFiqSJjAf+Qci7\nnRz5u2qb2Zlm1sTdc4D1QE4Rm3kBuMLMdjWzpsB17BgQRqcgvAHsaWaDI3/7GcDewKTI418DgyKP\nHUwYyY43wHwBuMHMmppZO+CyEtovo+gfKnm+IaSaHGhmdYHhMbZR3PsFpU/zEJFqTAGyiKSaE4LV\nd4DZwM/AHYUej/YvQo7uO2a2DviUMEkOd58B/DmyvcXAKgqe7t8++czd5xPSF/5CSMP4H2EiF4TJ\ncV0jaRwvx+jzHcBXwLeRy1cl9LkkzxEmu40vlJpxFjDHzNYSJqudWcTzHyfsv2+B/xIm4OUU2lZ0\nPehVQD/C3/4rcA3QL3I/hNztToQJkMPJnzQYz993KyFdYw7wFvB0Ce2HA09F9vVAYtQvdvefCD92\n3gV+BKYWalPS+5XXZ40ii0hczD2xzwszGwOcCCx39/2LaPMg0JeQp3ZOMRNNRKSaMbM5wPnuXlSF\nBiklM+sLPOLuHVLdFxGRyigZI8hPEMoLxWRmJxBWSepCGAF5JAmvKSIiEWZWN1IzuZaZtSWUWitq\nJFVEREqQcIDs7lMJp+GK0h94KtL2c6CpmbVO9HVFRGQ7I6QqrAKmAdMJedEiIlIGFbGEZ1t2LD/U\njjCpQkSqOXfvmOo+VHaResrdU90PEZGqoqLWuI9VwL1gAzNNnhARERGRpHL3UlexqYgAeREFa3K2\nI7/WZgGxJgxu3AjTp8N338GXX8IHH8CSJXDUUdC/f7i0alU+Ha8uhg8fzvDhw1PdjWpH+73i5ebC\nZ5/BNdcMZ8uW4cyaBUccAYcdBgcdFC677QZWyo/STZvgxx/h++/h889h6lSYPTtsO+9zqn2sysTV\nkI771NG+T53S7Ht3+N//4JVX4N13w+dK9+7Qo0f4jOrWDTp2hBqqQxYXK+0HekRFBMgTgEuBcZFV\noNa4e9zpFQ0ahAOje3c4//xw37Jl8N578OqrcM01cMABcNZZMGgQNG5cLn+DiFRi//0vPPUUvPQS\n7LwzNG/6aOGoAAAgAElEQVQO//gHHHII1K6d+Pbr1w9fWt26wdmRBafXrAlfbhMmwC23hC+0oUNh\n8GBo0SLx1xSRqmXGDHj6aRg/PvxIP+00uPNOOPxwqFu3hCe7w6+/hgCpZUtoraleiUo4QDaz54Gj\ngRZmtoAwe7o2gLuPdPc3IrOrZxFWQzo30dds3RqGDAmXLVvgnXfgySfh2mvh5JPhkkvg0EMTfRUR\nqczWr4fnnoPHHoOVK+Hcc0PAus8+MHx4+NIpT02bwsCB4ZKdDVOmhCD95puhVy/4858hI6P0o9Ui\nUnVs2QIvvggjR4azTkOHhtsHHVTos2Hz5tBg1qzw78KFsGgRLF4c/l2yJPxS32WX8AF3+ump+pOq\njIQDZHcfHEebSxN9naLUrZt/CnPZMnjmmTCS3K4d/PWv0K+fTkOUJCMjI9VdqJa030tp06b8L4Ql\nS8IQ7fr1+ZetW8GdZRsa8K/vj+WxmT05qu1s7vrNVxzfbxE16tWD9+rDtJ3JaNAgnMNs2TJcdtqp\nXLteqxb07h0ua9bA88+HH/L168PVV8Pvfw916pRrF9KGjvvU0b5PncL7fs0aePhhePDBEAxffXWI\nV2pv2xhyKh7/Br75Jgwrz5oFK1aE01CdO0OnTiFnq3t3aNs2XHbdFerVS80fV0UlvFBIspiZJ6sv\n2dnhVOqIESGHOe/HlAJlkUpg2zaYNg2++CJMQJgxA2bODP+Zd901/9K0KTRqtP2ycFMz7p58MM9/\n1ZnBh8zmmt7f0rHRryGw3rw5/LtxI6xaFb5s8i6//hpyszp2hA4d8i977QX77x8mOZTDMG9uLrz1\nFtx3X/j+u+WWMHpUq6KmTotIhfv11/B//rHHoF8/57rT59B12fvw0Ufw6acwfz7svTcceGC47Lsv\ndOkSAuKaNVPd/UrJzMo0Sa9KBsh53MMp1b/9DbKyQi5P3746pSmSdn74IUwqePPNkDDcpUuYObff\nftC1a8iLaN065n/e1avhnntg1Ci44IIwElOq9Dt3WL4c5s6FOXPy//3hhzA7uGbN0I/998+fKbPH\nHkn9IPnkE7jpJliwAG69NZwF0w96kapj0ya4/364/5+5/P6gn7m2/r/p8Nk4aNAAmzcv1d2rMmLF\nkQqQi+EevntvuikMBj34YPiuE5EUWrEiJOWOGQPr1oUJBCeeGJKDmzQp8elZWfDQQyE4HjAgnClq\n2zbJfXSHpUvDKc9vvw0lMD79NIxy9+gRyun07h0C6CQEzFOmwI03htHlhx7SXAqRyi43F564bxXD\n7qzNETU+486sa+n8u05wwglw/PHQvn1eAJfqrlZ6Re1HBchxyMkJifDDh4cJfsOHh7O0IlKB5swJ\np3NefDEExRddFILNUgSYH34If/pTmGvwz3+GQeYKtXBhCJTffx/efjukcPTuHU5RnXgiNGxY5k3n\n5sKzz8L114fvz3vugTZtkth3ESl/mzbx9b1v88f796TG5o3cf+J7HHpZd+jZc4cJBwqQk0MBchKs\nWBFGaSZNggceCBNklHYhUs5Wrw6nccaNC9HtVVdBs2al2sTy5aFazXvvhf+7p56aJv93Z88OgfKk\nSfDxx3DccWHiQ79+IUe6DNavhzvuCAPsd90V0kfS4m8VkaL98gvrHxjNLY+357ncQdx14RzOHdGV\nGvWKngisADk5qnaAnJVVoTNUPvsMzjsvpDf+5z8qGyhSbv7v/+DKK8OI8R13hELEpTR+PFx2GZx5\nZjj7U8a4s/ytXg2vvRY6/Mkn4W++4IKQOlKGCPe778LnVOPG8PjjIf1ZRNLMDz/A7bfz7qQtnM8o\njj2+FiMebRRXzXMFyMlRtQPkBg3gt78Nk3MOOywk4O26a7m+7pYtYVLMmDFhRGrQII3SiCTNpk1w\n+eVhabmnngr/r0tp1apQM3jatFBEv1Ll5S5fHjo9alSYdXfxxSHaLWV0n50dJvjcey8MGwaXXqrP\nKZG0MGcO/O1vbJz8Cdd2eomJi7oxanQNeveOfxMKkJMj2QFyes2TXrgwnIJt2DB8oRxwQCi3dM45\n4ct1/vykv2TdunD33eHM6B13hNGpdeuS/jIi1c/ixWHUdPNm+OqrMgXHb74ZJtS2aRPKFleq4BjC\nrOBrrgll6kaODOkXHTuGBOPFi+PeTK1aoa77J5/A2LEhc2P58nLst4gUb8OGEK8cfDCfNujFQY1/\nYf2ev+Xb70oXHEvpZGRkMHr06Ap5rfQKkJs2DbNSbr4ZXn89JAu/9Vb4Vnz9dTj44FAk+8ILQ6X9\nlSuT9tKHHAJffhlOY3brFq6LSBn98EMIjgcNChFdKUdMs7JCrvHFF4cJa/ffHxbVqLTMwuScF14I\n9Z03bgz1TS+6KNR2i9Oee4ZyqQceGD6n3nmnHPssIrFNmgT77EPuL3O59+JfOGXiefz9HzV4+mlN\n/C9vZoZV0Omz9AqQCzMLBbMvuSR8sSxdGuq17b9/CJD32AOOPDJM8/7++1CSKQH168Ojj8Lf/x5G\naEaMCDPKRaQUfvoJjj02JApff32pcwHmz4ejjw5rhEybFpZjrlL22CPUcJs1K0xSPPDAMGExziHh\n2rXDpL2xY+H888MPiezscu6ziIT5BUOHwuWX8+tDz3PS2rFM+KAJX34Jp5yS6s5VPtlp/sGV3gFy\nYTVqhHqjl18OEyaEtaVvuiksP3vSSSEd47LLQg2oBCLb004LgzyvvBJmya9dm7w/QaRKmz8/nAW6\n886QGlVKkyaFszknnwwTJxLXBJdKq3nz8ON++vQQ4e6zT9hvW7bE9fRjjoGvvw6T+I4/XikXIuXq\no49C2mejRnw88nt+c/mR7LsvZGaGRe6qohEjRjBw4MAC911++eVceeWVRT4nIyODG264gUMPPZQm\nTZpw8skns3r1agDmzp1LjRo1GDNmDLvvvju9evUCYMyYMXTt2pVmzZrRp08f5kel006ePJm9996b\npk2bctlll+HuFZevnfdiqb6EriQgN9d9+nT3O+5wP+AA9113db/8cvePPnLPySnTJrdudf/Tn9z3\n2st9xozEuidS5a1b5961q/s//1nqp+bkuN96q3u7duG/bLU0e7b7gAHunTq5T5gQPtPikJ3tfvPN\n7u3bu3/6aTn3UaS6yc11HzHCvVUrz530uj/8sHurVu4TJybvJRKOf8rJkiVLvEGDBr5mzRp3d8/K\nyvJWrVr5tGnTinzO0Ucf7W3btvXp06f7xo0b/bTTTvOzzjrL3d3nzJnjZuZDhw71TZs2+ebNm/3V\nV1/1zp07+w8//OA5OTl+xx13+OGHH+7u7itWrPBGjRr5Sy+95NnZ2X7//fd7rVq1fPTo0TFfu6j9\nGLm/9HFpWZ5UHpekHyAzZ7rfdpv7fvuFb93rr3f/8ccybWrMGPeWLd1ffjm5XRSpMnJz3U891f3C\nC0v91PXrw1N79HBfvLgc+lbZvPVW+FXet6/7vHlxP23ChPA59cgj5dg3kepkwwb3U05x797dt/40\n1y+6yH3ffd1nzUruy5QY/4QE0sQvZdCnTx9//PHH3d194sSJvu+++xbbPiMjw2+44Ybtt2fMmOF1\n6tTx3Nzc7QHynDlzCmw/OuDNycnx+vXr+7x58/ypp57yHj16FNh+u3btKixArlwpFqWx995hst93\n34Wp8FlZYZJMz57wxBNhBmqczj03zBG84opQYknVWEQKGTEiVGV46KFSPW3OnDCXr2nTsCjdLruU\nU/8qk9/9LixrfcQRoezlo4/GlTJ20kmhSMZDD4VMszRP7xNJb0uXhskQjRuz/MUP6XX+7ixdGhbQ\n7NSpgvuSrBC5DIYOHcrYsWMBGDt2LGeffXaJz2kflXOy2267kZWVxa+//hrz8Xnz5nHFFVew8847\ns/POO9M8UiN/0aJFLFmyhHbt2hW57fJWdQPkaPvtB//4Rygjd801YaJf+/ZhNa+ZM+PaRF6Vi7ff\nhrPOgq1by7nPIpXF11+H/18vvAA7Fb1aVGEffBBWmL7wwlDVsRRPrfrq1IG//S0kOD7xBPTqBb/8\nUuLTunQJpeB++gn691fJSpEymT49lKUcMIBvrnyC7j134uijw7yktF2gqJwMGDCAb7/9lu+//57X\nX3+dM888s8TnROcQz58/n9q1a9MiakJJdBWK3Xbbjccee4zVq1dvv2zcuJEePXqwyy67sCCqyo+7\nF7hd3qpHgJyndm0YMCCscjVjBrRsGWa69O4dhohLGKVp3TqMcm3bFr6von4QiVRPW7fC2WfDffeV\naqbKuHFhJeaxY8Nopxa9KMK++4aI94QTQrnLZ58t8SlNmoSPsw4dwiD0vHnl302RKuO//w1Lxd9+\nO+8cejPH9zbuvRduvz3UCahu6tWrx2mnncaQIUM49NBDdxjRLczdGTt2LDNnzmTTpk3ccsstnH76\n6UWWZvvjH//IXXfdxYwZMwBYu3Yt48ePB+CEE05g+vTpvPLKK2RnZ/Pggw+ydOnS5P6BxUj47Taz\nPmb2g5n9bGbXxXg8w8zWmtn/IpebEn3NpNhll7CE3rx54Qt+2DDYa69wOrOYWeT16oVVc484Iox+\n/fRTBfZZJN3cfnsYtjzrrLiau4cyitdeC++9F35oSglq1gxnvt59N+zvoUNh/fpin1KrFjz8cP4K\n1198UUF9FanMPvss/BgdOZInc87m7LPh5ZfhjDNS3bHUGjp0KN9//31c6RVmxtlnn80555zDLrvs\nwrZt23jwwQcLPB7t5JNP5rrrrmPQoEE0adKE/fffn7fffhuAFi1aMH78eK6//npatGjBrFmzOPLI\nI5P7xxWnLInLeRegJjAL6ADUBr4G9inUJgOYEMe2YiZXV5jcXPepU91PPDFUwLjvvpCgX4zHHw+z\nWT/+uIL6KJJOfvrJvXlz90WL4mqene1+ySWhyMyCBeXct6pqwwb3885z79LFvZiZ5NEmTHBv0cL9\njTfKuW8ildnUqe4tW3ru62/4rbe6d+wY5vpXhJTHPyWYP3++169f39evX19i24yMjCIn0ZW3ovYj\nKZqk1x2Y5e5z3T0LGAcMiNEu/U+gmoVFRyZNCpfPPgsF/e+8s8jRmgsuCCtgDxgAb7xRwf0VSSX3\nMGv1+uth111LbL5pU6gp/vPPMHUqlHCWTorSoAGMHh3OfvXuDc88U+JTTjoplI0/99yQ0iIihUyb\nBqeeStZTz3Hhy3157bWQ2bT33qnuWOrl5uZy3333MXjwYBo2bBjXc7yKVDJINEBuC0RnTC+M3BfN\ngcPN7Bsze8PMuib4muWvW7cw4eiDD8KSuV26wL/+FXNmXp8++V8+caQHilQNkyaFEhSXX15i0zVr\nwkIWebmxjRtXQP+qusGDw4SI226DK68MVXqK0aMHTJkCN94I//xnBfVRpDL46Sfo14/ND43i1P/0\nYtGi8NXfpk2qO5Z6GzdupHHjxrz33nvceuut2+9v2LAhjRo1KnBp3LgxH330EbBjGkVlZYlE+mZ2\nGtDH3S+M3D4LONTdL4tq0wjIcfdNZtYX+Je77xljWz5s2LDttzMyMshIlzVmv/02fLN8/334Qjrz\nzJAXGGX69BAsX3NNGFgTqbJycsKKUn//O5x4YrFNly8PVcuOOgruv796TnIpV6tXw5AhYd7ECy+E\nicfFWLAgvB/9+sG992pypFRzCxfCkUey/trb6T/+bNq0gaefDvP5K5KZVZlR11TK24+ZmZlkZmZu\nv//WW2/F3Uv9aZdogHwYMNzd+0Ru3wDkuvu9xTxnDvBbd19V6H5P+wNk6lS47jrYuDGMKBcK4OfN\nC2c9Bw6EO+7Ql49UUWPHwn/+E4ruFnOQ5606PXhwmAOr/w/lJCcn1HwfNy7kepVwXnjlyhAg77MP\nPP74Dr/1RaqHdevgiCNYedpF9H3jMrp1Cx9rqfj/oAA5OYraj5H7KzxArgX8CBwHLAa+AAa7+8yo\nNq2B5e7uZtYdeMHdO8TYVvoHyBByL198MQwVH3ZYqP8aVd5qxQro2zec0vzXvzRiJlVMVlaIrEaN\n2uEHYrSffgo/Fq+4Aq66quK6V609+WT4Af/CC2GBg2Js3BjmTrRsmZoRM5GUysmB/v1Z0mJ/ek+7\nm759LaVnVBQgJ0eyA+SEwjd3zwYuBd4GZgD/5+4zzexiM7s40mwg8J2ZfQ08AAxK5DVTziwUcJ05\nM4zUdOsWJvJFSsO1bBnKV/33v/DHP8a1AJZI5fHkk9CxY7HB8TffhIdvvlnBcYU65xx47rn8AtPF\naNAAJk4Mg2hnnKGFj6SaueYa5q7dmZ4f382gQakNjiV9JTSCnEyVZgS5sDlz4Oqrw8Ijjz8eki0J\nhS/69QuxxOjROo0pVUBOTvhROHr09uO8sK++CmnJ//53iNMkBWbMCG/CueeGXynFfPNv3RpSYLZu\nhZdegrp1K7CfIqnw2GP8fPeLHJf1FtdeX4NLL011hzSCnCxpNYIshAj4lVfgnnvCN80ll8C6dTRq\nFNIBFy4M65BkZ6e6oyIJevVVaNECevaM+fCXX4a47PHHFRynVNeu8Omn4f267LJiT2PttFNY+Khx\n4/CDfuPGCuynSEX75BN+uuEJjt3yOsNuTY/gWNKXAuRkOeWUUMoiJycsDzthwvbTmGvWwKBBYYlq\nkUopegm8GCOSX3wRAqxRo6B//xT0Twpq0yaUgfvuu7DKYTFl4GrXDhkZ7duHSjwlLNInUjktX86P\np97AsTaFW++szfnnp7pDku4UICdT06bw2GNh1svVV8M551Avax2vvBJGkAcOVJAsldTUqaGkWIzo\n9/PPQ3A8enRYlELSRJMm8NZbsGEDnHxyWK2lCDVrhveva9ew0u6GDRXYT5HylpPDj/3/ynGbJnD7\niHqcd16qOySVgQLk8nDMMfD111CnDhx0EDt9+RHjx4eRmjPOKLGmv0j6+cc/4C9/2SGZ/rPPQlD8\nxBMhSJY0U69eSC5u3jwUQF6zpsimNWrAI4+ENPMTT1S6hVQdP/zpQY79+j7ueKAR556b6t5IZaEA\nubw0bBhGkx94AE4/ndrDbuT5p7aRkxNSlRUkS6WxaBF89FFIpo/y6adhQPnJJ0tcL0RSqXbt8Cb9\n5jehvMiKFUU2rVEDRo6ETp3CD55iBp1FKoUfHnmf40YN5q4RdTjnPIU8pTFixAgGDhxY4L7LL7+c\nK6+8MkU9qliqYlERli2DCy6AJUvY+vT/cepfO9GoUcj7q1Ur1Z0TKcGdd4Yl2B59dPtdn34a6ug+\n/XTIW5VKwD1UtXj11VCLsnXrIpvm5MB554XfRhMnhoFokcpmZuYyeh2Xy903rOcPd+ywgG/aSNcq\nFkuXLqVz584sWrSIJk2akJ2dTdu2bXnrrbfo1q1bqru3A1WxqIxat4YJE2DoUHbK6MFLZ73C6tWh\nbGlOTqo7J1KM3FwYM4boGS3TpoWU1qeeUnBcqZjB7beHEiMZGbB4cZFNa9YMb3ubNuGHUKTMu0il\nMeunXHr1qcndJ3+R1sFxPMyScymtNm3a0LNnT8aPHw/AW2+9RcuWLdMyOC4PCpArilkoufT669S9\n8Wpe7XwNSxblcsEFWkxE0tgHH0D9+nDwwUAo1HLCCWEwuW/fFPdNSs8srPt99tlhtb0FC4psWrNm\nyMxo3jwU6VGQLJXF/PlwfI/1DG83ij/8X+XP/3JPzqUshg4dytjIwkNjx47l7EKpdlWZUixSITJ8\nvHHhak6o9Q57HlCXkSO1LLWkobPPht/+Fq68klmzwsDjPfeEymFSyf3jH2FW3pQpsPvuRTbLzoYh\nQ0I+8ssvh7nHIulq6VI46tCtXLLydq769jzYY49Ud6lE6ZpiAbB582batm3Lhx9+SI8ePZg5cybt\n2rVLdbdiSnaKhQLkVHGH++9nw90P0af1/zjgqKY8/LCWu5Q0smYNdOgAs2axYHMLevaEG2+Eiy5K\ndcckaR58EO6/P+QkFxNIZGWFzIw6dcJq1po7Ielo5UrIODqX3y9/mJtHNIahQ1Pdpbikc4AMcOGF\nF/L555/TqlUr3n333VR3p0jKQa4qzODqq2k4/gneWH4w/319Cddd62U+DSKSdM8/D717szS7Bccd\nB1dcoeC4yrn88rD4S0YG/Pxzkc1q1w4r7q1Zg9LCJC2tWxfmRPSt+z43HT0V/vCHVHepyhg6dCjf\nf/99tUqvAI0gp4e5c1nV7w9kLHqW31/RhpuG1051j0Tg4INZed3fybjtWE4/HW65JdUdknIzahTc\neiu8+y7stVeRzTZuDEHIAQfAv/+tM16SHvKOy/2bLuDhr4/AvvkamjVLdbfilu4jyAsWLGDvvfdm\n2bJlNGzYMNXdKZJGkKuiDh1o9vmbvNPzdp6+ZwkP3Fp0MX+RCvHNN6xbuok+fz+Gvn1DdTCpwi64\nAG67DY49FmbOLLJZgwYwaVJYPfH668s+8UckWbZuDZNI99h1C/+edjj21JOVKjhOd7m5udx3330M\nHjw4rYPj8qBMsnTRoAFtXhvJu9f/h6Nu70+jrFWcf0f6Ty6QqmnTyGfoV/MNDjnEuPdejRRWC+ee\nG5KLjzsOJk+GffeN2axJE3j77ZCV0agR3HRTxXZTJE9WVlidtnFjZ/SWM6kxZFD4kSdJsXHjRlq3\nbk3Hjh156623Ut2dCqcAOZ2Ysdu9f2Zyx/fI+HNXGmz6gkH/7J7qXkk1s3XdVk4ZdSIdT2qu0+jV\nzdlnh/puvXqFKPiAA2I2a948xNBHHRUWDa0mC2tJGsnJCWsJbNsGL/R5glojf4EXnkt1t6qUBg0a\nsGHDhlR3I2UUIKehLn88jrd3nk6vIR1osOZlThp9iqIUqRBZWXDGcSto1LQmo/+vkUoPVkdDhoQg\nuXdveOstOOigmM3atAkpy0cdFVIvLrywgvsp1ZY7/PGPYa2bNx6cRZ1jrws123faKdVdkyok4a8/\nM+tjZj+Y2c9mdl0RbR6MPP6NmVWPJVgStN8Z+zLptVzOfzqD9056IBQjFSlH20dk5izmufuWqJRX\ndXbGGfDww2Hm07RpRTbbbbcwkjx8eCj/JlLe3OHqq+G772DCS1nUO39ImEHctWuquyZVTEIBspnV\nBP4N9AG6AoPNbJ9CbU4AOrt7F+Ai4JFEXrM6ObhfG16atBODJ5/Lp0f+NdSxESkH20dkftnCS7mn\nUGdg/1R3SVLttNPyl0z88ssim3XpErIxrr4aXnutAvsn1dKwYfD++/Dmm9Do/ttCvs+ll6a6W1IF\nJTpG1B2Y5e5zAcxsHDAAiJ4G3R94CsDdPzezpmbW2t2XJfja1ULPPg145pUcTh54K2/99gK6TbkP\n2rdPdbekCskbkfn+e3jnmPup99tToF69VHdL0sHJJ4d0ixNPhAkT4LDDYjbbbz94/fUQS9erF7Iz\nRJLt3nth/PiQTbHzjI/h8cfh66+rRAqiVYG/oapJNMWiLbAg6vbCyH0ltUnPdQrT1O9OqMkjzzTi\nhGVjmNl9KEyfnuouSRUybBhkZsIbk3Jp9NxIOP/8VHdJ0slJJ8GTT0L//vDJJ0U2++1vw1LUZ54J\nU6dWXPekenj4YRg5MuS9t9ppbVjv/rHHQjJ8JefuuiTpkkyJjiDH25vCP41iPm/48OHbr2dkZJCR\nkVGmTlVFp55mbNzUkN5XTuSDo49hj1f/CUcemepuSSVXYERm2nuhfmg3TROQQk44AZ55Jowov/xy\nkZ89Rx4ZFmA87TR44w04+OAK7qdUSU89BffcAx9+CG3bAmdfGvLj+ysVTHaUmZlJZmZmwttJaCU9\nMzsMGO7ufSK3bwBy3f3eqDaPApnuPi5y+wfg6MIpFtV6Jb1SePRR+Putm/hwWw/ajb41fGGJlMHD\nD8M//xn1pTNoEPTsCX/+c6q7Junq3XdDlYvx4+Hoo4tsNmFCWJZ88mTYf/8K7J9UOePHhxXR338f\n9t6bMBv0ttvC5NH69VPdPakEUrWS3ldAFzPrYGZ1gDOACYXaTAD+EOnkYcAa5R+X3R//CH++pj69\nGn3O8otvDhGzSCk9+WQYPX733UhwvGpVKOk1ZEiquybprFcvGDcOBg6EKVOKbNa/PzzwQBjk++mn\nCuyfVCmvvx7m3735ZiQ4njsXrrgiBMkKjqWcJZRi4e7ZZnYp8DZQExjt7jPN7OLI4yPd/Q0zO8HM\nZgEbgXMT7nU195e/wIYNdTl+3Fe8f+/hNFuyJNRZUpK/xGH8eLjxxjAi07Fj5M5nnw2n0XfeOaV9\nk0rg2GPhxRdDkPzcc3D88TGbDRoEmzaFhz/8EHbfvYL7KZXalCmh7OTEiZFS3Dk5YSGbv/4VfvOb\nVHdPqoGEUiySSSkWpeMePiemTsniXT+ORgfvBY88gorXSnEmTQpz8N55Bw48MHKne8g7vu++sMyw\nSDymTg3Jxk8/HYaKi/Dgg+EydSrssksF9k8qrU8+gQEDwo/57VOR7rwT3nsvnPbSCkZSCmVNsVCA\nXIm5w5/+BDO+y+HNuqeEM07jxunUk8T03nsweHAIkrtHr2D+3//C6afDrFn64pHS+eSTMA/i0Ufh\n1FOLbHbXXeEkxQcfQIsWFdg/qXSmTQu/t556KpQNBODzz0PezldfqcyplFqqcpAlhczCRKvd96jJ\naTVfZWvD5iFHcOXKVHdN0szHH4fg+MUXCwXHAGPGwLnnKjiW0jv88LBKyKWXhpJbRbjxxhDf/O53\nsHZtBfZPKpXp00OmV976NECYH3HGGeFOBcdSgTSCXAVkZ4fPD891Xuh0A7Vefy1MuFLSnxAGiPv2\nDVW6fve7Qg9u3gzt2oVi+/rykbKaNSscXOeeC3/7W8z5EO6hGsG0aSHFp0GDFPRT0tasWSGd4p57\nQoljIBw0AwZAp05w//2p7J5UYhpBrsZq1Qq1R7dsNc5Zeg+5F14MRxwB336b6q5Jin3/fVgE7fHH\nYwTHEGraHnKIgmNJTOfO8NFH+TW5cnN3aGIG//oX7LVXiHm2bElBPyUtzZ8fTn7ecktUcAxhXsSy\nZVTq49sAABoVSURBVKHkjkgFU4BcRdSpAy+9BIsWwSU/XomP+Ef4xElCsWypnH7+OQTF998fApKY\nHn8cLrywQvslVdQuu4Qk42+/Dcvpbdu2Q5MaNcIh17w5/P73kJWVgn5KWlmyJMwNvuKKUDt7u08+\ngREj4IUXwhecSAVTgFyF1KsXCvR/8w385ctB+PPjwrfQ+PGp7ppUsHnzwu+j224Luccx/fgj/PBD\nWEpYJBmaNg3pXVu2hF9nq1bt0KRmzZDu4x6qduXkpKCfkhZWrgxlAIcOhauuinpg+fLwwTV6tFIF\nJWUUIFcxjRqFoupTpsDwD48NyX5XXQUPPZTqrkkFWbw4jMj85S+hpFuRRo0K30wanZFkqlcvzAb9\nzW+gR49wKqOQOnXC7/YVK8KoYYyMDKni1q4Nv6H69Qtp69tt2xZqbJ91VnhQJEU0Sa+KWr48rAR7\n7rlw7e/nhro5p5wS6i1pQZEqa8WK8L6ffTbccEMxDbdtC3nHH30EXbpUWP+kmnnssZBY+sILcNRR\nOzy8YUMIkg4+OKy8p4+m6mH9+jBxuFu3UCO7wPv+pz/BwoXw6quqrCNJoUl6UkCrVqGe+siR8NDE\nDiEQev/9sDSREv+qpBUrwsjxaaeVEBwDvPYadO2q4FjK10UXhXyKgQNDYdtCGjYMywlPnRpGETVG\nUvVt2BAmDu+zT5i0WSA4HjkyzJsZO1bBsaScRpCruLlz4Zhj4Jpr4M/nbAz14HJywvnNhg1T3T1J\nkl9/DcFxv35wxx1xjMT17h1OLxSZoCySRDNmhELI/fqFiVe1axd4+Ndfw+fUySeHvHmNJFdNGzeG\nOsedO4fJmgVi4A8+CHNmdFZLkkwjyBJThw5h4HjECHj4yQbhtNWuu4Zvo+XLU909SYKVK8OEvBNP\njDM4njUr1D0+5ZQK6Z8IXbvCl1+GfORjjw2lC6K0aBHmTbz6asjI0FhJ1bNxY/h9tMceMYLj6dND\ncPzsswqOJW0oQK4GOnQIZ61GjICHR9YKk7P69g21kmfPTnX3JAF5wXGfPnDnnXGOvD30EFxwAdSt\nW+79E9lu551h4sRwwB58cFjeMUrLlvlB8s03K0iuSjZtCsVydt89fP0UCI4XLQrDyvfdF44NkTRR\nK9UdkIqRFyRnZAAYf77ttjCSfOSRYQJNz54p7Z+U3qpVoUTS8cfD3XfHGRyvWxdyQrWIjKRCjRow\nbFhYnObUU+Haa0OVnUjElBckH3tsaH777Uq3qOzyguN27ULVtpo1ox5cuzYM1lxySaEVQkRSTznI\n1cycOSG74q9/hT//GXj77VDyYMSIUPJLKoXVq8NgyzHHhLcu7iDigQfgs89g3Lhy7Z9IiebMCQuK\nNGwYJvDtssv2h1asCEHygAEKkiuzzZtD6nmrVvD004WC4w0bQnB84IHhrJbeZCknykGWuHTsGJWT\n/DChxlJmZpgZc8MNKkhaCfz6awiOjz66lMFxTk74IrriinLtn0hcOnaEDz+Eww4LNZMnTdr+UN5I\n8muvKd2istqwIeQct2wZfv8UCI7zhpX33DNGnTeR9KAAuRqKDpIfeIAwgebzz0NO4MCBYTaFpKWl\nS0OaTO/eIWWvVN8rEydCs2YhIBFJB7VqhR/nL7wQTmldckkokkvBIPn66xUkVyZr14Z5EbvvHjK6\nakUnc27eHE4NtG8f6mSrnJukqTIfmWbWzMwmm9lPZvaOmTUtot1cM/vWzP5nZl+UvauSTHmDN//5\nTziF6c1bwOTJ0LhxyEtesCDVXZRCFiwIay0MGlSG9V7cw5Ouv16jNZJ+evaEb76BrVthv/1C6hch\nSH7/fXjvPbj0Up3gqgxWrQpnuA46KEzIKzByvH59/rDyE08UelAkvSTy0+16YLK77wm8F7kdiwMZ\n7t7N3bsn8HqSZLvtFoLkF14Ic2W8zk7hQ2vIEOjePXwrSVqYPTsEx5dcAjfdVIYYd/LkcM5Tpd0k\nXTVtCmPGhBpgF18cFjVatYoWLcJH0bffhruys1PdUSnKsmXhDNcxx4RsrgKDw8uXhwe6dAnDygqO\nJc0lEiD3B/KWRnoKOLmYthqySlNt2oT67B98EIKvXLcwg2/s2DCr+N57dW4zxWbODF86110XJvyX\nyZ13wo036nSmpL/eveG776BRI9h3XxgzhiaNcnn77RBj/f73YaBZ0svChWFexGmnha+NAj/i584N\nZwn69oVHHlFwLJVCmatYmNlqd985ct2AVXm3C7X7BVgL5AAj3f3xIranKhYptH59fime/2/v3sOi\nqrc+gH+XUqjgtQxN7WTl/UFTy7xVZHKknlIz89U0NbufvGWnF7NTZHnKykue4mSWWmqkHbVEo/JK\nWpppYC+khFYqqKmJVzogyHr/+I46KijCMJuZWZ/n2c84MMz82MXea//2+q01c6ar0VVGBnOS69UD\nPviA6RfGq5KSeEdy/Hhg4MASvsnq1eya9/PPZyUDGlPObdgADBvGi/S33kJuq3bo35/Hq4ULgZAQ\npwdoAPZ/6dYNePxx3o08w+rV7OA6Zgz/WxrjZWVSxcKVY5xSyNbd/XWuyLao6LaTqrYGcAeAJ0XE\nCu6WQ1WrAgkJzB/r3ZvrKNCgAQ9uV1zBuqVWO9erli/nQpfY2FIEx6qceo6JseDY+J4bbwTWrgX+\n9jegZ08EPzEEcydkom5dBmQHDzo9QLNxI9O/Ro8uJDieNg247z6WsbDg2PiY0swgp4G5xb+LSF0A\nq1S16QV+JgbAMVWdWMj3NCYm5tTziIgIRLCrhfGi48c52bh9OxAfD1x2mesbs2cDo0axD+zQobbQ\nq4x9/DEwciQwf34pe7gsXMgqAUlJll5hfNuRI+yIM20aCgY9iKf/fBnLvqmMhASupzDet3QpS1m/\n9x7Q0z3J8tgxYPhwYN06nkisfbTxosTERCQmJp56Pnbs2BLNIJcmQH4dwAFVfU1ERgOooaqjz3pN\nFQAVVfWoiIQAWApgrKouLeT9LMWinCgoYEnkRYuAL79kFz4AwLZtQL9+QFgY8zBq13ZymH5r8mRg\n0iTgiy+4oL/E8vKYw/n228zrNMYf7NkDjBsHzJuHSW0/wuTUSCxJqIBWrZweWGCJi+OaiAULWPjo\nlB9+4Hmic2fWOA4NdWyMxgDONAoZDyBSRNIBdHE9h4hcKSKfu15TB8AaEdkEYD2AJYUFx6Z8qVCB\niyyGDgU6dQKSk13fuO461koOD2cNn6X2n9KTCgp4i3LaNO7mUgXHAE9ODRtacGz8S926zDtavx6j\n6sRhwuFHENnxGFbM+8PpkQUEVV7AR0ezusip4Dg3l3eroqL4OGOGBcfGp1mraXNeCxdy4cXs2cz5\nO2XFCmDIEAZfEyYA1as7NkZ/8Oef7PS9e/dZqS0ltWMH0LYtb3Ha7U3jz3bsQOKoePT5tC8m37oI\n/WM7svmR8bi8PGZOrFmDM1Nbvv0WeOQRTqLExnL9ijHlhLWaNmWiVy/g008ZvMXGulV8u/12lmK6\n5BJOdbq1iTUXZ/dulkeqVInXHaUOjlW5IGbECAuOjf/7y18QsWAYVq0Owpjk3ohp9wUKbr0NmDeP\niyqMRxw6BNx5J6+91651Bcc7d3IFcZ8+nDVetMiCY+M3LEA2F9SpEw+IU6dyNvnUOadaNbbimz2b\nK8r692cvZFNsycns/HzPPcCsWQySS23OHHYWOWdJuTH+q0Xnmvj+5xpY3vIp3JczG8diP2Sv42ef\nBTZvdnp4Pu2XX4AOHTgxHx8PVDtxkGUrWrfmPk5LY/kjW7xt/IgFyKZYrrmGQfKePUBkJLB/v9s3\nIyLYJrZ+feYnT57Me3HmvBYuZIbKpEksEeqRc8svv7DaSFwcEBzsgTc0xneEhQErV1VA9Rb10elw\nArbPXsPWe5GRQJs2/GPbs8fpYfqUxEROkgwfDkyJ3o2gZ59hKsUff7D058svs06oMX7GAmRTbFWr\nAp99xoNlu3aMiU8JCeHKvm++YemL66+3VtVFyM/n5MtTT7FSRe/eHnrj3Fy2CX/uOdiSfhOogoOB\n6dNZrrLDA9dh9d1vMBVgwgQgNZXToDffzOdbtzo93HJLlbuob1/FnDGb8cT3DzKdLi8P2LQJeP99\nNpEyxk/ZIj1TInPnMs11/Hiu1Ttj9lOVuWijRgFNmgCvvMJbcQZ797ICUsWKrHV8+eUeemNVYPBg\nIDsb+OQTq3lsDFho54EHeCh65hnXn0VODrByJXMF4uO5wLh7d6BrV179V6ni9LAdd+QIMOT+HOxM\nOYT5lQfiqhO/AY8+yqsOjx20jPGOki7SswDZlNiWLWyS1LYtU5HPaft6/Dhrlv3zn1yF9tJLQOPG\njoy1PFi3jmtZBg0Cxo5lkOwx48czMF6zxvrvGuNm5052Or7sMjZ0O2MRbEEB6/YuWcI7Xps2ATfc\nAHTpwq1tW6ByZcfG7nUZGdj8ztfo9ebNiDixElN6fY3gRwfx+G0X3cZHWYBsHJGdzS6wGzcC//lP\nEdWVsrOBKVOY/9etGwtotmzp9bE65cQJZp+8+SZv/d59t4c/IDaW90LXrGEeuDHmDMePc63e/Pks\nbtG+fREvPHaMf0crVzL5dvNmoGlT5pTddBMfGzf2n7btBw/y9122DLp0Gd7ddReez38Bbzz+Cwa/\n1tzWMRi/YAGycYwqa8JHRwMxMcCTTxYx2XD4MEthTJnCHOXoaOCWW/x65fPOncCAAZwtnjWrDCog\nxcYCr7/Ok3nDhh5+c2P8y6JFLNc7dCgD5ksuucAP5OSw1Mz69dw2bGBdxsaNmY8bHs7HRo1YzaE8\nB5QHDvC2X1IS8P333PbsAdq3xx8du+Phrx9AxtHqiIsTNGni9GCN8RwLkI3j0tNZErNqVQbMRQaD\nOTmMFidMYL7f44+zRJwfrYRW5UzV8OHA008Df/+7h1MqCgq40u+zz7jS79prPfjmxvivzEyumzh0\niIehpk0v8g2ysxlopqZyS0kBtm3jG4eF8UL1mmuAq69m1786dU5vYWFlE0SrstvQrl0cR2YmkJHB\nosVpaRzv8eNAs2acnGjXjluzZli6oiKGDOH63nHjgEsv9fzwjHGSBcimXMjPZzrsv/4FTJzI2dMi\nJ4gLCpj3N3UqsGoVEwUHD+aB24dnlXfvZtpJejpPwDfc4OEP2L+fi2UOH2aAXOrOIsYEFlUedp5/\nntuwYR5Isc3PZ2D666/ctm9nXfi9e/n4++/Avn2MQKtVO3erXJmpG+5bxYp837w8Brgntz//ZHrE\noUN8PHiQv0D9+mduDRrwCqBZMwbobsfVrCxevK9axdSv228v5e9vTDllAbIpV5KSGMNdcQUX8F2w\noduuXZx2njOHJ4T772e5Bx9qGVtQwMpHzz0HPPEEHz0+WbRkCfDYY5yqHzvWpnuMKYWtW3mcys9n\nwHz99WX8gaosEXH0KB9PbocPs0xjfv65W1AQ/87dt0qVgJo1T281alzUYsIFC3hR0Ls311D70c07\nY85hAbIpd/LzmW786qtMNYiOLkbAqMroOi6OteRq1ADuuotbhw7ldnHMpk38HXNyOBsTHu7hD9i6\nlbWqfv6ZZ/IuXTz8AcYEpoICYOZMNuvp35/Xnf4aMJ48jGzbxov5Tp2cHpExZa+kAbLVbTFlJiiI\nt/CSkri1aMFKF+e9DhJhaaWJE5lDN2MGo+oRI5i/168fS8elpV3gjbxj3z6WB+3WjZPe69Z5ODhO\nTWWeSocOQOfOzHe04NgYj6lQAXjoIf6pHTzIjITp01l9xl8cOcLO8x06cF30pk0WHBtzITaDbLxm\nxQouVgsO5vq8zp0v8g0yM4GvvgK+/ppbbi6P9h07Mqhu3RoIDS2TsZ/t6FHgrbfYVXvAAOCFF3in\n0yMOHWI9qg8+YOvoESOYs1G9uoc+wBhTlPXr2VQkK4vlGe+803eXROTkcD7h1VeBO+5gz6Y6dZwe\nlTHeZSkWxicUFAAffQT84x9MLx4zhl1fS2T7dgbK69ez2H9qKnDVVQyWw8M5FdSkCSs8XLCeU/Fk\nZ7Oy2sSJbLwVE+OB3ie5uezbnZgIJCTwd4mMZHJkVJTHxm6MKR5VpvtHRwO1anE9QVSU7wTKx49z\nFvxkE9OxY62ZqQlcFiAbn5KbywoP48cD9eqxYllUVClXkuflsbD/Dz/wMS2NW2Yma5Redx1XdZ+9\n1a7NVeTnOfvt2cPFhu++C0REAC++WIL1g7m5LLuUns5kwPR05p6kpHAVY+fOnK667TZrd2tMOZCf\nz7SwV17hdero0UCvXuV2KQSysniMio1leeaXXmJRIGMCmQXIxifl57ND8oQJXMj92GOcOK1d24Mf\nkpvLVSm//sq85owMdvDIyGDwvH8/X1OrFkumXX45UKsWNCQU3x4Jx7Stt2HJ9hbo13Izht/6I5rU\nOXzuZ5w4wdJL2dmnH48eZZLy3r3csrMZkDduzIC4USOgTRtO7Vh7aGPKrYIC4PPP2ZPnt9+Ys/zw\nw2XQ+KcEVDknMH061zX36AGMHOmFihzG+AivB8gich+AFwE0BXCjqiYV8booAG8CqAjgfVV9rYjX\nWYDskMTERERERDg6BlU2qXrnHeDTTzmJ2qcP2zJ7Ja04N5fTLwcOID05G3FLqmF2Yn1UqpiHB29M\nxUMtN6KmZgH//W/hiwMrVOCsb0jI6ceQENa5CwvjVrPmGVPk5WG/Byrb987x9X2fksJZ2rg4dp/u\n0wfo2dODaxCKaccOTi58+CEPSwMHcsFw3bpF/4yv73tfZvveOSUNkEtzoygFwD0A3j3PoCoCeBtA\nVwC7AGwQkXhV3VKKzzUeVh7+cEVON3eaPJktYWfPZpO9iAim5HbtypRiT+cBZmcD330XjISEuli8\nuC6ys4F77wU+SeAEr8gtAG7x7IeifOz3QGX73jm+vu/Dw4G33+YCvsWLmYIxciTQvj3w17+y4UbL\nlh5oPHKWnBxg40bgyy+B+Hj2HenRg5MKnTsX77jo6/vel9m+9z0lDpBVNQ1gZH4e7QBsU9XtrtfO\nBdADgAXIpkg1agCDBnHLymLhiuXLeXszP5+d6Vq35taoEdOLizPLrMpsipOpySkpLMu2ZQvQqhVz\noOfO5fv6ymIcY4wzQkKAvn25HTvG49SKFawakZV15nGqSRMep4pTiEaV5eZOdoj+6Sfgu++4jrd5\ncwbgU6dy9tqj7euNMWco66UG9QBkuD3PBHBTGX+m8SO1arH0cb9+PHFs3851bcnJwHvvne7oGhLC\nvOWqVbneLiiIa/by83ny2rePW2goi1s0bcqTTd++LHpRqZLTv6kxxleFhvKu07338nlmJvOCk5PZ\nHHTbNqZEBAUx26pqVW7BwTxO5eUxTeLkkoVLL2VQ3bw5u0SPG8eA2JYqGOM9581BFpFlAAqrmjhG\nVRe7XrMKwNOF5SCLyL0AolT1EdfzAQBuUtVhhbzWEpCNMcYYY4xHeTwHWVUjSz4cAMw7dl/n2wCc\nRS7ss+ymtjHGGGOMcZynlhEUFdxuBNBIRK4WkUsB/A+AeA99pjHGGGOMMR5X4gBZRO4RkQwA7QF8\nLiJfuL5+pYh8DgCqmg9gKICvAGwGMM8qWBhjjDHGmPKs3DQKMcYYY4wxpjzwcKXGiyciUSKSJiJb\nRSTa6fEEChFpICKrROQnEUkVkeFOjynQiEhFEUkWkcVOjyWQiEgNEZkvIltEZLOItHd6TIFCRJ51\nHXNSRCRORIKdHpO/EpEZIrJXRFLcvlZLRJaJSLqILBWRGk6O0V8Vse/fcB1zfhSRhSJSjKJ/5mIU\ntt/dvve0iBSISK3ivp+jAbJbI5EoAM0B9BORZk6OKYDkAXhKVVuAaTJP2r73uhFg6pHdxvGuKQAS\nVLUZgJawuuxeISJXA3gEQBtVDQe7q/Z1ckx+biZ4bnU3GsAyVW0MYIXrufG8wvb9UgAtVLUVgHQA\nz3p9VP6vsP0OEWkAIBLAjot5M6dnkE81ElHVPAAnG4mYMqaqv6vqJte/j4FBwpXOjipwiEh9AHcC\neB9FL3I1HuaatblZVWcAXCehqocdHlagOAJemFcRkSAAVcBKR6YMqOoaAAfP+nJ3AB+6/v0hgJ5e\nHVSAKGzfq+oyVS1wPV0PoL7XB+bnivh/HgAmAfjfi30/pwPkwhqJ1HNoLAHLNbPTGvyjNd4xGcAz\nAAou9ELjUQ0B7BeRmSKSJCLviUgVpwcVCFQ1C8BEADsB7AZwSFWXOzuqgBOmqntd/94LIMzJwQSw\nIQASnB5EIBCRHgAyVfX/LvZnnQ6Q7dayw0QkFMB8ACNcM8mmjInIXQD2qWoybPbY24IAtAHwb1Vt\nAyAbdpvZK0TkWgAjAVwN3q0KFZH+jg4qgClX6Ns52MtE5DkAx1U1zumx+DvX5McYADHuXy7uzzsd\nIBe7kYjxPBG5BMACAHNU9TOnxxNAOgLoLiK/AfgYQBcRmeXwmAJFJjibsMH1fD4YMJuydwOAtap6\nwFUCdCH4t2C8Z6+I1AEAEakLYJ/D4wkoIjIYTK2zC0PvuBa8IP/Rdb6tD+AHEbmiOD/sdIBsjUQc\nIiICYDqAzar6ptPjCSSqOkZVG6hqQ3CR0kpVHej0uAKBqv4OIENEGru+1BXATw4OKZCkAWgvIpVd\nx5+u4CJV4z3xAAa5/j0IgE2MeImIRIFpdT1UNcfp8QQCVU1R1TBVbeg632aCi4SLdWHoaIBsjUQc\n1QnAAAC3uUqNJbv+gI332W1O7xoG4CMR+RGsYvGKw+MJCKr6I4BZ4MTIyXzAac6NyL+JyMcA1gJo\nIiIZIvIggPEAIkUkHUAX13PjYYXs+yEA3gIQCmCZ63z7b0cH6Yfc9ntjt//n3V3UudYahRhjjDHG\nGOPG6RQLY4wxxhhjyhULkI0xxhhjjHFjAbIxxhhjjDFuLEA2xhhjjDHGjQXIxhhjjDHGuLEA2Rhj\njDHGGDcWIBtjjDHGGOPm/wFjz0EwGGsRhgAAAABJRU5ErkJggg==\n", + "text/plain": [""] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": ["train_plot_prediction(3)"] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAEaCAYAAAAMtaHPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nBNkYY4wxxpg0LEE2xhhjjDEmjf8Dhw3L+LFjwHYAAAAASUVORK5CYII=\n", + "text/plain": [""] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": ["train_plot_prediction(4)"] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAEaCAYAAAAMtaHPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\njDHGGGNMEv8PaggJNGCcLvoAAAAASUVORK5CYII=\n", + "text/plain": [""] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": ["train_plot_prediction(5)"] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAEaCAYAAAAMtaHPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nMcYYY9L4P1f5gFgUdniAAAAAAElFTkSuQmCC\n", + "text/plain": [""] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": ["train_plot_prediction(10)"] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": ["## With random forest"] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "from sklearn.ensemble import RandomForestRegressor\n", + "rf = RandomForestRegressor(n_estimators=10, max_depth=10).fit(scaler.transform(X_train), y_train)\n", + "\n", + "y_pred_rf = rf.predict(scaler.transform(x.reshape(-1, 1)))" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [""] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlwAAAEACAYAAABmuKihAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nCVwRERERHfsJJzrhQWaT1P8AAAAASUVORK5CYII=\n", + "text/plain": [""] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pl.figure(figsize=(10, 4))\n", + "pl.plot(x, y_pred_rf, c='r', label='y_pred')\n", + "pl.plot(x, y, c='b', label='y')\n", + "pl.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/server/sonar-web/src/main/js/sonar-aligned/helpers/mocks/fixtures/json/03-array-simple.json b/server/sonar-web/src/main/js/sonar-aligned/helpers/mocks/fixtures/json/03-array-simple.json new file mode 100644 index 00000000000..4af52a4a3d3 --- /dev/null +++ b/server/sonar-web/src/main/js/sonar-aligned/helpers/mocks/fixtures/json/03-array-simple.json @@ -0,0 +1,9 @@ +[[ + [], [[[]]], [], + [ + "string-in-array", + null, + 0.123e-3, + true + ] +]] diff --git a/server/sonar-web/src/main/js/sonar-aligned/helpers/mocks/fixtures/json/04-object-jupyter-notebook-oneline.json b/server/sonar-web/src/main/js/sonar-aligned/helpers/mocks/fixtures/json/04-object-jupyter-notebook-oneline.json new file mode 100644 index 00000000000..3c171a69daf --- /dev/null +++ b/server/sonar-web/src/main/js/sonar-aligned/helpers/mocks/fixtures/json/04-object-jupyter-notebook-oneline.json @@ -0,0 +1 @@ +{"cells":[{"cell_type":"markdown","id":"a35eeb9f-df70-4ab1-a243-2d2025888eb0","metadata":{},"source":["# Introduction to the JupyterLab and Jupyter Notebooks\n","\n","This is a short introduction to two of the flagship tools created by [the Jupyter Community](https://jupyter.org).\n","\n","> **⚠️Experimental!⚠️**: This is an experimental interface provided by the [JupyterLite project](https://jupyterlite.readthedocs.io/en/latest/). It embeds an entire JupyterLab interface, with many popular packages for scientific computing, in your browser. There may be minor differences in behavior between JupyterLite and the JupyterLab you install locally. You may also encounter some bugs or unexpected behavior. To report any issues, or to get involved with the JupyterLite project, see [the JupyterLite repository](https://github.com/jupyterlite/jupyterlite/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc).\n","\n","## JupyterLab 🧪\n","\n","**JupyterLab** is a next-generation web-based user interface for Project Jupyter. It enables you to work with documents and activities such as Jupyter notebooks, text editors, terminals, and custom components in a flexible, integrated, and extensible manner. It is the interface that you're looking at right now.\n","\n","**For an overview of the JupyterLab interface**, see the **JupyterLab Welcome Tour** on this page, by going to `Help -> Welcome Tour` and following the prompts.\n","\n","> **See Also**: For a more in-depth tour of JupyterLab with a full environment that runs in the cloud, see [the JupyterLab introduction on Binder](https://mybinder.org/v2/gh/jupyterlab/jupyterlab-demo/HEAD?urlpath=lab/tree/demo).\n","\n","## Jupyter Notebooks 📓\n","\n","**Jupyter Notebooks** are a community standard for communicating and performing interactive computing. They are a document that blends computations, outputs, explanatory text, mathematics, images, and rich media representations of objects.\n","\n","JupyterLab is one interface used to create and interact with Jupyter Notebooks.\n","\n","**For an overview of Jupyter Notebooks**, see the **JupyterLab Welcome Tour** on this page, by going to `Help -> Notebook Tour` and following the prompts.\n","\n","> **See Also**: For a more in-depth tour of Jupyter Notebooks and the Classic Jupyter Notebook interface, see [the Jupyter Notebook IPython tutorial on Binder](https://mybinder.org/v2/gh/ipython/ipython-in-depth/HEAD?urlpath=tree/binder/Index.ipynb).\n","\n","## An example: visualizing data in the notebook ✨\n","\n","Below is an example of a code cell. We'll visualize some simple data using two popular packages in Python. We'll use [NumPy](https://numpy.org/) to create some random data, and [Matplotlib](https://matplotlib.org) to visualize it.\n","\n","Note how the code and the results of running the code are bundled together."]},{"cell_type":"code","execution_count":1,"id":"fe55883a-6887-43dd-9498-5333a51799e2","metadata":{"trusted":true},"outputs":[{"data":{"image/png":"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","text/plain":[""]},"metadata":{},"output_type":"display_data"}],"source":["from matplotlib import pyplot as plt\n","import numpy as np\n","\n","x = None\n","if x is not None:\n"," print(x)\n","\n","# Generate 100 random data points along 3 dimensions\n","x, y, scale = np.random.randn(3, 100)\n","fig, ax = plt.subplots()\n","\n","# Map each onto a scatterplot we'll create with Matplotlib\n","ax.scatter(x=x, y=y, c=scale, s=np.abs(scale)*500)\n","ax.set(title=\"Some random data, created with JupyterLab!\")\n","plt.show()"]},{"cell_type":"markdown","id":"b9670d85-ef29-4dfd-b4b5-e76d279c1f1a","metadata":{},"source":["## Next steps 🏃\n","\n","This is just a short introduction to JupyterLab and Jupyter Notebooks. See below for some more ways to interact with tools in the Jupyter ecosystem, and its community.\n","\n","### Other notebooks in this demo\n","\n","Here are some other notebooks in this demo. Each of the items below corresponds to a file or folder in the **file browser to the left**.\n","\n","- [**`Lorenz.ipynb`**](Lorenz.ipynb) uses Python to demonstrate interactive visualizations and computations around the [Lorenz system](https://en.wikipedia.org/wiki/Lorenz_system). It shows off basic Python functionality, including more visualizations, data structures, and scientific computing libraries.\n","- [**`sqlite.ipynb`**](sqlite.ipynb) demonstrates how an in-browser sqlite kernel to run your own SQL commands from the notebook. It uses the [jupyterlite/xeus-sqlite-kernel](https://github.com/jupyterlite/xeus-sqlite-kernel).\n","\n","### Other sources of information in Jupyter\n","\n","- **More on using JupyterLab**: See [the JupyterLab documentation](https://jupyterlab.readthedocs.io/en/stable/) for more thorough information about how to install and use JupyterLab.\n","- **More interactive demos**: See [try.jupyter.org](https://try.jupyter.org) for more interactive demos with the Jupyter ecosystem.\n","- **Learn more about Jupyter**: See [the Jupyter community documentation](https://docs.jupyter.org) to learn more about the project, its community and tools, and how to get involved.\n","- **Join our discussions**: The [Jupyter Community Forum](https://discourse.jupyter.org) is a place where many in the Jupyter community ask questions, help one another, and discuss issues around interactive computing and our ecosystem."]}],"metadata":{"kernelspec":{"display_name":"Pyolite","language":"python","name":"python"},"language_info":{"codemirror_mode":{"name":"python","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.8"}},"nbformat":4,"nbformat_minor":5} \ No newline at end of file -- cgit v1.2.3