From 2b6377e45746482345649544af9fc8e92334896e Mon Sep 17 00:00:00 2001 From: Goutte Date: Wed, 19 Oct 2022 08:33:51 +0200 Subject: [PATCH 01/56] feat(gdscript): sketch implementation of gdscript target language MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This does not really work yet, but it's a start. Results are not denormalized, no support for enums nor datetimes, and thousands of other features are missing. I still don't know how we are going to denormalize JSON+LD without writing a whole GDScript lib for it… --- bin/configs/gdscript-petstore-new.yaml | 6 + .../languages/GdscriptClientCodegen.java | 203 +++++++++ .../org.openapitools.codegen.CodegenConfig | 1 + .../main/resources/gdscript/ApiBee.handlebars | 321 ++++++++++++++ .../resources/gdscript/ApiError.handlebars | 15 + .../main/resources/gdscript/README.handlebars | 37 ++ .../main/resources/gdscript/api.handlebars | 79 ++++ .../main/resources/gdscript/model.handlebars | 40 ++ .../GdscriptClientCodegenOptionsProvider.java | 72 ++++ .../gdscript/.openapi-generator-ignore | 23 + .../gdscript/.openapi-generator/FILES | 13 + .../gdscript/.openapi-generator/VERSION | 1 + samples/client/petstore/gdscript/README.md | 28 ++ .../client/petstore/gdscript/apis/PetApi.gd | 401 ++++++++++++++++++ .../client/petstore/gdscript/apis/StoreApi.gd | 195 +++++++++ .../client/petstore/gdscript/apis/UserApi.gd | 360 ++++++++++++++++ .../client/petstore/gdscript/core/ApiBee.gd | 321 ++++++++++++++ .../client/petstore/gdscript/core/ApiError.gd | 15 + .../petstore/gdscript/models/ApiResponse.gd | 33 ++ .../petstore/gdscript/models/Category.gd | 28 ++ .../client/petstore/gdscript/models/Order.gd | 49 +++ .../client/petstore/gdscript/models/Pet.gd | 51 +++ .../client/petstore/gdscript/models/Tag.gd | 28 ++ .../client/petstore/gdscript/models/User.gd | 59 +++ 24 files changed, 2379 insertions(+) create mode 100644 bin/configs/gdscript-petstore-new.yaml create mode 100644 modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java create mode 100644 modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars create mode 100644 modules/openapi-generator/src/main/resources/gdscript/ApiError.handlebars create mode 100644 modules/openapi-generator/src/main/resources/gdscript/README.handlebars create mode 100644 modules/openapi-generator/src/main/resources/gdscript/api.handlebars create mode 100644 modules/openapi-generator/src/main/resources/gdscript/model.handlebars create mode 100644 modules/openapi-generator/src/test/java/org/openapitools/codegen/options/GdscriptClientCodegenOptionsProvider.java create mode 100644 samples/client/petstore/gdscript/.openapi-generator-ignore create mode 100644 samples/client/petstore/gdscript/.openapi-generator/FILES create mode 100644 samples/client/petstore/gdscript/.openapi-generator/VERSION create mode 100644 samples/client/petstore/gdscript/README.md create mode 100644 samples/client/petstore/gdscript/apis/PetApi.gd create mode 100644 samples/client/petstore/gdscript/apis/StoreApi.gd create mode 100644 samples/client/petstore/gdscript/apis/UserApi.gd create mode 100644 samples/client/petstore/gdscript/core/ApiBee.gd create mode 100644 samples/client/petstore/gdscript/core/ApiError.gd create mode 100644 samples/client/petstore/gdscript/models/ApiResponse.gd create mode 100644 samples/client/petstore/gdscript/models/Category.gd create mode 100644 samples/client/petstore/gdscript/models/Order.gd create mode 100644 samples/client/petstore/gdscript/models/Pet.gd create mode 100644 samples/client/petstore/gdscript/models/Tag.gd create mode 100644 samples/client/petstore/gdscript/models/User.gd diff --git a/bin/configs/gdscript-petstore-new.yaml b/bin/configs/gdscript-petstore-new.yaml new file mode 100644 index 000000000000..ae90278e87b8 --- /dev/null +++ b/bin/configs/gdscript-petstore-new.yaml @@ -0,0 +1,6 @@ +generatorName: gdscript +outputDir: samples/client/petstore/gdscript +inputSpec: modules/openapi-generator/src/test/resources/3_0/petstore.yaml +templateDir: modules/openapi-generator/src/main/resources/gdscript +additionalProperties: + hideGenerationTimestamp: "true" diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java new file mode 100644 index 000000000000..889365314e9f --- /dev/null +++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java @@ -0,0 +1,203 @@ +package org.openapitools.codegen.languages; + +import io.swagger.v3.oas.models.media.Schema; +import org.openapitools.codegen.*; +//import io.swagger.models.properties.ArrayProperty; +//import io.swagger.models.properties.MapProperty; +//import io.swagger.models.properties.Property; +//import io.swagger.models.parameters.Parameter; + +import java.io.File; +import java.util.Arrays; +//import java.util.*; + +//import org.apache.commons.lang3.StringUtils; + +import org.openapitools.codegen.api.TemplatingEngineAdapter; +import org.openapitools.codegen.templating.HandlebarsEngineAdapter; +import org.openapitools.codegen.utils.ModelUtils; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class GdscriptClientCodegen extends DefaultCodegen implements CodegenConfig { + public static final String PROJECT_NAME = "projectName"; + + @SuppressWarnings("FieldCanBeLocal") + private final Logger LOGGER = LoggerFactory.getLogger(GdscriptClientCodegen.class); + + public CodegenType getTag() { + return CodegenType.CLIENT; + } + + public String getName() { + return "gdscript"; + } + + public String getHelp() { + return "Generates a GDScript client (Godot 4+)."; + } + + public GdscriptClientCodegen() { + super(); + + outputFolder = "generated-code" + File.separator + "gdscript"; + modelTemplateFiles.put("model.handlebars", ".gd"); + apiTemplateFiles.put("api.handlebars", ".gd"); + //apiTemplateFiles.put("api_base.handlebars", "plop.gd"); + + embeddedTemplateDir = templateDir = "gdscript"; + apiPackage = "apis"; + modelPackage = "models"; + + supportingFiles.add(new SupportingFile("ApiBee.handlebars", "core", "ApiBee.gd")); + supportingFiles.add(new SupportingFile("ApiError.handlebars", "core", "ApiError.gd")); + supportingFiles.add(new SupportingFile("README.handlebars", "", "README.md")); + + // Reserved keywords + // https://github.com/godotengine/godot/blob/master/modules/gdscript/gdscript_tokenizer.cpp + // FIXME + setReservedWordsLowerCase( + Arrays.asList( + // Local method names used in base API class + // FIXME: bzzzzz + + // Local variable names used in API methods (endpoints) + // FIXME +// "all_params", "resource_path", "path_params", "query_params", +// "header_params", "form_params", "local_var_files", "body_params", "auth_settings", + + // FIXME Global Scope + // https://github.com/godotengine/godot/blob/master/doc/classes/%40GlobalScope.xml + + // @property +// "property", + + // Tokens from GDScript + // https://github.com/godotengine/godot/blob/master/modules/gdscript/gdscript_tokenizer.cpp + // Logical + "and", "or", "not", + // Control flow + "if", "elif", "else", "for", "while", "break", "continue", "pass", "return", "match", + // Keywords + "as", "assert", "await", "breakpoint", "class", "class_name", "const", "enum", "extends", + "func", "in", "is", "namespace", "preload", "self", "signal", "static", "super", "trait", + "var", "void", "yield", + // Constants + "PI", "TAU", "INF", "NaN", // CONST_NAN, + // Special + "Color", // ERROR, + + // Types + "float", "int", "String", "bool", "Dictionary", "Array", "Color" + + ) + ); + + + typeMapping.clear(); + typeMapping.put("array", "Array"); + typeMapping.put("List", "Array"); + typeMapping.put("boolean", "bool"); + typeMapping.put("string", "String"); + typeMapping.put("int", "int"); + typeMapping.put("float", "float"); + typeMapping.put("number", "float"); + typeMapping.put("long", "float"); + typeMapping.put("short", "float"); + typeMapping.put("char", "String"); + typeMapping.put("double", "int"); + typeMapping.put("object", "Object"); + typeMapping.put("integer", "int"); + typeMapping.put("map", "Dictionary"); + typeMapping.put("set", "Array"); + typeMapping.put("date", "string"); + // FIXME: handle DateTime somehow + //typeMapping.put("DateTime", "Date"); + //typeMapping.put("binary", "any"); + typeMapping.put("file", "File"); + typeMapping.put("ByteArray", "Array"); + typeMapping.put("UUID", "String"); + //typeMapping.put("Error", "Error"); + //typeMapping.put("AnyType", "Variant"); + + + // TODO: add meaningful parameters + cliOptions.add(new CliOption(PROJECT_NAME, "The name of the project !!")); + + // This constructor is ran twice, because … reasons. + LOGGER.warn("THIS GENERATOR IS UNSAFE AND MALICIOUS OAS3 YAML FILES MAY HURT YOU."); + LOGGER.warn("PLEASE READ CAREFULLY THE OAS3 FILE YOU ARE USING BEFORE YOU TRUST IT."); + LOGGER.info("(this generation itself should be safe, but not the generated code)"); + + // TODO: Fill this out. + + } + + @Override + public String defaultTemplatingEngine() { + return "handlebars"; + } + + @Override + public void processOpts() { + super.processOpts(); + + // Ensure we're using the appropriate template engine, and configure it while we're at it. + // We had to use handlebars because the truthy value of mustache includes `""` and `"null"`, + // and things went south for default values and examples (but descriptions were OK, somehow) + TemplatingEngineAdapter templatingEngine = getTemplatingEngine(); + if (templatingEngine instanceof HandlebarsEngineAdapter) { + HandlebarsEngineAdapter handlebars = (HandlebarsEngineAdapter) templatingEngine; + //handlebars.infiniteLoops(true); // will we want this eventually? + handlebars.setPrettyPrint(true); // removes blank lines from flow tags + } else { + throw new RuntimeException("Only the HandlebarsEngineAdapter is supported for this generator"); + } + } + + @Override + public String escapeUnsafeCharacters(String input) { + // There might be ways to inject code in Gdscript, but I don't see any for now. + // TODO: review this with someone else + return input; + } + + @Override + public String escapeQuotationMark(String input) { + // I've seen some other targets REMOVE the quotation marks altogether. + // We might need to do that as well ? + // TODO: review this with someone else + return input + .replace("\"", "\\\"") + .replace("'", "\\'") + ; + } + + // When example is "null" (with quotes), mustache's {{#example}} triggers + // Not sure why this happens on {{#example}} but not {{#description}} + // Perhaps I'm just using mustache wrong… Anyway, it's voodoo. + // Also, even with this fix, {{#example}} still triggers. + // → That just because of how mustache works. (false or [] only) + // → I'll switch to handlebars. + // → Pebble would perhaps help reduce injections, with custom filters + // → Handlebars also has a discrepancy between description and example, both 'null' + // → We need this (hot?)fix in the end. + @Override + public String toExampleValue(Schema schema) { + if (schema.getExample() != null) { + return super.toExampleValue(schema); + } + + return ""; + } + + // → Same + @Override + public String toDefaultValue(Schema schema) { + if (schema.getDefault() != null) { + return schema.getDefault().toString(); + } + + return ""; + } +} diff --git a/modules/openapi-generator/src/main/resources/META-INF/services/org.openapitools.codegen.CodegenConfig b/modules/openapi-generator/src/main/resources/META-INF/services/org.openapitools.codegen.CodegenConfig index ba2d139af981..ea930aa38c86 100644 --- a/modules/openapi-generator/src/main/resources/META-INF/services/org.openapitools.codegen.CodegenConfig +++ b/modules/openapi-generator/src/main/resources/META-INF/services/org.openapitools.codegen.CodegenConfig @@ -32,6 +32,7 @@ org.openapitools.codegen.languages.ErlangProperCodegen org.openapitools.codegen.languages.ErlangServerCodegen org.openapitools.codegen.languages.FsharpFunctionsServerCodegen org.openapitools.codegen.languages.FsharpGiraffeServerCodegen +org.openapitools.codegen.languages.GdscriptClientCodegen org.openapitools.codegen.languages.GoClientCodegen org.openapitools.codegen.languages.GoEchoServerCodegen org.openapitools.codegen.languages.GoServerCodegen diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars new file mode 100644 index 000000000000..26b68ece3481 --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars @@ -0,0 +1,321 @@ +extends RefCounted +class_name ApiBee # We name it for now (KISS), but eventually I'd like to remove this. + + +# Base class for all generated API endpoints. +# +# Every property/method defined here may collide with userland, +# so these are all listed and excluded in our CodeGen Java file. +# We want to keep the amount of renaming to a minimum, though. +# Therefore, we use the bee_ prefix, even if awkward. + + +const DEFAULT_HOST := "localhost" +const HTTP_DEFAULT_PORT := 80 +const HTTPS_DEFAULT_PORT := 443 +const POLLING_INTERVAL_MS := 500 # milliseconds + + +# We'll probably only use this for logging +var bee_name := "ApiBee" + + +# Godot's HTTP Client we are using. +# If none was set (by you), we'll make one. +var bee_client: HTTPClient: + set(value): + bee_client = value + get: + if not bee_client: + bee_client = HTTPClient.new() + return bee_client + + +# The host to connect to, with or without the scheme. +# Eg: "gitea.com", "https://gitea.com" +# We configure TLS accordingly to the provided scheme, if any. +var bee_host := DEFAULT_HOST: + set(value): + if value.begins_with("https://"): + enable_ssl() + value = value.substr(8) # "https://".length() == 8 + elif value.begins_with("http://"): + disable_ssl() + value = value.substr(7) # "http://".length() == 7 + bee_host = value + + +# Port through which the connection will be established. +# Note: changing the host may change the port as well. +var bee_port := HTTP_DEFAULT_PORT + + +# @private +var __bee_ssl_enabled := false +var __bee_verify_host := true # only if ssl enabled + + +func enable_ssl(): + self.__bee_ssl_enabled = true + self.bee_port = HTTPS_DEFAULT_PORT + + +func disable_ssl(): + self.__bee_ssl_enabled = false + self.bee_port = HTTP_DEFAULT_PORT + + +func next_loop_iteration(): + # Use this when it works, on release (beta3 now) +# return Engine.get_main_loop().idle_frame + # For now, this works + return RenderingServer.frame_post_draw + + +func bee_connect_client_if_needed( + on_success: Callable, # func() + on_failure: Callable, # func(error: ApiError) + #finally: Callable, +): + if ( + self.bee_client.get_status() == HTTPClient.STATUS_CONNECTED + or + self.bee_client.get_status() == HTTPClient.STATUS_RESOLVING + or + self.bee_client.get_status() == HTTPClient.STATUS_CONNECTING + or + self.bee_client.get_status() == HTTPClient.STATUS_REQUESTING + or + self.bee_client.get_status() == HTTPClient.STATUS_BODY + ): + on_success.call() + + var connecting := self.bee_client.connect_to_host( + self.bee_host, self.bee_port, + self.__bee_ssl_enabled, self.__bee_verify_host + ) + if connecting != OK: + var error := ApiError.new() + error.internal_code = connecting + error.identifier = "apibee.connect_to_host.failure" + error.message = "%s: failed to connect to `%s' port %d with error %d" % [ + self.bee_name, self.bee_host, self.bee_port, connecting + ] + on_failure.call(error) + return + + # Wait until resolved and connected. + while ( + self.bee_client.get_status() == HTTPClient.STATUS_CONNECTING + or + self.bee_client.get_status() == HTTPClient.STATUS_RESOLVING + ): + self.bee_client.poll() + print("Connecting...") + if POLLING_INTERVAL_MS: + OS.delay_msec(POLLING_INTERVAL_MS) + await next_loop_iteration() + + if self.bee_client.get_status() != HTTPClient.STATUS_CONNECTED: + var error := ApiError.new() + error.internal_code = connecting + error.identifier = "apibee.connect_to_host.wrong_status" + error.message = "%s: failed to connect to `%s' port %d, with client status %d" % [ + self.bee_name, self.bee_host, self.bee_port, self.bee_client.get_status() + ] + on_failure.call(error) + return + + on_success.call() + + +# @protected +func bee_request( + method: int, # one of HTTPClient.METHOD_XXXXX + path: String, + query: Dictionary, + on_success: Callable, # func(response: Variant, responseCode: int, responseHeaders: Dictionary) + on_failure: Callable, # func(error: ApiError) +): + + bee_request_text( + method, path, query, + func(responseText, responseCode, responseHeaders): + var mime: String = responseHeaders['Mime'] + var deserializedResponse: Dictionary + var denormalizedResponse # Variant + + if "application/json" == mime: + var parser := JSON.new() + var parsing := parser.parse(responseText) + if OK != parsing: + var error := ApiError.new() + error.internal_code = parsing + error.identifier = "apibee.deserialize.cannot_parse_json" + error.message = "%s: failed to parse JSON at line %d.\n%s" % [ + self.bee_name, parser.get_error_line(), parser.get_error_message() + ] + on_failure.call(error) + return + deserializedResponse = parser.data + denormalizedResponse = deserializedResponse # FIXME + else: + var error := ApiError.new() + error.internal_code = ERR_INVALID_DATA + error.identifier = "apibee.deserialize.mime_type_unsupported" + error.message = "%s: mime type `%s' is not supported (yet)" % [ + self.bee_name, mime + ] + on_failure.call(error) + return + + on_success.call(denormalizedResponse, responseCode, responseHeaders) + , + func(error): + on_failure.call(error) + , + ) + + +# @protected +func bee_request_text( + method: int, # one of HTTPClient.METHOD_XXXXX + path: String, + query: Dictionary, + on_success: Callable, # func(responseText: String, responseCode: int, responseHeaders: Dictionary) + on_failure: Callable, # func(error: ApiError) +): + bee_connect_client_if_needed( + func(): + bee_do_request_text(method, path, query, on_success, on_failure) + , + func(error): + on_failure.call(error) + , + ) + + +# @protected +func bee_do_request_text( + method: int, # one of HTTPClient.METHOD_XXXXX + path: String, + query: Dictionary, + on_success: Callable, # func(responseText: String, responseCode: int, responseHeaders: Dictionary) + on_failure: Callable, # func(error: ApiError) +): + + # How can we help users define more / override these? + # 1. template overrides + # 2. CLI args + # 3. YAML Config file + var headers = [ + "User-Agent: Pirulo/1.0 (Godot)", + "Accept: */*", + ] + + var path_queried := path + var query_string := self.bee_client.query_string_from_dict(query) + if query_string: + path_queried = "%s?%s" % [path, query_string] + + var requesting := self.bee_client.request(method, path_queried, headers) + if requesting != OK: + var error := ApiError.new() + error.internal_code = requesting + error.identifier = "apibee.request.failure" + error.message = "%s: failed to request to path `%s'." % [ + self.bee_name, path + ] + on_failure.call(error) + return + + while self.bee_client.get_status() == HTTPClient.STATUS_REQUESTING: + # Keep polling for as long as the request is being processed. + self.bee_client.poll() + print("Requesting...") + if POLLING_INTERVAL_MS: # yeah yeah, needs work + OS.delay_msec(POLLING_INTERVAL_MS) + await next_loop_iteration() +# if OS.has_feature("web") or async: + + if not self.bee_client.has_response(): + var error := ApiError.new() + error.identifier = "apibee.request.no_response" + error.message = "%s: request to `%s' yielded no response whatsoever." % [ + self.bee_name, path + ] + on_failure.call(error) + return + + var response_code := self.bee_client.get_response_code() + var response_headers := self.bee_client.get_response_headers_as_dictionary() + # FIXME: extract from headers "Content-Type": "application/json; charset=utf-8" + # This begs for a HttpResponse class ; wait for Godot? + var encoding := "utf-8" + var mime := "application/json" + response_headers['Encoding'] = encoding + response_headers['Mime'] = mime + + prints("RESPONSE CODE:", response_code) + prints("RESPONSE HEADERS:", response_headers) + + # TODO: cap the size of this, perhaps? + var response_bytes := PackedByteArray() + + while self.bee_client.get_status() == HTTPClient.STATUS_BODY: + self.bee_client.poll() + var chunk = self.bee_client.read_response_body_chunk() + if chunk.size() == 0: # Got nothing, wait for buffers to fill a bit. + if not false: + OS.delay_usec(POLLING_INTERVAL_MS) + else: + await next_loop_iteration() + else: # Yummy data has arrived + response_bytes = response_bytes + chunk + + print("RESPONSE SIZE: %d bytes " % response_bytes.size()) + + var response_text: String + if encoding == "utf-8": + response_text = response_bytes.get_string_from_utf8() + elif encoding == "utf-16": + response_text = response_bytes.get_string_from_utf16() + elif encoding == "utf-32": + response_text = response_bytes.get_string_from_utf32() + else: + response_text = response_bytes.get_string_from_ascii() + + # Should we close ? + #self.bee_client.close() + + on_success.call(response_text, response_code, response_headers) + + +func bee_convert_http_method(method: String) -> int: + match method: + 'GET': return HTTPClient.METHOD_GET + 'POST': return HTTPClient.METHOD_POST + 'PUT': return HTTPClient.METHOD_PUT + 'PATCH': return HTTPClient.METHOD_PATCH + 'DELETE': return HTTPClient.METHOD_DELETE + 'CONNECT': return HTTPClient.METHOD_CONNECT + 'HEAD': return HTTPClient.METHOD_HEAD + 'MAX': return HTTPClient.METHOD_MAX + 'OPTIONS': return HTTPClient.METHOD_OPTIONS + 'TRACE': return HTTPClient.METHOD_TRACE + _: + printerr("%s: unknown http method `%s`, assuming GET." % [ + self.bee_name, method + ]) + return HTTPClient.METHOD_GET + + +func bee_urlize_path_param(anything) -> String: + var serialized := bee_escape_path_param(str(anything)) + return serialized + + +func bee_escape_path_param(value: String) -> String: + # TODO: escape for URL + return value + diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiError.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiError.handlebars new file mode 100644 index 000000000000..fd32f3fe04f1 --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiError.handlebars @@ -0,0 +1,15 @@ +extends Resource +class_name ApiError + +# Helps finding the error in the code, among other things. +# Could be a UUID, or even a translation key, so long as it's unique. +@export var identifier := "" + +# A message for humans. May be multiline. +@export var message := "" + +# One of Godot's ERR_XXXX when relevant +@export var internal_code := OK + +# The HTTP response code, if any. (usually >= 400) +@export var response_code := HTTPClient.RESPONSE_OK diff --git a/modules/openapi-generator/src/main/resources/gdscript/README.handlebars b/modules/openapi-generator/src/main/resources/gdscript/README.handlebars new file mode 100644 index 000000000000..b1ce51b6c189 --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/README.handlebars @@ -0,0 +1,37 @@ +# {{{projectName}}} + +{{#if appDescriptionWithNewLines}} +{{{appDescriptionWithNewLines}}} +{{/if}} + +This Godot 4 addon is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: + +- API version: {{appVersion}} +- Package version: {{packageVersion}} +{{#unless hideGenerationTimestamp}} +- Build date: {{generatedDate}} +{{/unless}} +- Build package: {{generatorClass}} +{{#if infoUrl}} +For more information, please visit [{{{infoUrl}}}]({{{infoUrl}}}). +{{/if}} + + +## Requirements. + +Godot `4.x`. + + +## Installation & Usage + +Copy the files into the `addon` directory of your Godot project. + +Then, enable the addon in your project settings. + +You can now use it anywhere in your code: + +```gdscript +# TODO +var +``` + diff --git a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars new file mode 100644 index 000000000000..1269ca463046 --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars @@ -0,0 +1,79 @@ +# API {{classname}} + +{{#with operations}} + +class {{classname}}: + extends ApiBee + +{{#each operation}} + +{{#if isDeprecated}} + # /!. DEPRECATED +{{/if}} + # Operation {{operationId}} {{httpMethod}} {{path}} +{{#if summary}} + # {{summary}} +{{/if}} +{{#if description}} + # + # {{description}} +{{/if}} +{{#if notes}} + # + # {{notes}} +{{/if}} + func {{operationIdSnakeCase}}( + {{#each allParams}} + # {{paramName}}{{#if dataType}}: {{dataType}}{{/if}}{{#if defaultValue}} = {{{defaultValue}}}{{/if}}{{#if example}} Eg: {{{example}}}{{/if}} + # {{description}} + {{paramName}}{{#if required}}{{#if dataType}}: {{{dataType}}}{{/if}}{{/if}}{{#unless required}} = {{#defaultValue}}{{{.}}}{{/defaultValue}}{{#unless defaultValue}}null{{/unless}}{{/unless}}, + {{/each}} + on_success: Callable, # func(result{{#if returnType}}: {{returnType}}{{/if}}) + on_failure: Callable # func(error: ApiError) + ): + # CollectionFormat: {{#if collectionFormat}}YES{{/if}}{{#unless collectionFormat}}NO{{/unless}} + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "{{{path}}}"{{#each pathParams}}.replace("{" + "{{baseName}}" + "}", bee_urlize_path_param({{{paramName}}})){{/each}} + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + #var bzz_query := Dictionary() + var bzz_query := { + {{#each queryParams}} + "{{baseName}}": {{paramName}}, + {{/each}} + } + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("{{httpMethod}}") + + {{#with returnProperty}} + # Will be used at some point for denormalization + # baseType = "{{{baseType}}}" + # openApiType = "{{{openApiType}}}" + # dataType = "{{{dataType}}}" + # complexType = "{{{complexType}}}" + # isArray = "{{{isArray}}}" + var bzz_return_type := "{{{baseType}}}" + {{/with}} + + bee_request( + bzz_method, bzz_path, bzz_query, + func(result, code, headers): + #print('SUCCESS!') + #print(result) + on_success.call(result) + , # ざわ‥ + func(error): + #printerr("FAILURE!") + #print(error) + on_failure.call(error) + , # ざわ‥ + ) +{{/each}} + +{{/with}} diff --git a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars new file mode 100644 index 000000000000..da64cc4a0c95 --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars @@ -0,0 +1,40 @@ +{{#each models}} +{{#with model}} +# {{classname}} +# namespace: {{modelPackage}} +# package: {{invokerPackage}} +# author: OpenAPI Generator Community +# link: https://openapi-generator.tech + +# NOTE: This class is AUTO GENERATED by OpenAPI Generator (https://openapi-generator.tech). +# Best not edit the class manually. + + +# {{classname}} Model +{{#if description}} +# {{{description}}} +{{/if}} +class {{classname}}: + extends RefCounted + class_name {{classname}} + +{{#each vars}} +{{#if deprecated}} + # /!. DEPRECATED +{{/if}} +{{#if description}} + # {{{description}}} +{{/if}} + # Type: {{dataType}} + # Required: {{#unless required}}False{{/unless}}{{#if required}}True{{/if}} +{{#if example}} + # Example: {{{example}}} +{{/if}} + var {{name}}: {{dataType}}{{#if defaultValue}} = {{{defaultValue}}}{{/if}} + + +{{/each}} + + +{{/with}} +{{/each}} \ No newline at end of file diff --git a/modules/openapi-generator/src/test/java/org/openapitools/codegen/options/GdscriptClientCodegenOptionsProvider.java b/modules/openapi-generator/src/test/java/org/openapitools/codegen/options/GdscriptClientCodegenOptionsProvider.java new file mode 100644 index 000000000000..00dc67cae542 --- /dev/null +++ b/modules/openapi-generator/src/test/java/org/openapitools/codegen/options/GdscriptClientCodegenOptionsProvider.java @@ -0,0 +1,72 @@ +package org.openapitools.codegen.options; + +import org.openapitools.codegen.CodegenConstants; +import org.openapitools.codegen.languages.GdscriptClientCodegen; + +import com.google.common.collect.ImmutableMap; +import org.openapitools.codegen.languages.PhpClientCodegen; + +import java.util.Map; + +public class GdscriptClientCodegenOptionsProvider implements OptionsProvider { + public static final String PROJECT_NAME_VALUE = "OpenAPI"; + + //These options weren't checked: + // legacyDiscriminatorBehavior, + // enumUnknownDefaultCase, + // sortModelPropertiesByRequiredFlag, + // sortParamsByRequiredFlag, + // ensureUniqueParams, + // allowUnicodeIdentifiers, + // prependFormOrBodyParameters, + // disallowAdditionalPropertiesIfNotPresent. + public static final String MODEL_PACKAGE_VALUE = "package"; + public static final String API_PACKAGE_VALUE = "apiPackage"; + public static final String SORT_PARAMS_VALUE = "false"; + public static final String SORT_MODEL_PROPERTIES_VALUE = "false"; + public static final String ENSURE_UNIQUE_PARAMS_VALUE = "true"; +// public static final String VARIABLE_NAMING_CONVENTION_VALUE = "snake_case"; + public static final String INVOKER_PACKAGE_VALUE = "OpenAPITools\\Client\\Php"; + public static final String PACKAGE_NAME_VALUE = "OpenAPIToolsClient-php"; +// public static final String SRC_BASE_PATH_VALUE = "libPhp"; + public static final String ARTIFACT_VERSION_VALUE = "1.0.0-SNAPSHOT"; + public static final String ALLOW_UNICODE_IDENTIFIERS_VALUE = "false"; + public static final String PREPEND_FORM_OR_BODY_PARAMETERS_VALUE = "true"; + public static final String ENUM_UNKNOWN_DEFAULT_CASE_VALUE = "false"; + + @Override + public String getLanguage() { + return "gdscript"; + } + + @Override + public Map createOptions() { + ImmutableMap.Builder builder = new ImmutableMap.Builder(); + return builder + .put(GdscriptClientCodegen.PROJECT_NAME, PROJECT_NAME_VALUE) + +// .put(CodegenConstants.API_PACKAGE, API_PACKAGE_VALUE) + .put(CodegenConstants.SORT_PARAMS_BY_REQUIRED_FLAG, SORT_PARAMS_VALUE) + .put(CodegenConstants.SORT_MODEL_PROPERTIES_BY_REQUIRED_FLAG, SORT_MODEL_PROPERTIES_VALUE) + .put(CodegenConstants.ENSURE_UNIQUE_PARAMS, ENSURE_UNIQUE_PARAMS_VALUE) +// .put(PhpClientCodegen.VARIABLE_NAMING_CONVENTION, VARIABLE_NAMING_CONVENTION_VALUE) +// .put(CodegenConstants.INVOKER_PACKAGE, INVOKER_PACKAGE_VALUE) +// .put(PhpClientCodegen.PACKAGE_NAME, PACKAGE_NAME_VALUE) +// .put(PhpClientCodegen.SRC_BASE_PATH, SRC_BASE_PATH_VALUE) +// .put(CodegenConstants.ARTIFACT_VERSION, ARTIFACT_VERSION_VALUE) +// .put(CodegenConstants.HIDE_GENERATION_TIMESTAMP, "true") + .put(CodegenConstants.ALLOW_UNICODE_IDENTIFIERS, ALLOW_UNICODE_IDENTIFIERS_VALUE) + .put(CodegenConstants.PREPEND_FORM_OR_BODY_PARAMETERS, PREPEND_FORM_OR_BODY_PARAMETERS_VALUE) + .put(CodegenConstants.LEGACY_DISCRIMINATOR_BEHAVIOR, "true") + .put(CodegenConstants.DISALLOW_ADDITIONAL_PROPERTIES_IF_NOT_PRESENT, "true") + .put(CodegenConstants.ENUM_UNKNOWN_DEFAULT_CASE, ENUM_UNKNOWN_DEFAULT_CASE_VALUE) + + .build(); + } + + @Override + public boolean isServer() { + return false; + } +} + diff --git a/samples/client/petstore/gdscript/.openapi-generator-ignore b/samples/client/petstore/gdscript/.openapi-generator-ignore new file mode 100644 index 000000000000..7484ee590a38 --- /dev/null +++ b/samples/client/petstore/gdscript/.openapi-generator-ignore @@ -0,0 +1,23 @@ +# OpenAPI Generator Ignore +# Generated by openapi-generator https://github.com/openapitools/openapi-generator + +# Use this file to prevent files from being overwritten by the generator. +# The patterns follow closely to .gitignore or .dockerignore. + +# As an example, the C# client generator defines ApiClient.cs. +# You can make changes and tell OpenAPI Generator to ignore just this file by uncommenting the following line: +#ApiClient.cs + +# You can match any string of characters against a directory, file or extension with a single asterisk (*): +#foo/*/qux +# The above matches foo/bar/qux and foo/baz/qux, but not foo/bar/baz/qux + +# You can recursively match patterns against a directory, file or extension with a double asterisk (**): +#foo/**/qux +# This matches foo/bar/qux, foo/baz/qux, and foo/bar/baz/qux + +# You can also negate patterns with an exclamation (!). +# For example, you can ignore all files in a docs folder with the file extension .md: +#docs/*.md +# Then explicitly reverse the ignore rule for a single file: +#!docs/README.md diff --git a/samples/client/petstore/gdscript/.openapi-generator/FILES b/samples/client/petstore/gdscript/.openapi-generator/FILES new file mode 100644 index 000000000000..4538487dd240 --- /dev/null +++ b/samples/client/petstore/gdscript/.openapi-generator/FILES @@ -0,0 +1,13 @@ +.openapi-generator-ignore +README.md +apis/PetApi.gd +apis/StoreApi.gd +apis/UserApi.gd +core/ApiBee.gd +core/ApiError.gd +models/ApiResponse.gd +models/Category.gd +models/Order.gd +models/Pet.gd +models/Tag.gd +models/User.gd diff --git a/samples/client/petstore/gdscript/.openapi-generator/VERSION b/samples/client/petstore/gdscript/.openapi-generator/VERSION new file mode 100644 index 000000000000..ed829dbcddec --- /dev/null +++ b/samples/client/petstore/gdscript/.openapi-generator/VERSION @@ -0,0 +1 @@ +6.2.1-SNAPSHOT \ No newline at end of file diff --git a/samples/client/petstore/gdscript/README.md b/samples/client/petstore/gdscript/README.md new file mode 100644 index 000000000000..cf1e83b28ba8 --- /dev/null +++ b/samples/client/petstore/gdscript/README.md @@ -0,0 +1,28 @@ +# +This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters. + +This Godot 4 addon is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: + +- API version: 1.0.0 +- Package version: +- Build package: org.openapitools.codegen.languages.GdscriptClientCodegen + + +## Requirements. + +Godot `4.x`. + + +## Installation & Usage + +Copy the files into the `addon` directory of your Godot project. + +Then, enable the addon in your project settings. + +You can now use it anywhere in your code: + +```gdscript +# TODO +var +``` + diff --git a/samples/client/petstore/gdscript/apis/PetApi.gd b/samples/client/petstore/gdscript/apis/PetApi.gd new file mode 100644 index 000000000000..dcbf449b0b39 --- /dev/null +++ b/samples/client/petstore/gdscript/apis/PetApi.gd @@ -0,0 +1,401 @@ +# API PetApi + + +class PetApi: + extends ApiBee + + + # Operation addPet POST /pet + # Add a new pet to the store + func add_pet( + # pet: Pet + # Pet object that needs to be added to the store + pet: Pet, + on_success: Callable, # func(result: Pet) + on_failure: Callable # func(error: ApiError) + ): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/pet" + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + #var bzz_query := Dictionary() + var bzz_query := { + } + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("POST") + + # Will be used at some point for denormalization + # baseType = "Pet" + # openApiType = "Pet" + # dataType = "Pet" + # complexType = "Pet" + # isArray = "false" + var bzz_return_type := "Pet" + + bee_request( + bzz_method, bzz_path, bzz_query, + func(result, code, headers): + #print('SUCCESS!') + #print(result) + on_success.call(result) + , # ざわ‥ + func(error): + #printerr("FAILURE!") + #print(error) + on_failure.call(error) + , # ざわ‥ + ) + + # Operation deletePet DELETE /pet/{petId} + # Deletes a pet + func delete_pet( + # petId: float Eg: 789 + # Pet id to delete + petId: float, + # apiKey: String Eg: apiKey_example + # + apiKey = null, + on_success: Callable, # func(result) + on_failure: Callable # func(error: ApiError) + ): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + #var bzz_query := Dictionary() + var bzz_query := { + } + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("DELETE") + + + bee_request( + bzz_method, bzz_path, bzz_query, + func(result, code, headers): + #print('SUCCESS!') + #print(result) + on_success.call(result) + , # ざわ‥ + func(error): + #printerr("FAILURE!") + #print(error) + on_failure.call(error) + , # ざわ‥ + ) + + # Operation findPetsByStatus GET /pet/findByStatus + # Finds Pets by status + # + # Multiple status values can be provided with comma separated strings + func find_pets_by_status( + # status: Array + # Status values that need to be considered for filter + status: Array, + on_success: Callable, # func(result: Array) + on_failure: Callable # func(error: ApiError) + ): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/pet/findByStatus" + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + #var bzz_query := Dictionary() + var bzz_query := { + "status": status, + } + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("GET") + + # Will be used at some point for denormalization + # baseType = "array" + # openApiType = "array" + # dataType = "Array" + # complexType = "Pet" + # isArray = "true" + var bzz_return_type := "array" + + bee_request( + bzz_method, bzz_path, bzz_query, + func(result, code, headers): + #print('SUCCESS!') + #print(result) + on_success.call(result) + , # ざわ‥ + func(error): + #printerr("FAILURE!") + #print(error) + on_failure.call(error) + , # ざわ‥ + ) + + # /!. DEPRECATED + # Operation findPetsByTags GET /pet/findByTags + # Finds Pets by tags + # + # Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing. + func find_pets_by_tags( + # tags: Array + # Tags to filter by + tags: Array, + on_success: Callable, # func(result: Array) + on_failure: Callable # func(error: ApiError) + ): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/pet/findByTags" + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + #var bzz_query := Dictionary() + var bzz_query := { + "tags": tags, + } + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("GET") + + # Will be used at some point for denormalization + # baseType = "array" + # openApiType = "array" + # dataType = "Array" + # complexType = "Pet" + # isArray = "true" + var bzz_return_type := "array" + + bee_request( + bzz_method, bzz_path, bzz_query, + func(result, code, headers): + #print('SUCCESS!') + #print(result) + on_success.call(result) + , # ざわ‥ + func(error): + #printerr("FAILURE!") + #print(error) + on_failure.call(error) + , # ざわ‥ + ) + + # Operation getPetById GET /pet/{petId} + # Find pet by ID + # + # Returns a single pet + func get_pet_by_id( + # petId: float Eg: 789 + # ID of pet to return + petId: float, + on_success: Callable, # func(result: Pet) + on_failure: Callable # func(error: ApiError) + ): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + #var bzz_query := Dictionary() + var bzz_query := { + } + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("GET") + + # Will be used at some point for denormalization + # baseType = "Pet" + # openApiType = "Pet" + # dataType = "Pet" + # complexType = "Pet" + # isArray = "false" + var bzz_return_type := "Pet" + + bee_request( + bzz_method, bzz_path, bzz_query, + func(result, code, headers): + #print('SUCCESS!') + #print(result) + on_success.call(result) + , # ざわ‥ + func(error): + #printerr("FAILURE!") + #print(error) + on_failure.call(error) + , # ざわ‥ + ) + + # Operation updatePet PUT /pet + # Update an existing pet + func update_pet( + # pet: Pet + # Pet object that needs to be added to the store + pet: Pet, + on_success: Callable, # func(result: Pet) + on_failure: Callable # func(error: ApiError) + ): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/pet" + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + #var bzz_query := Dictionary() + var bzz_query := { + } + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("PUT") + + # Will be used at some point for denormalization + # baseType = "Pet" + # openApiType = "Pet" + # dataType = "Pet" + # complexType = "Pet" + # isArray = "false" + var bzz_return_type := "Pet" + + bee_request( + bzz_method, bzz_path, bzz_query, + func(result, code, headers): + #print('SUCCESS!') + #print(result) + on_success.call(result) + , # ざわ‥ + func(error): + #printerr("FAILURE!") + #print(error) + on_failure.call(error) + , # ざわ‥ + ) + + # Operation updatePetWithForm POST /pet/{petId} + # Updates a pet in the store with form data + func update_pet_with_form( + # petId: float Eg: 789 + # ID of pet that needs to be updated + petId: float, + # name: String Eg: name_example + # Updated name of the pet + name = null, + # status: String Eg: status_example + # Updated status of the pet + status = null, + on_success: Callable, # func(result) + on_failure: Callable # func(error: ApiError) + ): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + #var bzz_query := Dictionary() + var bzz_query := { + } + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("POST") + + + bee_request( + bzz_method, bzz_path, bzz_query, + func(result, code, headers): + #print('SUCCESS!') + #print(result) + on_success.call(result) + , # ざわ‥ + func(error): + #printerr("FAILURE!") + #print(error) + on_failure.call(error) + , # ざわ‥ + ) + + # Operation uploadFile POST /pet/{petId}/uploadImage + # uploads an image + func upload_file( + # petId: float Eg: 789 + # ID of pet to update + petId: float, + # additionalMetadata: String Eg: additionalMetadata_example + # Additional data to pass to server + additionalMetadata = null, + # file: File Eg: BINARY_DATA_HERE + # file to upload + file = null, + on_success: Callable, # func(result: ApiResponse) + on_failure: Callable # func(error: ApiError) + ): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/pet/{petId}/uploadImage".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + #var bzz_query := Dictionary() + var bzz_query := { + } + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("POST") + + # Will be used at some point for denormalization + # baseType = "ApiResponse" + # openApiType = "ApiResponse" + # dataType = "ApiResponse" + # complexType = "ApiResponse" + # isArray = "false" + var bzz_return_type := "ApiResponse" + + bee_request( + bzz_method, bzz_path, bzz_query, + func(result, code, headers): + #print('SUCCESS!') + #print(result) + on_success.call(result) + , # ざわ‥ + func(error): + #printerr("FAILURE!") + #print(error) + on_failure.call(error) + , # ざわ‥ + ) + diff --git a/samples/client/petstore/gdscript/apis/StoreApi.gd b/samples/client/petstore/gdscript/apis/StoreApi.gd new file mode 100644 index 000000000000..dffb867eea73 --- /dev/null +++ b/samples/client/petstore/gdscript/apis/StoreApi.gd @@ -0,0 +1,195 @@ +# API StoreApi + + +class StoreApi: + extends ApiBee + + + # Operation deleteOrder DELETE /store/order/{orderId} + # Delete purchase order by ID + # + # For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors + func delete_order( + # orderId: String Eg: orderId_example + # ID of the order that needs to be deleted + orderId: String, + on_success: Callable, # func(result) + on_failure: Callable # func(error: ApiError) + ): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/store/order/{orderId}".replace("{" + "orderId" + "}", bee_urlize_path_param(orderId)) + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + #var bzz_query := Dictionary() + var bzz_query := { + } + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("DELETE") + + + bee_request( + bzz_method, bzz_path, bzz_query, + func(result, code, headers): + #print('SUCCESS!') + #print(result) + on_success.call(result) + , # ざわ‥ + func(error): + #printerr("FAILURE!") + #print(error) + on_failure.call(error) + , # ざわ‥ + ) + + # Operation getInventory GET /store/inventory + # Returns pet inventories by status + # + # Returns a map of status codes to quantities + func get_inventory( + on_success: Callable, # func(result: Dictionary) + on_failure: Callable # func(error: ApiError) + ): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/store/inventory" + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + #var bzz_query := Dictionary() + var bzz_query := { + } + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("GET") + + # Will be used at some point for denormalization + # baseType = "map" + # openApiType = "object" + # dataType = "Dictionary" + # complexType = "integer" + # isArray = "false" + var bzz_return_type := "map" + + bee_request( + bzz_method, bzz_path, bzz_query, + func(result, code, headers): + #print('SUCCESS!') + #print(result) + on_success.call(result) + , # ざわ‥ + func(error): + #printerr("FAILURE!") + #print(error) + on_failure.call(error) + , # ざわ‥ + ) + + # Operation getOrderById GET /store/order/{orderId} + # Find purchase order by ID + # + # For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions + func get_order_by_id( + # orderId: float Eg: 789 + # ID of pet that needs to be fetched + orderId: float, + on_success: Callable, # func(result: Order) + on_failure: Callable # func(error: ApiError) + ): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/store/order/{orderId}".replace("{" + "orderId" + "}", bee_urlize_path_param(orderId)) + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + #var bzz_query := Dictionary() + var bzz_query := { + } + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("GET") + + # Will be used at some point for denormalization + # baseType = "Order" + # openApiType = "Order" + # dataType = "Order" + # complexType = "Order" + # isArray = "false" + var bzz_return_type := "Order" + + bee_request( + bzz_method, bzz_path, bzz_query, + func(result, code, headers): + #print('SUCCESS!') + #print(result) + on_success.call(result) + , # ざわ‥ + func(error): + #printerr("FAILURE!") + #print(error) + on_failure.call(error) + , # ざわ‥ + ) + + # Operation placeOrder POST /store/order + # Place an order for a pet + func place_order( + # order: Order + # order placed for purchasing the pet + order: Order, + on_success: Callable, # func(result: Order) + on_failure: Callable # func(error: ApiError) + ): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/store/order" + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + #var bzz_query := Dictionary() + var bzz_query := { + } + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("POST") + + # Will be used at some point for denormalization + # baseType = "Order" + # openApiType = "Order" + # dataType = "Order" + # complexType = "Order" + # isArray = "false" + var bzz_return_type := "Order" + + bee_request( + bzz_method, bzz_path, bzz_query, + func(result, code, headers): + #print('SUCCESS!') + #print(result) + on_success.call(result) + , # ざわ‥ + func(error): + #printerr("FAILURE!") + #print(error) + on_failure.call(error) + , # ざわ‥ + ) + diff --git a/samples/client/petstore/gdscript/apis/UserApi.gd b/samples/client/petstore/gdscript/apis/UserApi.gd new file mode 100644 index 000000000000..915131dc06f9 --- /dev/null +++ b/samples/client/petstore/gdscript/apis/UserApi.gd @@ -0,0 +1,360 @@ +# API UserApi + + +class UserApi: + extends ApiBee + + + # Operation createUser POST /user + # Create user + # + # This can only be done by the logged in user. + func create_user( + # user: User + # Created user object + user: User, + on_success: Callable, # func(result) + on_failure: Callable # func(error: ApiError) + ): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/user" + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + #var bzz_query := Dictionary() + var bzz_query := { + } + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("POST") + + + bee_request( + bzz_method, bzz_path, bzz_query, + func(result, code, headers): + #print('SUCCESS!') + #print(result) + on_success.call(result) + , # ざわ‥ + func(error): + #printerr("FAILURE!") + #print(error) + on_failure.call(error) + , # ざわ‥ + ) + + # Operation createUsersWithArrayInput POST /user/createWithArray + # Creates list of users with given input array + func create_users_with_array_input( + # user: Array + # List of user object + user: Array, + on_success: Callable, # func(result) + on_failure: Callable # func(error: ApiError) + ): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/user/createWithArray" + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + #var bzz_query := Dictionary() + var bzz_query := { + } + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("POST") + + + bee_request( + bzz_method, bzz_path, bzz_query, + func(result, code, headers): + #print('SUCCESS!') + #print(result) + on_success.call(result) + , # ざわ‥ + func(error): + #printerr("FAILURE!") + #print(error) + on_failure.call(error) + , # ざわ‥ + ) + + # Operation createUsersWithListInput POST /user/createWithList + # Creates list of users with given input array + func create_users_with_list_input( + # user: Array + # List of user object + user: Array, + on_success: Callable, # func(result) + on_failure: Callable # func(error: ApiError) + ): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/user/createWithList" + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + #var bzz_query := Dictionary() + var bzz_query := { + } + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("POST") + + + bee_request( + bzz_method, bzz_path, bzz_query, + func(result, code, headers): + #print('SUCCESS!') + #print(result) + on_success.call(result) + , # ざわ‥ + func(error): + #printerr("FAILURE!") + #print(error) + on_failure.call(error) + , # ざわ‥ + ) + + # Operation deleteUser DELETE /user/{username} + # Delete user + # + # This can only be done by the logged in user. + func delete_user( + # username: String Eg: username_example + # The name that needs to be deleted + username: String, + on_success: Callable, # func(result) + on_failure: Callable # func(error: ApiError) + ): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + #var bzz_query := Dictionary() + var bzz_query := { + } + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("DELETE") + + + bee_request( + bzz_method, bzz_path, bzz_query, + func(result, code, headers): + #print('SUCCESS!') + #print(result) + on_success.call(result) + , # ざわ‥ + func(error): + #printerr("FAILURE!") + #print(error) + on_failure.call(error) + , # ざわ‥ + ) + + # Operation getUserByName GET /user/{username} + # Get user by user name + func get_user_by_name( + # username: String Eg: username_example + # The name that needs to be fetched. Use user1 for testing. + username: String, + on_success: Callable, # func(result: User) + on_failure: Callable # func(error: ApiError) + ): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + #var bzz_query := Dictionary() + var bzz_query := { + } + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("GET") + + # Will be used at some point for denormalization + # baseType = "User" + # openApiType = "User" + # dataType = "User" + # complexType = "User" + # isArray = "false" + var bzz_return_type := "User" + + bee_request( + bzz_method, bzz_path, bzz_query, + func(result, code, headers): + #print('SUCCESS!') + #print(result) + on_success.call(result) + , # ざわ‥ + func(error): + #printerr("FAILURE!") + #print(error) + on_failure.call(error) + , # ざわ‥ + ) + + # Operation loginUser GET /user/login + # Logs user into the system + func login_user( + # username: String Eg: username_example + # The user name for login + username: String, + # password: String Eg: password_example + # The password for login in clear text + password: String, + on_success: Callable, # func(result: String) + on_failure: Callable # func(error: ApiError) + ): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/user/login" + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + #var bzz_query := Dictionary() + var bzz_query := { + "username": username, + "password": password, + } + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("GET") + + # Will be used at some point for denormalization + # baseType = "string" + # openApiType = "string" + # dataType = "String" + # complexType = "string" + # isArray = "false" + var bzz_return_type := "string" + + bee_request( + bzz_method, bzz_path, bzz_query, + func(result, code, headers): + #print('SUCCESS!') + #print(result) + on_success.call(result) + , # ざわ‥ + func(error): + #printerr("FAILURE!") + #print(error) + on_failure.call(error) + , # ざわ‥ + ) + + # Operation logoutUser GET /user/logout + # Logs out current logged in user session + func logout_user( + on_success: Callable, # func(result) + on_failure: Callable # func(error: ApiError) + ): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/user/logout" + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + #var bzz_query := Dictionary() + var bzz_query := { + } + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("GET") + + + bee_request( + bzz_method, bzz_path, bzz_query, + func(result, code, headers): + #print('SUCCESS!') + #print(result) + on_success.call(result) + , # ざわ‥ + func(error): + #printerr("FAILURE!") + #print(error) + on_failure.call(error) + , # ざわ‥ + ) + + # Operation updateUser PUT /user/{username} + # Updated user + # + # This can only be done by the logged in user. + func update_user( + # username: String Eg: username_example + # name that need to be deleted + username: String, + # user: User + # Updated user object + user: User, + on_success: Callable, # func(result) + on_failure: Callable # func(error: ApiError) + ): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + #var bzz_query := Dictionary() + var bzz_query := { + } + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("PUT") + + + bee_request( + bzz_method, bzz_path, bzz_query, + func(result, code, headers): + #print('SUCCESS!') + #print(result) + on_success.call(result) + , # ざわ‥ + func(error): + #printerr("FAILURE!") + #print(error) + on_failure.call(error) + , # ざわ‥ + ) + diff --git a/samples/client/petstore/gdscript/core/ApiBee.gd b/samples/client/petstore/gdscript/core/ApiBee.gd new file mode 100644 index 000000000000..26b68ece3481 --- /dev/null +++ b/samples/client/petstore/gdscript/core/ApiBee.gd @@ -0,0 +1,321 @@ +extends RefCounted +class_name ApiBee # We name it for now (KISS), but eventually I'd like to remove this. + + +# Base class for all generated API endpoints. +# +# Every property/method defined here may collide with userland, +# so these are all listed and excluded in our CodeGen Java file. +# We want to keep the amount of renaming to a minimum, though. +# Therefore, we use the bee_ prefix, even if awkward. + + +const DEFAULT_HOST := "localhost" +const HTTP_DEFAULT_PORT := 80 +const HTTPS_DEFAULT_PORT := 443 +const POLLING_INTERVAL_MS := 500 # milliseconds + + +# We'll probably only use this for logging +var bee_name := "ApiBee" + + +# Godot's HTTP Client we are using. +# If none was set (by you), we'll make one. +var bee_client: HTTPClient: + set(value): + bee_client = value + get: + if not bee_client: + bee_client = HTTPClient.new() + return bee_client + + +# The host to connect to, with or without the scheme. +# Eg: "gitea.com", "https://gitea.com" +# We configure TLS accordingly to the provided scheme, if any. +var bee_host := DEFAULT_HOST: + set(value): + if value.begins_with("https://"): + enable_ssl() + value = value.substr(8) # "https://".length() == 8 + elif value.begins_with("http://"): + disable_ssl() + value = value.substr(7) # "http://".length() == 7 + bee_host = value + + +# Port through which the connection will be established. +# Note: changing the host may change the port as well. +var bee_port := HTTP_DEFAULT_PORT + + +# @private +var __bee_ssl_enabled := false +var __bee_verify_host := true # only if ssl enabled + + +func enable_ssl(): + self.__bee_ssl_enabled = true + self.bee_port = HTTPS_DEFAULT_PORT + + +func disable_ssl(): + self.__bee_ssl_enabled = false + self.bee_port = HTTP_DEFAULT_PORT + + +func next_loop_iteration(): + # Use this when it works, on release (beta3 now) +# return Engine.get_main_loop().idle_frame + # For now, this works + return RenderingServer.frame_post_draw + + +func bee_connect_client_if_needed( + on_success: Callable, # func() + on_failure: Callable, # func(error: ApiError) + #finally: Callable, +): + if ( + self.bee_client.get_status() == HTTPClient.STATUS_CONNECTED + or + self.bee_client.get_status() == HTTPClient.STATUS_RESOLVING + or + self.bee_client.get_status() == HTTPClient.STATUS_CONNECTING + or + self.bee_client.get_status() == HTTPClient.STATUS_REQUESTING + or + self.bee_client.get_status() == HTTPClient.STATUS_BODY + ): + on_success.call() + + var connecting := self.bee_client.connect_to_host( + self.bee_host, self.bee_port, + self.__bee_ssl_enabled, self.__bee_verify_host + ) + if connecting != OK: + var error := ApiError.new() + error.internal_code = connecting + error.identifier = "apibee.connect_to_host.failure" + error.message = "%s: failed to connect to `%s' port %d with error %d" % [ + self.bee_name, self.bee_host, self.bee_port, connecting + ] + on_failure.call(error) + return + + # Wait until resolved and connected. + while ( + self.bee_client.get_status() == HTTPClient.STATUS_CONNECTING + or + self.bee_client.get_status() == HTTPClient.STATUS_RESOLVING + ): + self.bee_client.poll() + print("Connecting...") + if POLLING_INTERVAL_MS: + OS.delay_msec(POLLING_INTERVAL_MS) + await next_loop_iteration() + + if self.bee_client.get_status() != HTTPClient.STATUS_CONNECTED: + var error := ApiError.new() + error.internal_code = connecting + error.identifier = "apibee.connect_to_host.wrong_status" + error.message = "%s: failed to connect to `%s' port %d, with client status %d" % [ + self.bee_name, self.bee_host, self.bee_port, self.bee_client.get_status() + ] + on_failure.call(error) + return + + on_success.call() + + +# @protected +func bee_request( + method: int, # one of HTTPClient.METHOD_XXXXX + path: String, + query: Dictionary, + on_success: Callable, # func(response: Variant, responseCode: int, responseHeaders: Dictionary) + on_failure: Callable, # func(error: ApiError) +): + + bee_request_text( + method, path, query, + func(responseText, responseCode, responseHeaders): + var mime: String = responseHeaders['Mime'] + var deserializedResponse: Dictionary + var denormalizedResponse # Variant + + if "application/json" == mime: + var parser := JSON.new() + var parsing := parser.parse(responseText) + if OK != parsing: + var error := ApiError.new() + error.internal_code = parsing + error.identifier = "apibee.deserialize.cannot_parse_json" + error.message = "%s: failed to parse JSON at line %d.\n%s" % [ + self.bee_name, parser.get_error_line(), parser.get_error_message() + ] + on_failure.call(error) + return + deserializedResponse = parser.data + denormalizedResponse = deserializedResponse # FIXME + else: + var error := ApiError.new() + error.internal_code = ERR_INVALID_DATA + error.identifier = "apibee.deserialize.mime_type_unsupported" + error.message = "%s: mime type `%s' is not supported (yet)" % [ + self.bee_name, mime + ] + on_failure.call(error) + return + + on_success.call(denormalizedResponse, responseCode, responseHeaders) + , + func(error): + on_failure.call(error) + , + ) + + +# @protected +func bee_request_text( + method: int, # one of HTTPClient.METHOD_XXXXX + path: String, + query: Dictionary, + on_success: Callable, # func(responseText: String, responseCode: int, responseHeaders: Dictionary) + on_failure: Callable, # func(error: ApiError) +): + bee_connect_client_if_needed( + func(): + bee_do_request_text(method, path, query, on_success, on_failure) + , + func(error): + on_failure.call(error) + , + ) + + +# @protected +func bee_do_request_text( + method: int, # one of HTTPClient.METHOD_XXXXX + path: String, + query: Dictionary, + on_success: Callable, # func(responseText: String, responseCode: int, responseHeaders: Dictionary) + on_failure: Callable, # func(error: ApiError) +): + + # How can we help users define more / override these? + # 1. template overrides + # 2. CLI args + # 3. YAML Config file + var headers = [ + "User-Agent: Pirulo/1.0 (Godot)", + "Accept: */*", + ] + + var path_queried := path + var query_string := self.bee_client.query_string_from_dict(query) + if query_string: + path_queried = "%s?%s" % [path, query_string] + + var requesting := self.bee_client.request(method, path_queried, headers) + if requesting != OK: + var error := ApiError.new() + error.internal_code = requesting + error.identifier = "apibee.request.failure" + error.message = "%s: failed to request to path `%s'." % [ + self.bee_name, path + ] + on_failure.call(error) + return + + while self.bee_client.get_status() == HTTPClient.STATUS_REQUESTING: + # Keep polling for as long as the request is being processed. + self.bee_client.poll() + print("Requesting...") + if POLLING_INTERVAL_MS: # yeah yeah, needs work + OS.delay_msec(POLLING_INTERVAL_MS) + await next_loop_iteration() +# if OS.has_feature("web") or async: + + if not self.bee_client.has_response(): + var error := ApiError.new() + error.identifier = "apibee.request.no_response" + error.message = "%s: request to `%s' yielded no response whatsoever." % [ + self.bee_name, path + ] + on_failure.call(error) + return + + var response_code := self.bee_client.get_response_code() + var response_headers := self.bee_client.get_response_headers_as_dictionary() + # FIXME: extract from headers "Content-Type": "application/json; charset=utf-8" + # This begs for a HttpResponse class ; wait for Godot? + var encoding := "utf-8" + var mime := "application/json" + response_headers['Encoding'] = encoding + response_headers['Mime'] = mime + + prints("RESPONSE CODE:", response_code) + prints("RESPONSE HEADERS:", response_headers) + + # TODO: cap the size of this, perhaps? + var response_bytes := PackedByteArray() + + while self.bee_client.get_status() == HTTPClient.STATUS_BODY: + self.bee_client.poll() + var chunk = self.bee_client.read_response_body_chunk() + if chunk.size() == 0: # Got nothing, wait for buffers to fill a bit. + if not false: + OS.delay_usec(POLLING_INTERVAL_MS) + else: + await next_loop_iteration() + else: # Yummy data has arrived + response_bytes = response_bytes + chunk + + print("RESPONSE SIZE: %d bytes " % response_bytes.size()) + + var response_text: String + if encoding == "utf-8": + response_text = response_bytes.get_string_from_utf8() + elif encoding == "utf-16": + response_text = response_bytes.get_string_from_utf16() + elif encoding == "utf-32": + response_text = response_bytes.get_string_from_utf32() + else: + response_text = response_bytes.get_string_from_ascii() + + # Should we close ? + #self.bee_client.close() + + on_success.call(response_text, response_code, response_headers) + + +func bee_convert_http_method(method: String) -> int: + match method: + 'GET': return HTTPClient.METHOD_GET + 'POST': return HTTPClient.METHOD_POST + 'PUT': return HTTPClient.METHOD_PUT + 'PATCH': return HTTPClient.METHOD_PATCH + 'DELETE': return HTTPClient.METHOD_DELETE + 'CONNECT': return HTTPClient.METHOD_CONNECT + 'HEAD': return HTTPClient.METHOD_HEAD + 'MAX': return HTTPClient.METHOD_MAX + 'OPTIONS': return HTTPClient.METHOD_OPTIONS + 'TRACE': return HTTPClient.METHOD_TRACE + _: + printerr("%s: unknown http method `%s`, assuming GET." % [ + self.bee_name, method + ]) + return HTTPClient.METHOD_GET + + +func bee_urlize_path_param(anything) -> String: + var serialized := bee_escape_path_param(str(anything)) + return serialized + + +func bee_escape_path_param(value: String) -> String: + # TODO: escape for URL + return value + diff --git a/samples/client/petstore/gdscript/core/ApiError.gd b/samples/client/petstore/gdscript/core/ApiError.gd new file mode 100644 index 000000000000..fd32f3fe04f1 --- /dev/null +++ b/samples/client/petstore/gdscript/core/ApiError.gd @@ -0,0 +1,15 @@ +extends Resource +class_name ApiError + +# Helps finding the error in the code, among other things. +# Could be a UUID, or even a translation key, so long as it's unique. +@export var identifier := "" + +# A message for humans. May be multiline. +@export var message := "" + +# One of Godot's ERR_XXXX when relevant +@export var internal_code := OK + +# The HTTP response code, if any. (usually >= 400) +@export var response_code := HTTPClient.RESPONSE_OK diff --git a/samples/client/petstore/gdscript/models/ApiResponse.gd b/samples/client/petstore/gdscript/models/ApiResponse.gd new file mode 100644 index 000000000000..55bf17fe8382 --- /dev/null +++ b/samples/client/petstore/gdscript/models/ApiResponse.gd @@ -0,0 +1,33 @@ +# ApiResponse +# namespace: models +# package: +# author: OpenAPI Generator Community +# link: https://openapi-generator.tech + +# NOTE: This class is AUTO GENERATED by OpenAPI Generator (https://openapi-generator.tech). +# Best not edit the class manually. + + +# ApiResponse Model +# Describes the result of uploading an image resource +class ApiResponse: + extends RefCounted + class_name ApiResponse + + # Type: int + # Required: False + var code: int + + + # Type: String + # Required: False + var type: String + + + # Type: String + # Required: False + var message: String + + + + diff --git a/samples/client/petstore/gdscript/models/Category.gd b/samples/client/petstore/gdscript/models/Category.gd new file mode 100644 index 000000000000..4187bb37a88a --- /dev/null +++ b/samples/client/petstore/gdscript/models/Category.gd @@ -0,0 +1,28 @@ +# Category +# namespace: models +# package: +# author: OpenAPI Generator Community +# link: https://openapi-generator.tech + +# NOTE: This class is AUTO GENERATED by OpenAPI Generator (https://openapi-generator.tech). +# Best not edit the class manually. + + +# Category Model +# A category for a pet +class Category: + extends RefCounted + class_name Category + + # Type: float + # Required: False + var id: float + + + # Type: String + # Required: False + var name: String + + + + diff --git a/samples/client/petstore/gdscript/models/Order.gd b/samples/client/petstore/gdscript/models/Order.gd new file mode 100644 index 000000000000..49e1f43b22c9 --- /dev/null +++ b/samples/client/petstore/gdscript/models/Order.gd @@ -0,0 +1,49 @@ +# Order +# namespace: models +# package: +# author: OpenAPI Generator Community +# link: https://openapi-generator.tech + +# NOTE: This class is AUTO GENERATED by OpenAPI Generator (https://openapi-generator.tech). +# Best not edit the class manually. + + +# Order Model +# An order for a pets from the pet store +class Order: + extends RefCounted + class_name Order + + # Type: float + # Required: False + var id: float + + + # Type: float + # Required: False + var petId: float + + + # Type: int + # Required: False + var quantity: int + + + # Type: DateTime + # Required: False + var shipDate: DateTime + + + # Order Status + # Type: String + # Required: False + var status: String + + + # Type: bool + # Required: False + var complete: bool = false + + + + diff --git a/samples/client/petstore/gdscript/models/Pet.gd b/samples/client/petstore/gdscript/models/Pet.gd new file mode 100644 index 000000000000..9bc75d87062a --- /dev/null +++ b/samples/client/petstore/gdscript/models/Pet.gd @@ -0,0 +1,51 @@ +# Pet +# namespace: models +# package: +# author: OpenAPI Generator Community +# link: https://openapi-generator.tech + +# NOTE: This class is AUTO GENERATED by OpenAPI Generator (https://openapi-generator.tech). +# Best not edit the class manually. + + +# Pet Model +# A pet for sale in the pet store +class Pet: + extends RefCounted + class_name Pet + + # Type: float + # Required: False + var id: float + + + # Type: Category + # Required: False + var category: Category + + + # Type: String + # Required: True + # Example: doggie + var name: String + + + # Type: Array + # Required: True + var photoUrls: Array + + + # Type: Array + # Required: False + var tags: Array + + + # /!. DEPRECATED + # pet status in the store + # Type: String + # Required: False + var status: String + + + + diff --git a/samples/client/petstore/gdscript/models/Tag.gd b/samples/client/petstore/gdscript/models/Tag.gd new file mode 100644 index 000000000000..e4eb666338c0 --- /dev/null +++ b/samples/client/petstore/gdscript/models/Tag.gd @@ -0,0 +1,28 @@ +# Tag +# namespace: models +# package: +# author: OpenAPI Generator Community +# link: https://openapi-generator.tech + +# NOTE: This class is AUTO GENERATED by OpenAPI Generator (https://openapi-generator.tech). +# Best not edit the class manually. + + +# Tag Model +# A tag for a pet +class Tag: + extends RefCounted + class_name Tag + + # Type: float + # Required: False + var id: float + + + # Type: String + # Required: False + var name: String + + + + diff --git a/samples/client/petstore/gdscript/models/User.gd b/samples/client/petstore/gdscript/models/User.gd new file mode 100644 index 000000000000..f1f0ce14766e --- /dev/null +++ b/samples/client/petstore/gdscript/models/User.gd @@ -0,0 +1,59 @@ +# User +# namespace: models +# package: +# author: OpenAPI Generator Community +# link: https://openapi-generator.tech + +# NOTE: This class is AUTO GENERATED by OpenAPI Generator (https://openapi-generator.tech). +# Best not edit the class manually. + + +# User Model +# A User who is purchasing from the pet store +class User: + extends RefCounted + class_name User + + # Type: float + # Required: False + var id: float + + + # Type: String + # Required: False + var username: String + + + # Type: String + # Required: False + var firstName: String + + + # Type: String + # Required: False + var lastName: String + + + # Type: String + # Required: False + var email: String + + + # Type: String + # Required: False + var password: String + + + # Type: String + # Required: False + var phone: String + + + # User Status + # Type: int + # Required: False + var userStatus: int + + + + From 5c436d36ad6a4cb8d4e2adee1b17d7e37bad4cc1 Mon Sep 17 00:00:00 2001 From: Goutte Date: Wed, 19 Oct 2022 18:36:46 +0200 Subject: [PATCH 02/56] feat: add an exhaustive list of keywords reserved in GDScript I've also provided the small python script I used to generate the list. --- .../languages/GdscriptClientCodegen.java | 160 +++++++++++++++++- .../gdscript/utils/extract_reserved_words.py | 53 ++++++ 2 files changed, 211 insertions(+), 2 deletions(-) create mode 100755 modules/openapi-generator/src/main/resources/gdscript/utils/extract_reserved_words.py diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java index 889365314e9f..b043484373ff 100644 --- a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java +++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java @@ -66,9 +66,165 @@ public GdscriptClientCodegen() { // "all_params", "resource_path", "path_params", "query_params", // "header_params", "form_params", "local_var_files", "body_params", "auth_settings", - // FIXME Global Scope + // Global Scope // https://github.com/godotengine/godot/blob/master/doc/classes/%40GlobalScope.xml - + // List generated from modules/openapi-generator/src/main/resources/gdscript/utils/extract_reserved_words.py + // Godot's global functions + "abs", "absf", "absi", "acos", "asin", "atan", "atan2", "bezier_interpolate", "bytes_to_var", + "bytes_to_var_with_objects", "ceil", "ceilf", "ceili", "clamp", "clampf", "clampi", "cos", + "cosh", "cubic_interpolate", "cubic_interpolate_angle", "cubic_interpolate_angle_in_time", + "cubic_interpolate_in_time", "db_to_linear", "deg_to_rad", "ease", "error_string", "exp", + "floor", "floorf", "floori", "fmod", "fposmod", "hash", "instance_from_id", "inverse_lerp", + "is_equal_approx", "is_finite", "is_inf", "is_instance_id_valid", "is_instance_valid", + "is_nan", "is_zero_approx", "lerp", "lerp_angle", "lerpf", "linear_to_db", "log", "max", + "maxf", "maxi", "min", "minf", "mini", "move_toward", "nearest_po2", "pingpong", "posmod", + "pow", "print", "print_rich", "print_verbose", "printerr", "printraw", "prints", "printt", + "push_error", "push_warning", "rad_to_deg", "rand_from_seed", "randf", "randf_range", + "randfn", "randi", "randi_range", "randomize", "remap", "rid_allocate_id", "rid_from_int64", + "round", "roundf", "roundi", "seed", "sign", "signf", "signi", "sin", "sinh", "smoothstep", + "snapped", "sqrt", "step_decimals", "str", "str_to_var", "tan", "tanh", "typeof", + "var_to_bytes", "var_to_bytes_with_objects", "var_to_str", "weakref", "wrap", "wrapf", + // Godot's global constants + "wrapi", "SIDE_LEFT", "SIDE_TOP", "SIDE_RIGHT", "SIDE_BOTTOM", "CORNER_TOP_LEFT", + "CORNER_TOP_RIGHT", "CORNER_BOTTOM_RIGHT", "CORNER_BOTTOM_LEFT", "VERTICAL", "HORIZONTAL", + "CLOCKWISE", "COUNTERCLOCKWISE", "HORIZONTAL_ALIGNMENT_LEFT", "HORIZONTAL_ALIGNMENT_CENTER", + "HORIZONTAL_ALIGNMENT_RIGHT", "HORIZONTAL_ALIGNMENT_FILL", "VERTICAL_ALIGNMENT_TOP", + "VERTICAL_ALIGNMENT_CENTER", "VERTICAL_ALIGNMENT_BOTTOM", "VERTICAL_ALIGNMENT_FILL", + "INLINE_ALIGNMENT_TOP_TO", "INLINE_ALIGNMENT_CENTER_TO", "INLINE_ALIGNMENT_BOTTOM_TO", + "INLINE_ALIGNMENT_TO_TOP", "INLINE_ALIGNMENT_TO_CENTER", "INLINE_ALIGNMENT_TO_BASELINE", + "INLINE_ALIGNMENT_TO_BOTTOM", "INLINE_ALIGNMENT_TOP", "INLINE_ALIGNMENT_CENTER", + "INLINE_ALIGNMENT_BOTTOM", "INLINE_ALIGNMENT_IMAGE_MASK", "INLINE_ALIGNMENT_TEXT_MASK", + "KEY_NONE", "KEY_SPECIAL", "KEY_ESCAPE", "KEY_TAB", "KEY_BACKTAB", "KEY_BACKSPACE", + "KEY_ENTER", "KEY_KP_ENTER", "KEY_INSERT", "KEY_DELETE", "KEY_PAUSE", "KEY_PRINT", + "KEY_SYSREQ", "KEY_CLEAR", "KEY_HOME", "KEY_END", "KEY_LEFT", "KEY_UP", "KEY_RIGHT", + "KEY_DOWN", "KEY_PAGEUP", "KEY_PAGEDOWN", "KEY_SHIFT", "KEY_CTRL", "KEY_META", "KEY_ALT", + "KEY_CAPSLOCK", "KEY_NUMLOCK", "KEY_SCROLLLOCK", "KEY_F1", "KEY_F2", "KEY_F3", "KEY_F4", + "KEY_F5", "KEY_F6", "KEY_F7", "KEY_F8", "KEY_F9", "KEY_F10", "KEY_F11", "KEY_F12", "KEY_F13", + "KEY_F14", "KEY_F15", "KEY_F16", "KEY_F17", "KEY_F18", "KEY_F19", "KEY_F20", "KEY_F21", + "KEY_F22", "KEY_F23", "KEY_F24", "KEY_F25", "KEY_F26", "KEY_F27", "KEY_F28", "KEY_F29", + "KEY_F30", "KEY_F31", "KEY_F32", "KEY_F33", "KEY_F34", "KEY_F35", "KEY_KP_MULTIPLY", + "KEY_KP_DIVIDE", "KEY_KP_SUBTRACT", "KEY_KP_PERIOD", "KEY_KP_ADD", "KEY_KP_0", "KEY_KP_1", + "KEY_KP_2", "KEY_KP_3", "KEY_KP_4", "KEY_KP_5", "KEY_KP_6", "KEY_KP_7", "KEY_KP_8", + "KEY_KP_9", "KEY_SUPER_L", "KEY_SUPER_R", "KEY_MENU", "KEY_HYPER_L", "KEY_HYPER_R", + "KEY_HELP", "KEY_DIRECTION_L", "KEY_DIRECTION_R", "KEY_BACK", "KEY_FORWARD", "KEY_STOP", + "KEY_REFRESH", "KEY_VOLUMEDOWN", "KEY_VOLUMEMUTE", "KEY_VOLUMEUP", "KEY_BASSBOOST", + "KEY_BASSUP", "KEY_BASSDOWN", "KEY_TREBLEUP", "KEY_TREBLEDOWN", "KEY_MEDIAPLAY", + "KEY_MEDIASTOP", "KEY_MEDIAPREVIOUS", "KEY_MEDIANEXT", "KEY_MEDIARECORD", "KEY_HOMEPAGE", + "KEY_FAVORITES", "KEY_SEARCH", "KEY_STANDBY", "KEY_OPENURL", "KEY_LAUNCHMAIL", + "KEY_LAUNCHMEDIA", "KEY_LAUNCH0", "KEY_LAUNCH1", "KEY_LAUNCH2", "KEY_LAUNCH3", "KEY_LAUNCH4", + "KEY_LAUNCH5", "KEY_LAUNCH6", "KEY_LAUNCH7", "KEY_LAUNCH8", "KEY_LAUNCH9", "KEY_LAUNCHA", + "KEY_LAUNCHB", "KEY_LAUNCHC", "KEY_LAUNCHD", "KEY_LAUNCHE", "KEY_LAUNCHF", "KEY_UNKNOWN", + "KEY_SPACE", "KEY_EXCLAM", "KEY_QUOTEDBL", "KEY_NUMBERSIGN", "KEY_DOLLAR", "KEY_PERCENT", + "KEY_AMPERSAND", "KEY_APOSTROPHE", "KEY_PARENLEFT", "KEY_PARENRIGHT", "KEY_ASTERISK", + "KEY_PLUS", "KEY_COMMA", "KEY_MINUS", "KEY_PERIOD", "KEY_SLASH", "KEY_0", "KEY_1", "KEY_2", + "KEY_3", "KEY_4", "KEY_5", "KEY_6", "KEY_7", "KEY_8", "KEY_9", "KEY_COLON", "KEY_SEMICOLON", + "KEY_LESS", "KEY_EQUAL", "KEY_GREATER", "KEY_QUESTION", "KEY_AT", "KEY_A", "KEY_B", "KEY_C", + "KEY_D", "KEY_E", "KEY_F", "KEY_G", "KEY_H", "KEY_I", "KEY_J", "KEY_K", "KEY_L", "KEY_M", + "KEY_N", "KEY_O", "KEY_P", "KEY_Q", "KEY_R", "KEY_S", "KEY_T", "KEY_U", "KEY_V", "KEY_W", + "KEY_X", "KEY_Y", "KEY_Z", "KEY_BRACKETLEFT", "KEY_BACKSLASH", "KEY_BRACKETRIGHT", + "KEY_ASCIICIRCUM", "KEY_UNDERSCORE", "KEY_QUOTELEFT", "KEY_BRACELEFT", "KEY_BAR", + "KEY_BRACERIGHT", "KEY_ASCIITILDE", "KEY_NOBREAKSPACE", "KEY_EXCLAMDOWN", "KEY_CENT", + "KEY_STERLING", "KEY_CURRENCY", "KEY_YEN", "KEY_BROKENBAR", "KEY_SECTION", "KEY_DIAERESIS", + "KEY_COPYRIGHT", "KEY_ORDFEMININE", "KEY_GUILLEMOTLEFT", "KEY_NOTSIGN", "KEY_HYPHEN", + "KEY_REGISTERED", "KEY_MACRON", "KEY_DEGREE", "KEY_PLUSMINUS", "KEY_TWOSUPERIOR", + "KEY_THREESUPERIOR", "KEY_ACUTE", "KEY_MU", "KEY_PARAGRAPH", "KEY_PERIODCENTERED", + "KEY_CEDILLA", "KEY_ONESUPERIOR", "KEY_MASCULINE", "KEY_GUILLEMOTRIGHT", "KEY_ONEQUARTER", + "KEY_ONEHALF", "KEY_THREEQUARTERS", "KEY_QUESTIONDOWN", "KEY_AGRAVE", "KEY_AACUTE", + "KEY_ACIRCUMFLEX", "KEY_ATILDE", "KEY_ADIAERESIS", "KEY_ARING", "KEY_AE", "KEY_CCEDILLA", + "KEY_EGRAVE", "KEY_EACUTE", "KEY_ECIRCUMFLEX", "KEY_EDIAERESIS", "KEY_IGRAVE", "KEY_IACUTE", + "KEY_ICIRCUMFLEX", "KEY_IDIAERESIS", "KEY_ETH", "KEY_NTILDE", "KEY_OGRAVE", "KEY_OACUTE", + "KEY_OCIRCUMFLEX", "KEY_OTILDE", "KEY_ODIAERESIS", "KEY_MULTIPLY", "KEY_OOBLIQUE", + "KEY_UGRAVE", "KEY_UACUTE", "KEY_UCIRCUMFLEX", "KEY_UDIAERESIS", "KEY_YACUTE", "KEY_THORN", + "KEY_SSHARP", "KEY_DIVISION", "KEY_YDIAERESIS", "KEY_CODE_MASK", "KEY_MODIFIER_MASK", + "KEY_MASK_CMD_OR_CTRL", "KEY_MASK_SHIFT", "KEY_MASK_ALT", "KEY_MASK_META", "KEY_MASK_CTRL", + "KEY_MASK_KPAD", "KEY_MASK_GROUP_SWITCH", "MOUSE_BUTTON_NONE", "MOUSE_BUTTON_LEFT", + "MOUSE_BUTTON_RIGHT", "MOUSE_BUTTON_MIDDLE", "MOUSE_BUTTON_WHEEL_UP", + "MOUSE_BUTTON_WHEEL_DOWN", "MOUSE_BUTTON_WHEEL_LEFT", "MOUSE_BUTTON_WHEEL_RIGHT", + "MOUSE_BUTTON_XBUTTON1", "MOUSE_BUTTON_XBUTTON2", "MOUSE_BUTTON_MASK_LEFT", + "MOUSE_BUTTON_MASK_RIGHT", "MOUSE_BUTTON_MASK_MIDDLE", "MOUSE_BUTTON_MASK_XBUTTON1", + "MOUSE_BUTTON_MASK_XBUTTON2", "JOY_BUTTON_INVALID", "JOY_BUTTON_A", "JOY_BUTTON_B", + "JOY_BUTTON_X", "JOY_BUTTON_Y", "JOY_BUTTON_BACK", "JOY_BUTTON_GUIDE", "JOY_BUTTON_START", + "JOY_BUTTON_LEFT_STICK", "JOY_BUTTON_RIGHT_STICK", "JOY_BUTTON_LEFT_SHOULDER", + "JOY_BUTTON_RIGHT_SHOULDER", "JOY_BUTTON_DPAD_UP", "JOY_BUTTON_DPAD_DOWN", + "JOY_BUTTON_DPAD_LEFT", "JOY_BUTTON_DPAD_RIGHT", "JOY_BUTTON_MISC1", "JOY_BUTTON_PADDLE1", + "JOY_BUTTON_PADDLE2", "JOY_BUTTON_PADDLE3", "JOY_BUTTON_PADDLE4", "JOY_BUTTON_TOUCHPAD", + "JOY_BUTTON_SDL_MAX", "JOY_BUTTON_MAX", "JOY_AXIS_INVALID", "JOY_AXIS_LEFT_X", + "JOY_AXIS_LEFT_Y", "JOY_AXIS_RIGHT_X", "JOY_AXIS_RIGHT_Y", "JOY_AXIS_TRIGGER_LEFT", + "JOY_AXIS_TRIGGER_RIGHT", "JOY_AXIS_SDL_MAX", "JOY_AXIS_MAX", "MIDI_MESSAGE_NONE", + "MIDI_MESSAGE_NOTE_OFF", "MIDI_MESSAGE_NOTE_ON", "MIDI_MESSAGE_AFTERTOUCH", + "MIDI_MESSAGE_CONTROL_CHANGE", "MIDI_MESSAGE_PROGRAM_CHANGE", "MIDI_MESSAGE_CHANNEL_PRESSURE", + "MIDI_MESSAGE_PITCH_BEND", "MIDI_MESSAGE_SYSTEM_EXCLUSIVE", "MIDI_MESSAGE_QUARTER_FRAME", + "MIDI_MESSAGE_SONG_POSITION_POINTER", "MIDI_MESSAGE_SONG_SELECT", "MIDI_MESSAGE_TUNE_REQUEST", + "MIDI_MESSAGE_TIMING_CLOCK", "MIDI_MESSAGE_START", "MIDI_MESSAGE_CONTINUE", + "MIDI_MESSAGE_STOP", "MIDI_MESSAGE_ACTIVE_SENSING", "MIDI_MESSAGE_SYSTEM_RESET", "OK", + "FAILED", "ERR_UNAVAILABLE", "ERR_UNCONFIGURED", "ERR_UNAUTHORIZED", + "ERR_PARAMETER_RANGE_ERROR", "ERR_OUT_OF_MEMORY", "ERR_FILE_NOT_FOUND", "ERR_FILE_BAD_DRIVE", + "ERR_FILE_BAD_PATH", "ERR_FILE_NO_PERMISSION", "ERR_FILE_ALREADY_IN_USE", + "ERR_FILE_CANT_OPEN", "ERR_FILE_CANT_WRITE", "ERR_FILE_CANT_READ", "ERR_FILE_UNRECOGNIZED", + "ERR_FILE_CORRUPT", "ERR_FILE_MISSING_DEPENDENCIES", "ERR_FILE_EOF", "ERR_CANT_OPEN", + "ERR_CANT_CREATE", "ERR_QUERY_FAILED", "ERR_ALREADY_IN_USE", "ERR_LOCKED", "ERR_TIMEOUT", + "ERR_CANT_CONNECT", "ERR_CANT_RESOLVE", "ERR_CONNECTION_ERROR", "ERR_CANT_ACQUIRE_RESOURCE", + "ERR_CANT_FORK", "ERR_INVALID_DATA", "ERR_INVALID_PARAMETER", "ERR_ALREADY_EXISTS", + "ERR_DOES_NOT_EXIST", "ERR_DATABASE_CANT_READ", "ERR_DATABASE_CANT_WRITE", + "ERR_COMPILATION_FAILED", "ERR_METHOD_NOT_FOUND", "ERR_LINK_FAILED", "ERR_SCRIPT_FAILED", + "ERR_CYCLIC_LINK", "ERR_INVALID_DECLARATION", "ERR_DUPLICATE_SYMBOL", "ERR_PARSE_ERROR", + "ERR_BUSY", "ERR_SKIP", "ERR_HELP", "ERR_BUG", "ERR_PRINTER_ON_FIRE", "PROPERTY_HINT_NONE", + "PROPERTY_HINT_RANGE", "PROPERTY_HINT_ENUM", "PROPERTY_HINT_ENUM_SUGGESTION", + "PROPERTY_HINT_EXP_EASING", "PROPERTY_HINT_LINK", "PROPERTY_HINT_FLAGS", + "PROPERTY_HINT_LAYERS_2D_RENDER", "PROPERTY_HINT_LAYERS_2D_PHYSICS", + "PROPERTY_HINT_LAYERS_2D_NAVIGATION", "PROPERTY_HINT_LAYERS_3D_RENDER", + "PROPERTY_HINT_LAYERS_3D_PHYSICS", "PROPERTY_HINT_LAYERS_3D_NAVIGATION", "PROPERTY_HINT_FILE", + "PROPERTY_HINT_DIR", "PROPERTY_HINT_GLOBAL_FILE", "PROPERTY_HINT_GLOBAL_DIR", + "PROPERTY_HINT_RESOURCE_TYPE", "PROPERTY_HINT_MULTILINE_TEXT", "PROPERTY_HINT_EXPRESSION", + "PROPERTY_HINT_PLACEHOLDER_TEXT", "PROPERTY_HINT_COLOR_NO_ALPHA", + "PROPERTY_HINT_IMAGE_COMPRESS_LOSSY", "PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS", + "PROPERTY_HINT_OBJECT_ID", "PROPERTY_HINT_TYPE_STRING", + "PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE", "PROPERTY_HINT_METHOD_OF_VARIANT_TYPE", + "PROPERTY_HINT_METHOD_OF_BASE_TYPE", "PROPERTY_HINT_METHOD_OF_INSTANCE", + "PROPERTY_HINT_METHOD_OF_SCRIPT", "PROPERTY_HINT_PROPERTY_OF_VARIANT_TYPE", + "PROPERTY_HINT_PROPERTY_OF_BASE_TYPE", "PROPERTY_HINT_PROPERTY_OF_INSTANCE", + "PROPERTY_HINT_PROPERTY_OF_SCRIPT", "PROPERTY_HINT_OBJECT_TOO_BIG", + "PROPERTY_HINT_NODE_PATH_VALID_TYPES", "PROPERTY_HINT_SAVE_FILE", + "PROPERTY_HINT_GLOBAL_SAVE_FILE", "PROPERTY_HINT_INT_IS_OBJECTID", + "PROPERTY_HINT_INT_IS_POINTER", "PROPERTY_HINT_ARRAY_TYPE", "PROPERTY_HINT_LOCALE_ID", + "PROPERTY_HINT_LOCALIZABLE_STRING", "PROPERTY_HINT_NODE_TYPE", + "PROPERTY_HINT_HIDE_QUATERNION_EDIT", "PROPERTY_HINT_PASSWORD", "PROPERTY_HINT_MAX", + "PROPERTY_USAGE_NONE", "PROPERTY_USAGE_STORAGE", "PROPERTY_USAGE_EDITOR", + "PROPERTY_USAGE_CHECKABLE", "PROPERTY_USAGE_CHECKED", "PROPERTY_USAGE_INTERNATIONALIZED", + "PROPERTY_USAGE_GROUP", "PROPERTY_USAGE_CATEGORY", "PROPERTY_USAGE_SUBGROUP", + "PROPERTY_USAGE_CLASS_IS_BITFIELD", "PROPERTY_USAGE_NO_INSTANCE_STATE", + "PROPERTY_USAGE_RESTART_IF_CHANGED", "PROPERTY_USAGE_SCRIPT_VARIABLE", + "PROPERTY_USAGE_STORE_IF_NULL", "PROPERTY_USAGE_ANIMATE_AS_TRIGGER", + "PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED", "PROPERTY_USAGE_SCRIPT_DEFAULT_VALUE", + "PROPERTY_USAGE_CLASS_IS_ENUM", "PROPERTY_USAGE_NIL_IS_VARIANT", "PROPERTY_USAGE_INTERNAL", + "PROPERTY_USAGE_DO_NOT_SHARE_ON_DUPLICATE", "PROPERTY_USAGE_HIGH_END_GFX", + "PROPERTY_USAGE_NODE_PATH_FROM_SCENE_ROOT", "PROPERTY_USAGE_RESOURCE_NOT_PERSISTENT", + "PROPERTY_USAGE_KEYING_INCREMENTS", "PROPERTY_USAGE_DEFERRED_SET_RESOURCE", + "PROPERTY_USAGE_EDITOR_INSTANTIATE_OBJECT", "PROPERTY_USAGE_EDITOR_BASIC_SETTING", + "PROPERTY_USAGE_READ_ONLY", "PROPERTY_USAGE_ARRAY", "PROPERTY_USAGE_DEFAULT", + "PROPERTY_USAGE_DEFAULT_INTL", "PROPERTY_USAGE_NO_EDITOR", "METHOD_FLAG_NORMAL", + "METHOD_FLAG_EDITOR", "METHOD_FLAG_CONST", "METHOD_FLAG_VIRTUAL", "METHOD_FLAG_VARARG", + "METHOD_FLAG_STATIC", "METHOD_FLAG_OBJECT_CORE", "METHOD_FLAGS_DEFAULT", "TYPE_NIL", + "TYPE_BOOL", "TYPE_INT", "TYPE_FLOAT", "TYPE_STRING", "TYPE_VECTOR2", "TYPE_VECTOR2I", + "TYPE_RECT2", "TYPE_RECT2I", "TYPE_VECTOR3", "TYPE_VECTOR3I", "TYPE_TRANSFORM2D", + "TYPE_VECTOR4", "TYPE_VECTOR4I", "TYPE_PLANE", "TYPE_QUATERNION", "TYPE_AABB", "TYPE_BASIS", + "TYPE_TRANSFORM3D", "TYPE_PROJECTION", "TYPE_COLOR", "TYPE_STRING_NAME", "TYPE_NODE_PATH", + "TYPE_RID", "TYPE_OBJECT", "TYPE_CALLABLE", "TYPE_SIGNAL", "TYPE_DICTIONARY", "TYPE_ARRAY", + "TYPE_PACKED_BYTE_ARRAY", "TYPE_PACKED_INT32_ARRAY", "TYPE_PACKED_INT64_ARRAY", + "TYPE_PACKED_FLOAT32_ARRAY", "TYPE_PACKED_FLOAT64_ARRAY", "TYPE_PACKED_STRING_ARRAY", + "TYPE_PACKED_VECTOR2_ARRAY", "TYPE_PACKED_VECTOR3_ARRAY", "TYPE_PACKED_COLOR_ARRAY", + "TYPE_MAX", "OP_EQUAL", "OP_NOT_EQUAL", "OP_LESS", "OP_LESS_EQUAL", "OP_GREATER", + "OP_GREATER_EQUAL", "OP_ADD", "OP_SUBTRACT", "OP_MULTIPLY", "OP_DIVIDE", "OP_NEGATE", + "OP_POSITIVE", "OP_MODULE", "OP_POWER", "OP_SHIFT_LEFT", "OP_SHIFT_RIGHT", "OP_BIT_AND", + "OP_BIT_OR", "OP_BIT_XOR", "OP_BIT_NEGATE", "OP_AND", "OP_OR", "OP_XOR", "OP_NOT", "OP_IN", + // Godot's singletons + "OP_MAX", "AudioServer", "CameraServer", "ClassDB", "DisplayServer", "Engine", + "EngineDebugger", "Geometry2D", "Geometry3D", "GodotSharp", "IP", "Input", "InputMap", + "JavaClassWrapper", "JavaScriptBridge", "Marshalls", "NativeExtensionManager", + "NavigationMeshGenerator", "NavigationServer2D", "NavigationServer3D", "OS", "Performance", + "PhysicsServer2D", "PhysicsServer2DManager", "PhysicsServer3D", "PhysicsServer3DManager", + "ProjectSettings", "RenderingServer", "ResourceLoader", "ResourceSaver", "ResourceUID", + "TextServerManager", "ThemeDB", "Time", "TranslationServer", "WorkerThreadPool", "XRServer", // @property // "property", diff --git a/modules/openapi-generator/src/main/resources/gdscript/utils/extract_reserved_words.py b/modules/openapi-generator/src/main/resources/gdscript/utils/extract_reserved_words.py new file mode 100755 index 000000000000..27f6743a3596 --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/utils/extract_reserved_words.py @@ -0,0 +1,53 @@ +#!/bin/env python + +# Generates and prints a list of reserved words in Godot + +import xml.etree.ElementTree as ET +import requests +import xml + +words_code = "" # output +indentation = " " +max_line_len = 119 +url = "https://raw.githubusercontent.com/godotengine/godot/master/doc/classes/%40GlobalScope.xml" + +xml_string = requests.get(url).content +root = ET.fromstring(xml_string) + +methods_list = [] # of string +constants_list = [] # of string +singletons_list = [] # of string + +for method in root.iter('method'): + methods_list.append(method.attrib['name']) +for constant in root.iter('constant'): + constants_list.append(constant.attrib['name']) +for singleton in root.iter('member'): + singletons_list.append(singleton.attrib['name']) + +words_code += "%s// List generated from modules/openapi-generator/src/main/resources/gdscript/utils/extract_reserved_words.py\n" % indentation + +current_line = "%s" % indentation + +def add_word(word): + global current_line, words_code + words_string = "\"%s\", " % word + if len(current_line) + len(words_string) > max_line_len: + words_code += "%s\n" % current_line + current_line = "%s" % indentation + current_line += words_string + + +words_code += "%s// Godot's global functions\n" % indentation +for reserved in methods_list: + add_word(reserved) +words_code += "%s// Godot's global constants\n" % indentation +for reserved in constants_list: + add_word(reserved) +words_code += "%s// Godot's singletons\n" % indentation +for reserved in singletons_list: + add_word(reserved) + +words_code += "%s\n" % current_line + +print(words_code) \ No newline at end of file From a4924caf8dfea62ae0de2691200da866ba788b15 Mon Sep 17 00:00:00 2001 From: Goutte Date: Wed, 19 Oct 2022 21:34:48 +0200 Subject: [PATCH 03/56] refacto(gdscript): start using partials in templates MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Whilst I'm racking my brains trying to figure out integration testing… --- ...tstore-new.yaml => gdscript-petstore.yaml} | 0 .../languages/GdscriptClientCodegen.java | 32 +++++----- .../main/resources/gdscript/ApiBee.handlebars | 16 ++--- .../main/resources/gdscript/api.handlebars | 28 ++++----- .../resources/gdscript/partials/README.md | 7 +++ .../gdscript/partials/api_headers.handlebars | 1 + .../partials/api_statement_class.handlebars | 1 + .../partials/api_statement_extends.handlebars | 1 + .../disclaimer_autogenerated.handlebars | 3 + .../main/resources/gdscript/utils/README.md | 5 ++ .../gdscript/utils/extract_reserved_words.py | 19 ++++-- .../gdscript/.openapi-generator/FILES | 1 - .../client/petstore/gdscript/apis/PetApi.gd | 59 +++++++------------ .../client/petstore/gdscript/apis/StoreApi.gd | 31 ++++------ .../client/petstore/gdscript/apis/UserApi.gd | 59 +++++++------------ .../client/petstore/gdscript/core/ApiBee.gd | 16 ++--- 16 files changed, 131 insertions(+), 148 deletions(-) rename bin/configs/{gdscript-petstore-new.yaml => gdscript-petstore.yaml} (100%) create mode 100644 modules/openapi-generator/src/main/resources/gdscript/partials/README.md create mode 100644 modules/openapi-generator/src/main/resources/gdscript/partials/api_headers.handlebars create mode 100644 modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_class.handlebars create mode 100644 modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_extends.handlebars create mode 100644 modules/openapi-generator/src/main/resources/gdscript/partials/disclaimer_autogenerated.handlebars create mode 100644 modules/openapi-generator/src/main/resources/gdscript/utils/README.md diff --git a/bin/configs/gdscript-petstore-new.yaml b/bin/configs/gdscript-petstore.yaml similarity index 100% rename from bin/configs/gdscript-petstore-new.yaml rename to bin/configs/gdscript-petstore.yaml diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java index b043484373ff..a57138f6d6b4 100644 --- a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java +++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java @@ -43,7 +43,6 @@ public GdscriptClientCodegen() { outputFolder = "generated-code" + File.separator + "gdscript"; modelTemplateFiles.put("model.handlebars", ".gd"); apiTemplateFiles.put("api.handlebars", ".gd"); - //apiTemplateFiles.put("api_base.handlebars", "plop.gd"); embeddedTemplateDir = templateDir = "gdscript"; apiPackage = "apis"; @@ -59,14 +58,17 @@ public GdscriptClientCodegen() { setReservedWordsLowerCase( Arrays.asList( // Local method names used in base API class - // FIXME: bzzzzz - + "bee_connect_client_if_needed", "bee_request", "bee_request_text", "bee_do_request_text", + "bee_convert_http_method", "bee_urlize_path_param", "bee_escape_path_param", + "bee_next_loop_iteration", "bee_enable_ssl", "bee_disable_ssl", + // Local properties used in base API class + "bee_client", "bee_host", "bee_port", "bee_name", // Local variable names used in API methods (endpoints) - // FIXME -// "all_params", "resource_path", "path_params", "query_params", -// "header_params", "form_params", "local_var_files", "body_params", "auth_settings", + "bzz_method", "bzz_path", "bzz_query", + "bzz_result", "bzz_code", "bzz_headers", + "bzz_error", - // Global Scope + // Godot's Global Scope // https://github.com/godotengine/godot/blob/master/doc/classes/%40GlobalScope.xml // List generated from modules/openapi-generator/src/main/resources/gdscript/utils/extract_reserved_words.py // Godot's global functions @@ -225,8 +227,6 @@ public GdscriptClientCodegen() { "PhysicsServer2D", "PhysicsServer2DManager", "PhysicsServer3D", "PhysicsServer3DManager", "ProjectSettings", "RenderingServer", "ResourceLoader", "ResourceSaver", "ResourceUID", "TextServerManager", "ThemeDB", "Time", "TranslationServer", "WorkerThreadPool", "XRServer", - // @property -// "property", // Tokens from GDScript // https://github.com/godotengine/godot/blob/master/modules/gdscript/gdscript_tokenizer.cpp @@ -234,18 +234,16 @@ public GdscriptClientCodegen() { "and", "or", "not", // Control flow "if", "elif", "else", "for", "while", "break", "continue", "pass", "return", "match", - // Keywords + // Keywords – hey, namespace is here, and so is trait ! "as", "assert", "await", "breakpoint", "class", "class_name", "const", "enum", "extends", "func", "in", "is", "namespace", "preload", "self", "signal", "static", "super", "trait", "var", "void", "yield", // Constants - "PI", "TAU", "INF", "NaN", // CONST_NAN, - // Special - "Color", // ERROR, - - // Types - "float", "int", "String", "bool", "Dictionary", "Array", "Color" + "PI", "TAU", "INF", "NaN", + // Types TODO: extract all types from somewhere ; we're going to need all the Nodes, as well ?! + "float", "int", "String", "bool", "Dictionary", "Array", "Color", + "Quat", "Vector2", "Vector3", "Transform" ) ); @@ -285,8 +283,6 @@ public GdscriptClientCodegen() { LOGGER.warn("PLEASE READ CAREFULLY THE OAS3 FILE YOU ARE USING BEFORE YOU TRUST IT."); LOGGER.info("(this generation itself should be safe, but not the generated code)"); - // TODO: Fill this out. - } @Override diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars index 26b68ece3481..f6b434c3bf80 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars @@ -37,10 +37,10 @@ var bee_client: HTTPClient: var bee_host := DEFAULT_HOST: set(value): if value.begins_with("https://"): - enable_ssl() + bee_enable_ssl() value = value.substr(8) # "https://".length() == 8 elif value.begins_with("http://"): - disable_ssl() + bee_disable_ssl() value = value.substr(7) # "http://".length() == 7 bee_host = value @@ -55,17 +55,17 @@ var __bee_ssl_enabled := false var __bee_verify_host := true # only if ssl enabled -func enable_ssl(): +func bee_enable_ssl(): self.__bee_ssl_enabled = true self.bee_port = HTTPS_DEFAULT_PORT -func disable_ssl(): +func bee_disable_ssl(): self.__bee_ssl_enabled = false self.bee_port = HTTP_DEFAULT_PORT -func next_loop_iteration(): +func bee_next_loop_iteration(): # Use this when it works, on release (beta3 now) # return Engine.get_main_loop().idle_frame # For now, this works @@ -114,7 +114,7 @@ func bee_connect_client_if_needed( print("Connecting...") if POLLING_INTERVAL_MS: OS.delay_msec(POLLING_INTERVAL_MS) - await next_loop_iteration() + await bee_next_loop_iteration() if self.bee_client.get_status() != HTTPClient.STATUS_CONNECTED: var error := ApiError.new() @@ -235,7 +235,7 @@ func bee_do_request_text( print("Requesting...") if POLLING_INTERVAL_MS: # yeah yeah, needs work OS.delay_msec(POLLING_INTERVAL_MS) - await next_loop_iteration() + await bee_next_loop_iteration() # if OS.has_feature("web") or async: if not self.bee_client.has_response(): @@ -269,7 +269,7 @@ func bee_do_request_text( if not false: OS.delay_usec(POLLING_INTERVAL_MS) else: - await next_loop_iteration() + await bee_next_loop_iteration() else: # Yummy data has arrived response_bytes = response_bytes + chunk diff --git a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars index 1269ca463046..3d3d4adeedb4 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars @@ -1,16 +1,16 @@ +{{>partials/api_headers}} + # API {{classname}} +{{>partials/api_statement_class}}: + {{>partials/api_statement_extends}} {{#with operations}} - -class {{classname}}: - extends ApiBee - {{#each operation}} {{#if isDeprecated}} # /!. DEPRECATED {{/if}} - # Operation {{operationId}} {{httpMethod}} {{path}} + # Operation {{operationId}} → {{httpMethod}} {{path}} {{#if summary}} # {{summary}} {{/if}} @@ -41,12 +41,10 @@ class {{classname}}: # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays - #var bzz_query := Dictionary() - var bzz_query := { + var bzz_query := Dictionary() {{#each queryParams}} - "{{baseName}}": {{paramName}}, + bzz_query["{{baseName}}"] = {{paramName}} {{/each}} - } # Convert the HTTP method to something Godot understands var bzz_method := bee_convert_http_method("{{httpMethod}}") @@ -63,15 +61,15 @@ class {{classname}}: bee_request( bzz_method, bzz_path, bzz_query, - func(result, code, headers): + func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') - #print(result) - on_success.call(result) + #print(bzz_result) + on_success.call(bzz_result) , # ざわ‥ - func(error): + func(bzz_error): #printerr("FAILURE!") - #print(error) - on_failure.call(error) + #print(bzz_error) + on_failure.call(bzz_error) , # ざわ‥ ) {{/each}} diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/README.md b/modules/openapi-generator/src/main/resources/gdscript/partials/README.md new file mode 100644 index 000000000000..357f1f179173 --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/README.md @@ -0,0 +1,7 @@ +**Partials** are bits of code that we reuse through templates, +or use once but provide anyway in order to make template customization easier. + +For example, if you only want to change the base class of API classes, +you may override `api_statement_extends.handlebars` in this directory. + +> _May the fork be with you, always._ diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/api_headers.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/api_headers.handlebars new file mode 100644 index 000000000000..7949f58a71ba --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/api_headers.handlebars @@ -0,0 +1 @@ +{{>partials/disclaimer_autogenerated}} \ No newline at end of file diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_class.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_class.handlebars new file mode 100644 index 000000000000..5c3f55515a9e --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_class.handlebars @@ -0,0 +1 @@ +class {{classname}} \ No newline at end of file diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_extends.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_extends.handlebars new file mode 100644 index 000000000000..7809e0efdf0a --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_extends.handlebars @@ -0,0 +1 @@ +extends ApiBee \ No newline at end of file diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/disclaimer_autogenerated.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/disclaimer_autogenerated.handlebars new file mode 100644 index 000000000000..c8d24dc182aa --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/disclaimer_autogenerated.handlebars @@ -0,0 +1,3 @@ +# THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. +# For more information on how to customize templates, see: +# https://openapi-generator.tech diff --git a/modules/openapi-generator/src/main/resources/gdscript/utils/README.md b/modules/openapi-generator/src/main/resources/gdscript/utils/README.md new file mode 100644 index 000000000000..81a1a49cf972 --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/utils/README.md @@ -0,0 +1,5 @@ +Utils are not part of the template. +No need to customize them. + +They probably ought not be here, since this whole dir may be downloaded by generator consumers. +Help me find the right spot for these ! diff --git a/modules/openapi-generator/src/main/resources/gdscript/utils/extract_reserved_words.py b/modules/openapi-generator/src/main/resources/gdscript/utils/extract_reserved_words.py index 27f6743a3596..d511d7cf183e 100755 --- a/modules/openapi-generator/src/main/resources/gdscript/utils/extract_reserved_words.py +++ b/modules/openapi-generator/src/main/resources/gdscript/utils/extract_reserved_words.py @@ -4,7 +4,7 @@ import xml.etree.ElementTree as ET import requests -import xml + words_code = "" # output indentation = " " @@ -27,16 +27,25 @@ words_code += "%s// List generated from modules/openapi-generator/src/main/resources/gdscript/utils/extract_reserved_words.py\n" % indentation -current_line = "%s" % indentation +current_line = "" + +def new_line(): + global current_line + current_line = "%s" % indentation + +def write_line(): + global current_line, words_code + words_code += "%s\n" % current_line def add_word(word): global current_line, words_code words_string = "\"%s\", " % word if len(current_line) + len(words_string) > max_line_len: - words_code += "%s\n" % current_line - current_line = "%s" % indentation + write_line() + new_line() current_line += words_string +new_line() words_code += "%s// Godot's global functions\n" % indentation for reserved in methods_list: @@ -48,6 +57,6 @@ def add_word(word): for reserved in singletons_list: add_word(reserved) -words_code += "%s\n" % current_line +write_line() print(words_code) \ No newline at end of file diff --git a/samples/client/petstore/gdscript/.openapi-generator/FILES b/samples/client/petstore/gdscript/.openapi-generator/FILES index 4538487dd240..b7c810143726 100644 --- a/samples/client/petstore/gdscript/.openapi-generator/FILES +++ b/samples/client/petstore/gdscript/.openapi-generator/FILES @@ -1,4 +1,3 @@ -.openapi-generator-ignore README.md apis/PetApi.gd apis/StoreApi.gd diff --git a/samples/client/petstore/gdscript/apis/PetApi.gd b/samples/client/petstore/gdscript/apis/PetApi.gd index dcbf449b0b39..e6db0951f6dd 100644 --- a/samples/client/petstore/gdscript/apis/PetApi.gd +++ b/samples/client/petstore/gdscript/apis/PetApi.gd @@ -1,11 +1,12 @@ -# API PetApi - +# THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. +# For more information on how to customize templates, see: +# https://openapi-generator.tech +# API PetApi class PetApi: extends ApiBee - - # Operation addPet POST /pet + # Operation addPet → POST /pet # Add a new pet to the store func add_pet( # pet: Pet @@ -24,9 +25,7 @@ class PetApi: # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays - #var bzz_query := Dictionary() - var bzz_query := { - } + var bzz_query := Dictionary() # Convert the HTTP method to something Godot understands var bzz_method := bee_convert_http_method("POST") @@ -53,7 +52,7 @@ class PetApi: , # ざわ‥ ) - # Operation deletePet DELETE /pet/{petId} + # Operation deletePet → DELETE /pet/{petId} # Deletes a pet func delete_pet( # petId: float Eg: 789 @@ -75,9 +74,7 @@ class PetApi: # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays - #var bzz_query := Dictionary() - var bzz_query := { - } + var bzz_query := Dictionary() # Convert the HTTP method to something Godot understands var bzz_method := bee_convert_http_method("DELETE") @@ -97,7 +94,7 @@ class PetApi: , # ざわ‥ ) - # Operation findPetsByStatus GET /pet/findByStatus + # Operation findPetsByStatus → GET /pet/findByStatus # Finds Pets by status # # Multiple status values can be provided with comma separated strings @@ -118,10 +115,8 @@ class PetApi: # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays - #var bzz_query := Dictionary() - var bzz_query := { - "status": status, - } + var bzz_query := Dictionary() + bzz_query["status"] = status # Convert the HTTP method to something Godot understands var bzz_method := bee_convert_http_method("GET") @@ -149,7 +144,7 @@ class PetApi: ) # /!. DEPRECATED - # Operation findPetsByTags GET /pet/findByTags + # Operation findPetsByTags → GET /pet/findByTags # Finds Pets by tags # # Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing. @@ -170,10 +165,8 @@ class PetApi: # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays - #var bzz_query := Dictionary() - var bzz_query := { - "tags": tags, - } + var bzz_query := Dictionary() + bzz_query["tags"] = tags # Convert the HTTP method to something Godot understands var bzz_method := bee_convert_http_method("GET") @@ -200,7 +193,7 @@ class PetApi: , # ざわ‥ ) - # Operation getPetById GET /pet/{petId} + # Operation getPetById → GET /pet/{petId} # Find pet by ID # # Returns a single pet @@ -221,9 +214,7 @@ class PetApi: # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays - #var bzz_query := Dictionary() - var bzz_query := { - } + var bzz_query := Dictionary() # Convert the HTTP method to something Godot understands var bzz_method := bee_convert_http_method("GET") @@ -250,7 +241,7 @@ class PetApi: , # ざわ‥ ) - # Operation updatePet PUT /pet + # Operation updatePet → PUT /pet # Update an existing pet func update_pet( # pet: Pet @@ -269,9 +260,7 @@ class PetApi: # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays - #var bzz_query := Dictionary() - var bzz_query := { - } + var bzz_query := Dictionary() # Convert the HTTP method to something Godot understands var bzz_method := bee_convert_http_method("PUT") @@ -298,7 +287,7 @@ class PetApi: , # ざわ‥ ) - # Operation updatePetWithForm POST /pet/{petId} + # Operation updatePetWithForm → POST /pet/{petId} # Updates a pet in the store with form data func update_pet_with_form( # petId: float Eg: 789 @@ -323,9 +312,7 @@ class PetApi: # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays - #var bzz_query := Dictionary() - var bzz_query := { - } + var bzz_query := Dictionary() # Convert the HTTP method to something Godot understands var bzz_method := bee_convert_http_method("POST") @@ -345,7 +332,7 @@ class PetApi: , # ざわ‥ ) - # Operation uploadFile POST /pet/{petId}/uploadImage + # Operation uploadFile → POST /pet/{petId}/uploadImage # uploads an image func upload_file( # petId: float Eg: 789 @@ -370,9 +357,7 @@ class PetApi: # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays - #var bzz_query := Dictionary() - var bzz_query := { - } + var bzz_query := Dictionary() # Convert the HTTP method to something Godot understands var bzz_method := bee_convert_http_method("POST") diff --git a/samples/client/petstore/gdscript/apis/StoreApi.gd b/samples/client/petstore/gdscript/apis/StoreApi.gd index dffb867eea73..e04c2234a577 100644 --- a/samples/client/petstore/gdscript/apis/StoreApi.gd +++ b/samples/client/petstore/gdscript/apis/StoreApi.gd @@ -1,11 +1,12 @@ -# API StoreApi - +# THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. +# For more information on how to customize templates, see: +# https://openapi-generator.tech +# API StoreApi class StoreApi: extends ApiBee - - # Operation deleteOrder DELETE /store/order/{orderId} + # Operation deleteOrder → DELETE /store/order/{orderId} # Delete purchase order by ID # # For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors @@ -26,9 +27,7 @@ class StoreApi: # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays - #var bzz_query := Dictionary() - var bzz_query := { - } + var bzz_query := Dictionary() # Convert the HTTP method to something Godot understands var bzz_method := bee_convert_http_method("DELETE") @@ -48,7 +47,7 @@ class StoreApi: , # ざわ‥ ) - # Operation getInventory GET /store/inventory + # Operation getInventory → GET /store/inventory # Returns pet inventories by status # # Returns a map of status codes to quantities @@ -66,9 +65,7 @@ class StoreApi: # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays - #var bzz_query := Dictionary() - var bzz_query := { - } + var bzz_query := Dictionary() # Convert the HTTP method to something Godot understands var bzz_method := bee_convert_http_method("GET") @@ -95,7 +92,7 @@ class StoreApi: , # ざわ‥ ) - # Operation getOrderById GET /store/order/{orderId} + # Operation getOrderById → GET /store/order/{orderId} # Find purchase order by ID # # For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions @@ -116,9 +113,7 @@ class StoreApi: # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays - #var bzz_query := Dictionary() - var bzz_query := { - } + var bzz_query := Dictionary() # Convert the HTTP method to something Godot understands var bzz_method := bee_convert_http_method("GET") @@ -145,7 +140,7 @@ class StoreApi: , # ざわ‥ ) - # Operation placeOrder POST /store/order + # Operation placeOrder → POST /store/order # Place an order for a pet func place_order( # order: Order @@ -164,9 +159,7 @@ class StoreApi: # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays - #var bzz_query := Dictionary() - var bzz_query := { - } + var bzz_query := Dictionary() # Convert the HTTP method to something Godot understands var bzz_method := bee_convert_http_method("POST") diff --git a/samples/client/petstore/gdscript/apis/UserApi.gd b/samples/client/petstore/gdscript/apis/UserApi.gd index 915131dc06f9..d5ec7f33e2f4 100644 --- a/samples/client/petstore/gdscript/apis/UserApi.gd +++ b/samples/client/petstore/gdscript/apis/UserApi.gd @@ -1,11 +1,12 @@ -# API UserApi - +# THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. +# For more information on how to customize templates, see: +# https://openapi-generator.tech +# API UserApi class UserApi: extends ApiBee - - # Operation createUser POST /user + # Operation createUser → POST /user # Create user # # This can only be done by the logged in user. @@ -26,9 +27,7 @@ class UserApi: # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays - #var bzz_query := Dictionary() - var bzz_query := { - } + var bzz_query := Dictionary() # Convert the HTTP method to something Godot understands var bzz_method := bee_convert_http_method("POST") @@ -48,7 +47,7 @@ class UserApi: , # ざわ‥ ) - # Operation createUsersWithArrayInput POST /user/createWithArray + # Operation createUsersWithArrayInput → POST /user/createWithArray # Creates list of users with given input array func create_users_with_array_input( # user: Array @@ -67,9 +66,7 @@ class UserApi: # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays - #var bzz_query := Dictionary() - var bzz_query := { - } + var bzz_query := Dictionary() # Convert the HTTP method to something Godot understands var bzz_method := bee_convert_http_method("POST") @@ -89,7 +86,7 @@ class UserApi: , # ざわ‥ ) - # Operation createUsersWithListInput POST /user/createWithList + # Operation createUsersWithListInput → POST /user/createWithList # Creates list of users with given input array func create_users_with_list_input( # user: Array @@ -108,9 +105,7 @@ class UserApi: # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays - #var bzz_query := Dictionary() - var bzz_query := { - } + var bzz_query := Dictionary() # Convert the HTTP method to something Godot understands var bzz_method := bee_convert_http_method("POST") @@ -130,7 +125,7 @@ class UserApi: , # ざわ‥ ) - # Operation deleteUser DELETE /user/{username} + # Operation deleteUser → DELETE /user/{username} # Delete user # # This can only be done by the logged in user. @@ -151,9 +146,7 @@ class UserApi: # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays - #var bzz_query := Dictionary() - var bzz_query := { - } + var bzz_query := Dictionary() # Convert the HTTP method to something Godot understands var bzz_method := bee_convert_http_method("DELETE") @@ -173,7 +166,7 @@ class UserApi: , # ざわ‥ ) - # Operation getUserByName GET /user/{username} + # Operation getUserByName → GET /user/{username} # Get user by user name func get_user_by_name( # username: String Eg: username_example @@ -192,9 +185,7 @@ class UserApi: # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays - #var bzz_query := Dictionary() - var bzz_query := { - } + var bzz_query := Dictionary() # Convert the HTTP method to something Godot understands var bzz_method := bee_convert_http_method("GET") @@ -221,7 +212,7 @@ class UserApi: , # ざわ‥ ) - # Operation loginUser GET /user/login + # Operation loginUser → GET /user/login # Logs user into the system func login_user( # username: String Eg: username_example @@ -243,11 +234,9 @@ class UserApi: # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays - #var bzz_query := Dictionary() - var bzz_query := { - "username": username, - "password": password, - } + var bzz_query := Dictionary() + bzz_query["username"] = username + bzz_query["password"] = password # Convert the HTTP method to something Godot understands var bzz_method := bee_convert_http_method("GET") @@ -274,7 +263,7 @@ class UserApi: , # ざわ‥ ) - # Operation logoutUser GET /user/logout + # Operation logoutUser → GET /user/logout # Logs out current logged in user session func logout_user( on_success: Callable, # func(result) @@ -290,9 +279,7 @@ class UserApi: # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays - #var bzz_query := Dictionary() - var bzz_query := { - } + var bzz_query := Dictionary() # Convert the HTTP method to something Godot understands var bzz_method := bee_convert_http_method("GET") @@ -312,7 +299,7 @@ class UserApi: , # ざわ‥ ) - # Operation updateUser PUT /user/{username} + # Operation updateUser → PUT /user/{username} # Updated user # # This can only be done by the logged in user. @@ -336,9 +323,7 @@ class UserApi: # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays - #var bzz_query := Dictionary() - var bzz_query := { - } + var bzz_query := Dictionary() # Convert the HTTP method to something Godot understands var bzz_method := bee_convert_http_method("PUT") diff --git a/samples/client/petstore/gdscript/core/ApiBee.gd b/samples/client/petstore/gdscript/core/ApiBee.gd index 26b68ece3481..f6b434c3bf80 100644 --- a/samples/client/petstore/gdscript/core/ApiBee.gd +++ b/samples/client/petstore/gdscript/core/ApiBee.gd @@ -37,10 +37,10 @@ var bee_client: HTTPClient: var bee_host := DEFAULT_HOST: set(value): if value.begins_with("https://"): - enable_ssl() + bee_enable_ssl() value = value.substr(8) # "https://".length() == 8 elif value.begins_with("http://"): - disable_ssl() + bee_disable_ssl() value = value.substr(7) # "http://".length() == 7 bee_host = value @@ -55,17 +55,17 @@ var __bee_ssl_enabled := false var __bee_verify_host := true # only if ssl enabled -func enable_ssl(): +func bee_enable_ssl(): self.__bee_ssl_enabled = true self.bee_port = HTTPS_DEFAULT_PORT -func disable_ssl(): +func bee_disable_ssl(): self.__bee_ssl_enabled = false self.bee_port = HTTP_DEFAULT_PORT -func next_loop_iteration(): +func bee_next_loop_iteration(): # Use this when it works, on release (beta3 now) # return Engine.get_main_loop().idle_frame # For now, this works @@ -114,7 +114,7 @@ func bee_connect_client_if_needed( print("Connecting...") if POLLING_INTERVAL_MS: OS.delay_msec(POLLING_INTERVAL_MS) - await next_loop_iteration() + await bee_next_loop_iteration() if self.bee_client.get_status() != HTTPClient.STATUS_CONNECTED: var error := ApiError.new() @@ -235,7 +235,7 @@ func bee_do_request_text( print("Requesting...") if POLLING_INTERVAL_MS: # yeah yeah, needs work OS.delay_msec(POLLING_INTERVAL_MS) - await next_loop_iteration() + await bee_next_loop_iteration() # if OS.has_feature("web") or async: if not self.bee_client.has_response(): @@ -269,7 +269,7 @@ func bee_do_request_text( if not false: OS.delay_usec(POLLING_INTERVAL_MS) else: - await next_loop_iteration() + await bee_next_loop_iteration() else: # Yummy data has arrived response_bytes = response_bytes + chunk From 8de37d1353d4c26e86c37fb49dbc148ffd26478e Mon Sep 17 00:00:00 2001 From: Goutte Date: Wed, 19 Oct 2022 23:57:23 +0200 Subject: [PATCH 04/56] test(gdscript): prepare a demo and integration testing --- .../languages/GdscriptClientCodegen.java | 402 +++++++++--------- samples/client/petstore/gdscript/.gitignore | 4 + .../gdscript/.openapi-generator/FILES | 1 + samples/client/petstore/gdscript/Logger.gd | 46 ++ samples/client/petstore/gdscript/README.md | 1 + .../client/petstore/gdscript/apis/PetApi.gd | 96 ++--- .../client/petstore/gdscript/apis/StoreApi.gd | 48 +-- .../client/petstore/gdscript/apis/UserApi.gd | 96 ++--- samples/client/petstore/gdscript/icon.svg | 1 + samples/client/petstore/gdscript/main.gd | 15 + samples/client/petstore/gdscript/main.tscn | 62 +++ .../client/petstore/gdscript/project.godot | 36 ++ 12 files changed, 488 insertions(+), 320 deletions(-) create mode 100644 samples/client/petstore/gdscript/.gitignore create mode 100644 samples/client/petstore/gdscript/Logger.gd create mode 100644 samples/client/petstore/gdscript/icon.svg create mode 100644 samples/client/petstore/gdscript/main.gd create mode 100644 samples/client/petstore/gdscript/main.tscn create mode 100644 samples/client/petstore/gdscript/project.godot diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java index a57138f6d6b4..605669d4e9ea 100644 --- a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java +++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java @@ -3,15 +3,12 @@ import io.swagger.v3.oas.models.media.Schema; import org.openapitools.codegen.*; //import io.swagger.models.properties.ArrayProperty; -//import io.swagger.models.properties.MapProperty; //import io.swagger.models.properties.Property; //import io.swagger.models.parameters.Parameter; import java.io.File; import java.util.Arrays; -//import java.util.*; - -//import org.apache.commons.lang3.StringUtils; +import java.util.List; import org.openapitools.codegen.api.TemplatingEngineAdapter; import org.openapitools.codegen.templating.HandlebarsEngineAdapter; @@ -40,7 +37,10 @@ public String getHelp() { public GdscriptClientCodegen() { super(); - outputFolder = "generated-code" + File.separator + "gdscript"; + // It makes sense to package the generated code like a Godot addon, for ease of installation. + // Since most users will set the output dir, we need to document that fact. + String addonName = "oas." + "petstore"; // TODO: replace "petstore" from CLI or YAML or both (how?) + outputFolder = "generated-code" + File.separator + "gdscript" + File.separator + "addons" + File.separator + addonName; modelTemplateFiles.put("model.handlebars", ".gd"); apiTemplateFiles.put("api.handlebars", ".gd"); @@ -52,202 +52,10 @@ public GdscriptClientCodegen() { supportingFiles.add(new SupportingFile("ApiError.handlebars", "core", "ApiError.gd")); supportingFiles.add(new SupportingFile("README.handlebars", "", "README.md")); - // Reserved keywords - // https://github.com/godotengine/godot/blob/master/modules/gdscript/gdscript_tokenizer.cpp - // FIXME - setReservedWordsLowerCase( - Arrays.asList( - // Local method names used in base API class - "bee_connect_client_if_needed", "bee_request", "bee_request_text", "bee_do_request_text", - "bee_convert_http_method", "bee_urlize_path_param", "bee_escape_path_param", - "bee_next_loop_iteration", "bee_enable_ssl", "bee_disable_ssl", - // Local properties used in base API class - "bee_client", "bee_host", "bee_port", "bee_name", - // Local variable names used in API methods (endpoints) - "bzz_method", "bzz_path", "bzz_query", - "bzz_result", "bzz_code", "bzz_headers", - "bzz_error", - - // Godot's Global Scope - // https://github.com/godotengine/godot/blob/master/doc/classes/%40GlobalScope.xml - // List generated from modules/openapi-generator/src/main/resources/gdscript/utils/extract_reserved_words.py - // Godot's global functions - "abs", "absf", "absi", "acos", "asin", "atan", "atan2", "bezier_interpolate", "bytes_to_var", - "bytes_to_var_with_objects", "ceil", "ceilf", "ceili", "clamp", "clampf", "clampi", "cos", - "cosh", "cubic_interpolate", "cubic_interpolate_angle", "cubic_interpolate_angle_in_time", - "cubic_interpolate_in_time", "db_to_linear", "deg_to_rad", "ease", "error_string", "exp", - "floor", "floorf", "floori", "fmod", "fposmod", "hash", "instance_from_id", "inverse_lerp", - "is_equal_approx", "is_finite", "is_inf", "is_instance_id_valid", "is_instance_valid", - "is_nan", "is_zero_approx", "lerp", "lerp_angle", "lerpf", "linear_to_db", "log", "max", - "maxf", "maxi", "min", "minf", "mini", "move_toward", "nearest_po2", "pingpong", "posmod", - "pow", "print", "print_rich", "print_verbose", "printerr", "printraw", "prints", "printt", - "push_error", "push_warning", "rad_to_deg", "rand_from_seed", "randf", "randf_range", - "randfn", "randi", "randi_range", "randomize", "remap", "rid_allocate_id", "rid_from_int64", - "round", "roundf", "roundi", "seed", "sign", "signf", "signi", "sin", "sinh", "smoothstep", - "snapped", "sqrt", "step_decimals", "str", "str_to_var", "tan", "tanh", "typeof", - "var_to_bytes", "var_to_bytes_with_objects", "var_to_str", "weakref", "wrap", "wrapf", - // Godot's global constants - "wrapi", "SIDE_LEFT", "SIDE_TOP", "SIDE_RIGHT", "SIDE_BOTTOM", "CORNER_TOP_LEFT", - "CORNER_TOP_RIGHT", "CORNER_BOTTOM_RIGHT", "CORNER_BOTTOM_LEFT", "VERTICAL", "HORIZONTAL", - "CLOCKWISE", "COUNTERCLOCKWISE", "HORIZONTAL_ALIGNMENT_LEFT", "HORIZONTAL_ALIGNMENT_CENTER", - "HORIZONTAL_ALIGNMENT_RIGHT", "HORIZONTAL_ALIGNMENT_FILL", "VERTICAL_ALIGNMENT_TOP", - "VERTICAL_ALIGNMENT_CENTER", "VERTICAL_ALIGNMENT_BOTTOM", "VERTICAL_ALIGNMENT_FILL", - "INLINE_ALIGNMENT_TOP_TO", "INLINE_ALIGNMENT_CENTER_TO", "INLINE_ALIGNMENT_BOTTOM_TO", - "INLINE_ALIGNMENT_TO_TOP", "INLINE_ALIGNMENT_TO_CENTER", "INLINE_ALIGNMENT_TO_BASELINE", - "INLINE_ALIGNMENT_TO_BOTTOM", "INLINE_ALIGNMENT_TOP", "INLINE_ALIGNMENT_CENTER", - "INLINE_ALIGNMENT_BOTTOM", "INLINE_ALIGNMENT_IMAGE_MASK", "INLINE_ALIGNMENT_TEXT_MASK", - "KEY_NONE", "KEY_SPECIAL", "KEY_ESCAPE", "KEY_TAB", "KEY_BACKTAB", "KEY_BACKSPACE", - "KEY_ENTER", "KEY_KP_ENTER", "KEY_INSERT", "KEY_DELETE", "KEY_PAUSE", "KEY_PRINT", - "KEY_SYSREQ", "KEY_CLEAR", "KEY_HOME", "KEY_END", "KEY_LEFT", "KEY_UP", "KEY_RIGHT", - "KEY_DOWN", "KEY_PAGEUP", "KEY_PAGEDOWN", "KEY_SHIFT", "KEY_CTRL", "KEY_META", "KEY_ALT", - "KEY_CAPSLOCK", "KEY_NUMLOCK", "KEY_SCROLLLOCK", "KEY_F1", "KEY_F2", "KEY_F3", "KEY_F4", - "KEY_F5", "KEY_F6", "KEY_F7", "KEY_F8", "KEY_F9", "KEY_F10", "KEY_F11", "KEY_F12", "KEY_F13", - "KEY_F14", "KEY_F15", "KEY_F16", "KEY_F17", "KEY_F18", "KEY_F19", "KEY_F20", "KEY_F21", - "KEY_F22", "KEY_F23", "KEY_F24", "KEY_F25", "KEY_F26", "KEY_F27", "KEY_F28", "KEY_F29", - "KEY_F30", "KEY_F31", "KEY_F32", "KEY_F33", "KEY_F34", "KEY_F35", "KEY_KP_MULTIPLY", - "KEY_KP_DIVIDE", "KEY_KP_SUBTRACT", "KEY_KP_PERIOD", "KEY_KP_ADD", "KEY_KP_0", "KEY_KP_1", - "KEY_KP_2", "KEY_KP_3", "KEY_KP_4", "KEY_KP_5", "KEY_KP_6", "KEY_KP_7", "KEY_KP_8", - "KEY_KP_9", "KEY_SUPER_L", "KEY_SUPER_R", "KEY_MENU", "KEY_HYPER_L", "KEY_HYPER_R", - "KEY_HELP", "KEY_DIRECTION_L", "KEY_DIRECTION_R", "KEY_BACK", "KEY_FORWARD", "KEY_STOP", - "KEY_REFRESH", "KEY_VOLUMEDOWN", "KEY_VOLUMEMUTE", "KEY_VOLUMEUP", "KEY_BASSBOOST", - "KEY_BASSUP", "KEY_BASSDOWN", "KEY_TREBLEUP", "KEY_TREBLEDOWN", "KEY_MEDIAPLAY", - "KEY_MEDIASTOP", "KEY_MEDIAPREVIOUS", "KEY_MEDIANEXT", "KEY_MEDIARECORD", "KEY_HOMEPAGE", - "KEY_FAVORITES", "KEY_SEARCH", "KEY_STANDBY", "KEY_OPENURL", "KEY_LAUNCHMAIL", - "KEY_LAUNCHMEDIA", "KEY_LAUNCH0", "KEY_LAUNCH1", "KEY_LAUNCH2", "KEY_LAUNCH3", "KEY_LAUNCH4", - "KEY_LAUNCH5", "KEY_LAUNCH6", "KEY_LAUNCH7", "KEY_LAUNCH8", "KEY_LAUNCH9", "KEY_LAUNCHA", - "KEY_LAUNCHB", "KEY_LAUNCHC", "KEY_LAUNCHD", "KEY_LAUNCHE", "KEY_LAUNCHF", "KEY_UNKNOWN", - "KEY_SPACE", "KEY_EXCLAM", "KEY_QUOTEDBL", "KEY_NUMBERSIGN", "KEY_DOLLAR", "KEY_PERCENT", - "KEY_AMPERSAND", "KEY_APOSTROPHE", "KEY_PARENLEFT", "KEY_PARENRIGHT", "KEY_ASTERISK", - "KEY_PLUS", "KEY_COMMA", "KEY_MINUS", "KEY_PERIOD", "KEY_SLASH", "KEY_0", "KEY_1", "KEY_2", - "KEY_3", "KEY_4", "KEY_5", "KEY_6", "KEY_7", "KEY_8", "KEY_9", "KEY_COLON", "KEY_SEMICOLON", - "KEY_LESS", "KEY_EQUAL", "KEY_GREATER", "KEY_QUESTION", "KEY_AT", "KEY_A", "KEY_B", "KEY_C", - "KEY_D", "KEY_E", "KEY_F", "KEY_G", "KEY_H", "KEY_I", "KEY_J", "KEY_K", "KEY_L", "KEY_M", - "KEY_N", "KEY_O", "KEY_P", "KEY_Q", "KEY_R", "KEY_S", "KEY_T", "KEY_U", "KEY_V", "KEY_W", - "KEY_X", "KEY_Y", "KEY_Z", "KEY_BRACKETLEFT", "KEY_BACKSLASH", "KEY_BRACKETRIGHT", - "KEY_ASCIICIRCUM", "KEY_UNDERSCORE", "KEY_QUOTELEFT", "KEY_BRACELEFT", "KEY_BAR", - "KEY_BRACERIGHT", "KEY_ASCIITILDE", "KEY_NOBREAKSPACE", "KEY_EXCLAMDOWN", "KEY_CENT", - "KEY_STERLING", "KEY_CURRENCY", "KEY_YEN", "KEY_BROKENBAR", "KEY_SECTION", "KEY_DIAERESIS", - "KEY_COPYRIGHT", "KEY_ORDFEMININE", "KEY_GUILLEMOTLEFT", "KEY_NOTSIGN", "KEY_HYPHEN", - "KEY_REGISTERED", "KEY_MACRON", "KEY_DEGREE", "KEY_PLUSMINUS", "KEY_TWOSUPERIOR", - "KEY_THREESUPERIOR", "KEY_ACUTE", "KEY_MU", "KEY_PARAGRAPH", "KEY_PERIODCENTERED", - "KEY_CEDILLA", "KEY_ONESUPERIOR", "KEY_MASCULINE", "KEY_GUILLEMOTRIGHT", "KEY_ONEQUARTER", - "KEY_ONEHALF", "KEY_THREEQUARTERS", "KEY_QUESTIONDOWN", "KEY_AGRAVE", "KEY_AACUTE", - "KEY_ACIRCUMFLEX", "KEY_ATILDE", "KEY_ADIAERESIS", "KEY_ARING", "KEY_AE", "KEY_CCEDILLA", - "KEY_EGRAVE", "KEY_EACUTE", "KEY_ECIRCUMFLEX", "KEY_EDIAERESIS", "KEY_IGRAVE", "KEY_IACUTE", - "KEY_ICIRCUMFLEX", "KEY_IDIAERESIS", "KEY_ETH", "KEY_NTILDE", "KEY_OGRAVE", "KEY_OACUTE", - "KEY_OCIRCUMFLEX", "KEY_OTILDE", "KEY_ODIAERESIS", "KEY_MULTIPLY", "KEY_OOBLIQUE", - "KEY_UGRAVE", "KEY_UACUTE", "KEY_UCIRCUMFLEX", "KEY_UDIAERESIS", "KEY_YACUTE", "KEY_THORN", - "KEY_SSHARP", "KEY_DIVISION", "KEY_YDIAERESIS", "KEY_CODE_MASK", "KEY_MODIFIER_MASK", - "KEY_MASK_CMD_OR_CTRL", "KEY_MASK_SHIFT", "KEY_MASK_ALT", "KEY_MASK_META", "KEY_MASK_CTRL", - "KEY_MASK_KPAD", "KEY_MASK_GROUP_SWITCH", "MOUSE_BUTTON_NONE", "MOUSE_BUTTON_LEFT", - "MOUSE_BUTTON_RIGHT", "MOUSE_BUTTON_MIDDLE", "MOUSE_BUTTON_WHEEL_UP", - "MOUSE_BUTTON_WHEEL_DOWN", "MOUSE_BUTTON_WHEEL_LEFT", "MOUSE_BUTTON_WHEEL_RIGHT", - "MOUSE_BUTTON_XBUTTON1", "MOUSE_BUTTON_XBUTTON2", "MOUSE_BUTTON_MASK_LEFT", - "MOUSE_BUTTON_MASK_RIGHT", "MOUSE_BUTTON_MASK_MIDDLE", "MOUSE_BUTTON_MASK_XBUTTON1", - "MOUSE_BUTTON_MASK_XBUTTON2", "JOY_BUTTON_INVALID", "JOY_BUTTON_A", "JOY_BUTTON_B", - "JOY_BUTTON_X", "JOY_BUTTON_Y", "JOY_BUTTON_BACK", "JOY_BUTTON_GUIDE", "JOY_BUTTON_START", - "JOY_BUTTON_LEFT_STICK", "JOY_BUTTON_RIGHT_STICK", "JOY_BUTTON_LEFT_SHOULDER", - "JOY_BUTTON_RIGHT_SHOULDER", "JOY_BUTTON_DPAD_UP", "JOY_BUTTON_DPAD_DOWN", - "JOY_BUTTON_DPAD_LEFT", "JOY_BUTTON_DPAD_RIGHT", "JOY_BUTTON_MISC1", "JOY_BUTTON_PADDLE1", - "JOY_BUTTON_PADDLE2", "JOY_BUTTON_PADDLE3", "JOY_BUTTON_PADDLE4", "JOY_BUTTON_TOUCHPAD", - "JOY_BUTTON_SDL_MAX", "JOY_BUTTON_MAX", "JOY_AXIS_INVALID", "JOY_AXIS_LEFT_X", - "JOY_AXIS_LEFT_Y", "JOY_AXIS_RIGHT_X", "JOY_AXIS_RIGHT_Y", "JOY_AXIS_TRIGGER_LEFT", - "JOY_AXIS_TRIGGER_RIGHT", "JOY_AXIS_SDL_MAX", "JOY_AXIS_MAX", "MIDI_MESSAGE_NONE", - "MIDI_MESSAGE_NOTE_OFF", "MIDI_MESSAGE_NOTE_ON", "MIDI_MESSAGE_AFTERTOUCH", - "MIDI_MESSAGE_CONTROL_CHANGE", "MIDI_MESSAGE_PROGRAM_CHANGE", "MIDI_MESSAGE_CHANNEL_PRESSURE", - "MIDI_MESSAGE_PITCH_BEND", "MIDI_MESSAGE_SYSTEM_EXCLUSIVE", "MIDI_MESSAGE_QUARTER_FRAME", - "MIDI_MESSAGE_SONG_POSITION_POINTER", "MIDI_MESSAGE_SONG_SELECT", "MIDI_MESSAGE_TUNE_REQUEST", - "MIDI_MESSAGE_TIMING_CLOCK", "MIDI_MESSAGE_START", "MIDI_MESSAGE_CONTINUE", - "MIDI_MESSAGE_STOP", "MIDI_MESSAGE_ACTIVE_SENSING", "MIDI_MESSAGE_SYSTEM_RESET", "OK", - "FAILED", "ERR_UNAVAILABLE", "ERR_UNCONFIGURED", "ERR_UNAUTHORIZED", - "ERR_PARAMETER_RANGE_ERROR", "ERR_OUT_OF_MEMORY", "ERR_FILE_NOT_FOUND", "ERR_FILE_BAD_DRIVE", - "ERR_FILE_BAD_PATH", "ERR_FILE_NO_PERMISSION", "ERR_FILE_ALREADY_IN_USE", - "ERR_FILE_CANT_OPEN", "ERR_FILE_CANT_WRITE", "ERR_FILE_CANT_READ", "ERR_FILE_UNRECOGNIZED", - "ERR_FILE_CORRUPT", "ERR_FILE_MISSING_DEPENDENCIES", "ERR_FILE_EOF", "ERR_CANT_OPEN", - "ERR_CANT_CREATE", "ERR_QUERY_FAILED", "ERR_ALREADY_IN_USE", "ERR_LOCKED", "ERR_TIMEOUT", - "ERR_CANT_CONNECT", "ERR_CANT_RESOLVE", "ERR_CONNECTION_ERROR", "ERR_CANT_ACQUIRE_RESOURCE", - "ERR_CANT_FORK", "ERR_INVALID_DATA", "ERR_INVALID_PARAMETER", "ERR_ALREADY_EXISTS", - "ERR_DOES_NOT_EXIST", "ERR_DATABASE_CANT_READ", "ERR_DATABASE_CANT_WRITE", - "ERR_COMPILATION_FAILED", "ERR_METHOD_NOT_FOUND", "ERR_LINK_FAILED", "ERR_SCRIPT_FAILED", - "ERR_CYCLIC_LINK", "ERR_INVALID_DECLARATION", "ERR_DUPLICATE_SYMBOL", "ERR_PARSE_ERROR", - "ERR_BUSY", "ERR_SKIP", "ERR_HELP", "ERR_BUG", "ERR_PRINTER_ON_FIRE", "PROPERTY_HINT_NONE", - "PROPERTY_HINT_RANGE", "PROPERTY_HINT_ENUM", "PROPERTY_HINT_ENUM_SUGGESTION", - "PROPERTY_HINT_EXP_EASING", "PROPERTY_HINT_LINK", "PROPERTY_HINT_FLAGS", - "PROPERTY_HINT_LAYERS_2D_RENDER", "PROPERTY_HINT_LAYERS_2D_PHYSICS", - "PROPERTY_HINT_LAYERS_2D_NAVIGATION", "PROPERTY_HINT_LAYERS_3D_RENDER", - "PROPERTY_HINT_LAYERS_3D_PHYSICS", "PROPERTY_HINT_LAYERS_3D_NAVIGATION", "PROPERTY_HINT_FILE", - "PROPERTY_HINT_DIR", "PROPERTY_HINT_GLOBAL_FILE", "PROPERTY_HINT_GLOBAL_DIR", - "PROPERTY_HINT_RESOURCE_TYPE", "PROPERTY_HINT_MULTILINE_TEXT", "PROPERTY_HINT_EXPRESSION", - "PROPERTY_HINT_PLACEHOLDER_TEXT", "PROPERTY_HINT_COLOR_NO_ALPHA", - "PROPERTY_HINT_IMAGE_COMPRESS_LOSSY", "PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS", - "PROPERTY_HINT_OBJECT_ID", "PROPERTY_HINT_TYPE_STRING", - "PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE", "PROPERTY_HINT_METHOD_OF_VARIANT_TYPE", - "PROPERTY_HINT_METHOD_OF_BASE_TYPE", "PROPERTY_HINT_METHOD_OF_INSTANCE", - "PROPERTY_HINT_METHOD_OF_SCRIPT", "PROPERTY_HINT_PROPERTY_OF_VARIANT_TYPE", - "PROPERTY_HINT_PROPERTY_OF_BASE_TYPE", "PROPERTY_HINT_PROPERTY_OF_INSTANCE", - "PROPERTY_HINT_PROPERTY_OF_SCRIPT", "PROPERTY_HINT_OBJECT_TOO_BIG", - "PROPERTY_HINT_NODE_PATH_VALID_TYPES", "PROPERTY_HINT_SAVE_FILE", - "PROPERTY_HINT_GLOBAL_SAVE_FILE", "PROPERTY_HINT_INT_IS_OBJECTID", - "PROPERTY_HINT_INT_IS_POINTER", "PROPERTY_HINT_ARRAY_TYPE", "PROPERTY_HINT_LOCALE_ID", - "PROPERTY_HINT_LOCALIZABLE_STRING", "PROPERTY_HINT_NODE_TYPE", - "PROPERTY_HINT_HIDE_QUATERNION_EDIT", "PROPERTY_HINT_PASSWORD", "PROPERTY_HINT_MAX", - "PROPERTY_USAGE_NONE", "PROPERTY_USAGE_STORAGE", "PROPERTY_USAGE_EDITOR", - "PROPERTY_USAGE_CHECKABLE", "PROPERTY_USAGE_CHECKED", "PROPERTY_USAGE_INTERNATIONALIZED", - "PROPERTY_USAGE_GROUP", "PROPERTY_USAGE_CATEGORY", "PROPERTY_USAGE_SUBGROUP", - "PROPERTY_USAGE_CLASS_IS_BITFIELD", "PROPERTY_USAGE_NO_INSTANCE_STATE", - "PROPERTY_USAGE_RESTART_IF_CHANGED", "PROPERTY_USAGE_SCRIPT_VARIABLE", - "PROPERTY_USAGE_STORE_IF_NULL", "PROPERTY_USAGE_ANIMATE_AS_TRIGGER", - "PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED", "PROPERTY_USAGE_SCRIPT_DEFAULT_VALUE", - "PROPERTY_USAGE_CLASS_IS_ENUM", "PROPERTY_USAGE_NIL_IS_VARIANT", "PROPERTY_USAGE_INTERNAL", - "PROPERTY_USAGE_DO_NOT_SHARE_ON_DUPLICATE", "PROPERTY_USAGE_HIGH_END_GFX", - "PROPERTY_USAGE_NODE_PATH_FROM_SCENE_ROOT", "PROPERTY_USAGE_RESOURCE_NOT_PERSISTENT", - "PROPERTY_USAGE_KEYING_INCREMENTS", "PROPERTY_USAGE_DEFERRED_SET_RESOURCE", - "PROPERTY_USAGE_EDITOR_INSTANTIATE_OBJECT", "PROPERTY_USAGE_EDITOR_BASIC_SETTING", - "PROPERTY_USAGE_READ_ONLY", "PROPERTY_USAGE_ARRAY", "PROPERTY_USAGE_DEFAULT", - "PROPERTY_USAGE_DEFAULT_INTL", "PROPERTY_USAGE_NO_EDITOR", "METHOD_FLAG_NORMAL", - "METHOD_FLAG_EDITOR", "METHOD_FLAG_CONST", "METHOD_FLAG_VIRTUAL", "METHOD_FLAG_VARARG", - "METHOD_FLAG_STATIC", "METHOD_FLAG_OBJECT_CORE", "METHOD_FLAGS_DEFAULT", "TYPE_NIL", - "TYPE_BOOL", "TYPE_INT", "TYPE_FLOAT", "TYPE_STRING", "TYPE_VECTOR2", "TYPE_VECTOR2I", - "TYPE_RECT2", "TYPE_RECT2I", "TYPE_VECTOR3", "TYPE_VECTOR3I", "TYPE_TRANSFORM2D", - "TYPE_VECTOR4", "TYPE_VECTOR4I", "TYPE_PLANE", "TYPE_QUATERNION", "TYPE_AABB", "TYPE_BASIS", - "TYPE_TRANSFORM3D", "TYPE_PROJECTION", "TYPE_COLOR", "TYPE_STRING_NAME", "TYPE_NODE_PATH", - "TYPE_RID", "TYPE_OBJECT", "TYPE_CALLABLE", "TYPE_SIGNAL", "TYPE_DICTIONARY", "TYPE_ARRAY", - "TYPE_PACKED_BYTE_ARRAY", "TYPE_PACKED_INT32_ARRAY", "TYPE_PACKED_INT64_ARRAY", - "TYPE_PACKED_FLOAT32_ARRAY", "TYPE_PACKED_FLOAT64_ARRAY", "TYPE_PACKED_STRING_ARRAY", - "TYPE_PACKED_VECTOR2_ARRAY", "TYPE_PACKED_VECTOR3_ARRAY", "TYPE_PACKED_COLOR_ARRAY", - "TYPE_MAX", "OP_EQUAL", "OP_NOT_EQUAL", "OP_LESS", "OP_LESS_EQUAL", "OP_GREATER", - "OP_GREATER_EQUAL", "OP_ADD", "OP_SUBTRACT", "OP_MULTIPLY", "OP_DIVIDE", "OP_NEGATE", - "OP_POSITIVE", "OP_MODULE", "OP_POWER", "OP_SHIFT_LEFT", "OP_SHIFT_RIGHT", "OP_BIT_AND", - "OP_BIT_OR", "OP_BIT_XOR", "OP_BIT_NEGATE", "OP_AND", "OP_OR", "OP_XOR", "OP_NOT", "OP_IN", - // Godot's singletons - "OP_MAX", "AudioServer", "CameraServer", "ClassDB", "DisplayServer", "Engine", - "EngineDebugger", "Geometry2D", "Geometry3D", "GodotSharp", "IP", "Input", "InputMap", - "JavaClassWrapper", "JavaScriptBridge", "Marshalls", "NativeExtensionManager", - "NavigationMeshGenerator", "NavigationServer2D", "NavigationServer3D", "OS", "Performance", - "PhysicsServer2D", "PhysicsServer2DManager", "PhysicsServer3D", "PhysicsServer3DManager", - "ProjectSettings", "RenderingServer", "ResourceLoader", "ResourceSaver", "ResourceUID", - "TextServerManager", "ThemeDB", "Time", "TranslationServer", "WorkerThreadPool", "XRServer", - - // Tokens from GDScript - // https://github.com/godotengine/godot/blob/master/modules/gdscript/gdscript_tokenizer.cpp - // Logical - "and", "or", "not", - // Control flow - "if", "elif", "else", "for", "while", "break", "continue", "pass", "return", "match", - // Keywords – hey, namespace is here, and so is trait ! - "as", "assert", "await", "breakpoint", "class", "class_name", "const", "enum", "extends", - "func", "in", "is", "namespace", "preload", "self", "signal", "static", "super", "trait", - "var", "void", "yield", - // Constants - "PI", "TAU", "INF", "NaN", - - // Types TODO: extract all types from somewhere ; we're going to need all the Nodes, as well ?! - "float", "int", "String", "bool", "Dictionary", "Array", "Color", - "Quat", "Vector2", "Vector3", "Transform" - ) - ); + setReservedWordsLowerCase(getReservedWords()); + typeMapping.clear(); typeMapping.put("array", "Array"); typeMapping.put("List", "Array"); @@ -309,7 +117,7 @@ public void processOpts() { @Override public String escapeUnsafeCharacters(String input) { - // There might be ways to inject code in Gdscript, but I don't see any for now. + // There might be ways to inject code in Gdscript, but I don't see any for now. (no /* */ comments) // TODO: review this with someone else return input; } @@ -352,4 +160,198 @@ public String toDefaultValue(Schema schema) { return ""; } + + protected List getReservedWords() { + // FIXME: Missing Nodes and other Objects globally available (RefCounted, Sprite2D, etc.) + // FIXME: Missing primitive types (Rect…) + return Arrays.asList( + // Local method names used in base API class + "bee_connect_client_if_needed", "bee_request", "bee_request_text", "bee_do_request_text", + "bee_convert_http_method", "bee_urlize_path_param", "bee_escape_path_param", + "bee_next_loop_iteration", "bee_enable_ssl", "bee_disable_ssl", + // Local properties used in base API class + "bee_client", "bee_host", "bee_port", "bee_name", + // Local variable names used in API methods (endpoints) + "bzz_method", "bzz_path", "bzz_query", + "bzz_result", "bzz_code", "bzz_headers", + "bzz_error", + + // Godot's Global Scope + // https://github.com/godotengine/godot/blob/master/doc/classes/%40GlobalScope.xml + // List generated from modules/openapi-generator/src/main/resources/gdscript/utils/extract_reserved_words.py + // Godot's global functions + "abs", "absf", "absi", "acos", "asin", "atan", "atan2", "bezier_interpolate", "bytes_to_var", + "bytes_to_var_with_objects", "ceil", "ceilf", "ceili", "clamp", "clampf", "clampi", "cos", + "cosh", "cubic_interpolate", "cubic_interpolate_angle", "cubic_interpolate_angle_in_time", + "cubic_interpolate_in_time", "db_to_linear", "deg_to_rad", "ease", "error_string", "exp", + "floor", "floorf", "floori", "fmod", "fposmod", "hash", "instance_from_id", "inverse_lerp", + "is_equal_approx", "is_finite", "is_inf", "is_instance_id_valid", "is_instance_valid", + "is_nan", "is_zero_approx", "lerp", "lerp_angle", "lerpf", "linear_to_db", "log", "max", + "maxf", "maxi", "min", "minf", "mini", "move_toward", "nearest_po2", "pingpong", "posmod", + "pow", "print", "print_rich", "print_verbose", "printerr", "printraw", "prints", "printt", + "push_error", "push_warning", "rad_to_deg", "rand_from_seed", "randf", "randf_range", + "randfn", "randi", "randi_range", "randomize", "remap", "rid_allocate_id", "rid_from_int64", + "round", "roundf", "roundi", "seed", "sign", "signf", "signi", "sin", "sinh", "smoothstep", + "snapped", "sqrt", "step_decimals", "str", "str_to_var", "tan", "tanh", "typeof", + "var_to_bytes", "var_to_bytes_with_objects", "var_to_str", "weakref", "wrap", "wrapf", + // Godot's global constants + "wrapi", "SIDE_LEFT", "SIDE_TOP", "SIDE_RIGHT", "SIDE_BOTTOM", "CORNER_TOP_LEFT", + "CORNER_TOP_RIGHT", "CORNER_BOTTOM_RIGHT", "CORNER_BOTTOM_LEFT", "VERTICAL", "HORIZONTAL", + "CLOCKWISE", "COUNTERCLOCKWISE", "HORIZONTAL_ALIGNMENT_LEFT", "HORIZONTAL_ALIGNMENT_CENTER", + "HORIZONTAL_ALIGNMENT_RIGHT", "HORIZONTAL_ALIGNMENT_FILL", "VERTICAL_ALIGNMENT_TOP", + "VERTICAL_ALIGNMENT_CENTER", "VERTICAL_ALIGNMENT_BOTTOM", "VERTICAL_ALIGNMENT_FILL", + "INLINE_ALIGNMENT_TOP_TO", "INLINE_ALIGNMENT_CENTER_TO", "INLINE_ALIGNMENT_BOTTOM_TO", + "INLINE_ALIGNMENT_TO_TOP", "INLINE_ALIGNMENT_TO_CENTER", "INLINE_ALIGNMENT_TO_BASELINE", + "INLINE_ALIGNMENT_TO_BOTTOM", "INLINE_ALIGNMENT_TOP", "INLINE_ALIGNMENT_CENTER", + "INLINE_ALIGNMENT_BOTTOM", "INLINE_ALIGNMENT_IMAGE_MASK", "INLINE_ALIGNMENT_TEXT_MASK", + "KEY_NONE", "KEY_SPECIAL", "KEY_ESCAPE", "KEY_TAB", "KEY_BACKTAB", "KEY_BACKSPACE", + "KEY_ENTER", "KEY_KP_ENTER", "KEY_INSERT", "KEY_DELETE", "KEY_PAUSE", "KEY_PRINT", + "KEY_SYSREQ", "KEY_CLEAR", "KEY_HOME", "KEY_END", "KEY_LEFT", "KEY_UP", "KEY_RIGHT", + "KEY_DOWN", "KEY_PAGEUP", "KEY_PAGEDOWN", "KEY_SHIFT", "KEY_CTRL", "KEY_META", "KEY_ALT", + "KEY_CAPSLOCK", "KEY_NUMLOCK", "KEY_SCROLLLOCK", "KEY_F1", "KEY_F2", "KEY_F3", "KEY_F4", + "KEY_F5", "KEY_F6", "KEY_F7", "KEY_F8", "KEY_F9", "KEY_F10", "KEY_F11", "KEY_F12", "KEY_F13", + "KEY_F14", "KEY_F15", "KEY_F16", "KEY_F17", "KEY_F18", "KEY_F19", "KEY_F20", "KEY_F21", + "KEY_F22", "KEY_F23", "KEY_F24", "KEY_F25", "KEY_F26", "KEY_F27", "KEY_F28", "KEY_F29", + "KEY_F30", "KEY_F31", "KEY_F32", "KEY_F33", "KEY_F34", "KEY_F35", "KEY_KP_MULTIPLY", + "KEY_KP_DIVIDE", "KEY_KP_SUBTRACT", "KEY_KP_PERIOD", "KEY_KP_ADD", "KEY_KP_0", "KEY_KP_1", + "KEY_KP_2", "KEY_KP_3", "KEY_KP_4", "KEY_KP_5", "KEY_KP_6", "KEY_KP_7", "KEY_KP_8", + "KEY_KP_9", "KEY_SUPER_L", "KEY_SUPER_R", "KEY_MENU", "KEY_HYPER_L", "KEY_HYPER_R", + "KEY_HELP", "KEY_DIRECTION_L", "KEY_DIRECTION_R", "KEY_BACK", "KEY_FORWARD", "KEY_STOP", + "KEY_REFRESH", "KEY_VOLUMEDOWN", "KEY_VOLUMEMUTE", "KEY_VOLUMEUP", "KEY_BASSBOOST", + "KEY_BASSUP", "KEY_BASSDOWN", "KEY_TREBLEUP", "KEY_TREBLEDOWN", "KEY_MEDIAPLAY", + "KEY_MEDIASTOP", "KEY_MEDIAPREVIOUS", "KEY_MEDIANEXT", "KEY_MEDIARECORD", "KEY_HOMEPAGE", + "KEY_FAVORITES", "KEY_SEARCH", "KEY_STANDBY", "KEY_OPENURL", "KEY_LAUNCHMAIL", + "KEY_LAUNCHMEDIA", "KEY_LAUNCH0", "KEY_LAUNCH1", "KEY_LAUNCH2", "KEY_LAUNCH3", "KEY_LAUNCH4", + "KEY_LAUNCH5", "KEY_LAUNCH6", "KEY_LAUNCH7", "KEY_LAUNCH8", "KEY_LAUNCH9", "KEY_LAUNCHA", + "KEY_LAUNCHB", "KEY_LAUNCHC", "KEY_LAUNCHD", "KEY_LAUNCHE", "KEY_LAUNCHF", "KEY_UNKNOWN", + "KEY_SPACE", "KEY_EXCLAM", "KEY_QUOTEDBL", "KEY_NUMBERSIGN", "KEY_DOLLAR", "KEY_PERCENT", + "KEY_AMPERSAND", "KEY_APOSTROPHE", "KEY_PARENLEFT", "KEY_PARENRIGHT", "KEY_ASTERISK", + "KEY_PLUS", "KEY_COMMA", "KEY_MINUS", "KEY_PERIOD", "KEY_SLASH", "KEY_0", "KEY_1", "KEY_2", + "KEY_3", "KEY_4", "KEY_5", "KEY_6", "KEY_7", "KEY_8", "KEY_9", "KEY_COLON", "KEY_SEMICOLON", + "KEY_LESS", "KEY_EQUAL", "KEY_GREATER", "KEY_QUESTION", "KEY_AT", "KEY_A", "KEY_B", "KEY_C", + "KEY_D", "KEY_E", "KEY_F", "KEY_G", "KEY_H", "KEY_I", "KEY_J", "KEY_K", "KEY_L", "KEY_M", + "KEY_N", "KEY_O", "KEY_P", "KEY_Q", "KEY_R", "KEY_S", "KEY_T", "KEY_U", "KEY_V", "KEY_W", + "KEY_X", "KEY_Y", "KEY_Z", "KEY_BRACKETLEFT", "KEY_BACKSLASH", "KEY_BRACKETRIGHT", + "KEY_ASCIICIRCUM", "KEY_UNDERSCORE", "KEY_QUOTELEFT", "KEY_BRACELEFT", "KEY_BAR", + "KEY_BRACERIGHT", "KEY_ASCIITILDE", "KEY_NOBREAKSPACE", "KEY_EXCLAMDOWN", "KEY_CENT", + "KEY_STERLING", "KEY_CURRENCY", "KEY_YEN", "KEY_BROKENBAR", "KEY_SECTION", "KEY_DIAERESIS", + "KEY_COPYRIGHT", "KEY_ORDFEMININE", "KEY_GUILLEMOTLEFT", "KEY_NOTSIGN", "KEY_HYPHEN", + "KEY_REGISTERED", "KEY_MACRON", "KEY_DEGREE", "KEY_PLUSMINUS", "KEY_TWOSUPERIOR", + "KEY_THREESUPERIOR", "KEY_ACUTE", "KEY_MU", "KEY_PARAGRAPH", "KEY_PERIODCENTERED", + "KEY_CEDILLA", "KEY_ONESUPERIOR", "KEY_MASCULINE", "KEY_GUILLEMOTRIGHT", "KEY_ONEQUARTER", + "KEY_ONEHALF", "KEY_THREEQUARTERS", "KEY_QUESTIONDOWN", "KEY_AGRAVE", "KEY_AACUTE", + "KEY_ACIRCUMFLEX", "KEY_ATILDE", "KEY_ADIAERESIS", "KEY_ARING", "KEY_AE", "KEY_CCEDILLA", + "KEY_EGRAVE", "KEY_EACUTE", "KEY_ECIRCUMFLEX", "KEY_EDIAERESIS", "KEY_IGRAVE", "KEY_IACUTE", + "KEY_ICIRCUMFLEX", "KEY_IDIAERESIS", "KEY_ETH", "KEY_NTILDE", "KEY_OGRAVE", "KEY_OACUTE", + "KEY_OCIRCUMFLEX", "KEY_OTILDE", "KEY_ODIAERESIS", "KEY_MULTIPLY", "KEY_OOBLIQUE", + "KEY_UGRAVE", "KEY_UACUTE", "KEY_UCIRCUMFLEX", "KEY_UDIAERESIS", "KEY_YACUTE", "KEY_THORN", + "KEY_SSHARP", "KEY_DIVISION", "KEY_YDIAERESIS", "KEY_CODE_MASK", "KEY_MODIFIER_MASK", + "KEY_MASK_CMD_OR_CTRL", "KEY_MASK_SHIFT", "KEY_MASK_ALT", "KEY_MASK_META", "KEY_MASK_CTRL", + "KEY_MASK_KPAD", "KEY_MASK_GROUP_SWITCH", "MOUSE_BUTTON_NONE", "MOUSE_BUTTON_LEFT", + "MOUSE_BUTTON_RIGHT", "MOUSE_BUTTON_MIDDLE", "MOUSE_BUTTON_WHEEL_UP", + "MOUSE_BUTTON_WHEEL_DOWN", "MOUSE_BUTTON_WHEEL_LEFT", "MOUSE_BUTTON_WHEEL_RIGHT", + "MOUSE_BUTTON_XBUTTON1", "MOUSE_BUTTON_XBUTTON2", "MOUSE_BUTTON_MASK_LEFT", + "MOUSE_BUTTON_MASK_RIGHT", "MOUSE_BUTTON_MASK_MIDDLE", "MOUSE_BUTTON_MASK_XBUTTON1", + "MOUSE_BUTTON_MASK_XBUTTON2", "JOY_BUTTON_INVALID", "JOY_BUTTON_A", "JOY_BUTTON_B", + "JOY_BUTTON_X", "JOY_BUTTON_Y", "JOY_BUTTON_BACK", "JOY_BUTTON_GUIDE", "JOY_BUTTON_START", + "JOY_BUTTON_LEFT_STICK", "JOY_BUTTON_RIGHT_STICK", "JOY_BUTTON_LEFT_SHOULDER", + "JOY_BUTTON_RIGHT_SHOULDER", "JOY_BUTTON_DPAD_UP", "JOY_BUTTON_DPAD_DOWN", + "JOY_BUTTON_DPAD_LEFT", "JOY_BUTTON_DPAD_RIGHT", "JOY_BUTTON_MISC1", "JOY_BUTTON_PADDLE1", + "JOY_BUTTON_PADDLE2", "JOY_BUTTON_PADDLE3", "JOY_BUTTON_PADDLE4", "JOY_BUTTON_TOUCHPAD", + "JOY_BUTTON_SDL_MAX", "JOY_BUTTON_MAX", "JOY_AXIS_INVALID", "JOY_AXIS_LEFT_X", + "JOY_AXIS_LEFT_Y", "JOY_AXIS_RIGHT_X", "JOY_AXIS_RIGHT_Y", "JOY_AXIS_TRIGGER_LEFT", + "JOY_AXIS_TRIGGER_RIGHT", "JOY_AXIS_SDL_MAX", "JOY_AXIS_MAX", "MIDI_MESSAGE_NONE", + "MIDI_MESSAGE_NOTE_OFF", "MIDI_MESSAGE_NOTE_ON", "MIDI_MESSAGE_AFTERTOUCH", + "MIDI_MESSAGE_CONTROL_CHANGE", "MIDI_MESSAGE_PROGRAM_CHANGE", "MIDI_MESSAGE_CHANNEL_PRESSURE", + "MIDI_MESSAGE_PITCH_BEND", "MIDI_MESSAGE_SYSTEM_EXCLUSIVE", "MIDI_MESSAGE_QUARTER_FRAME", + "MIDI_MESSAGE_SONG_POSITION_POINTER", "MIDI_MESSAGE_SONG_SELECT", "MIDI_MESSAGE_TUNE_REQUEST", + "MIDI_MESSAGE_TIMING_CLOCK", "MIDI_MESSAGE_START", "MIDI_MESSAGE_CONTINUE", + "MIDI_MESSAGE_STOP", "MIDI_MESSAGE_ACTIVE_SENSING", "MIDI_MESSAGE_SYSTEM_RESET", "OK", + "FAILED", "ERR_UNAVAILABLE", "ERR_UNCONFIGURED", "ERR_UNAUTHORIZED", + "ERR_PARAMETER_RANGE_ERROR", "ERR_OUT_OF_MEMORY", "ERR_FILE_NOT_FOUND", "ERR_FILE_BAD_DRIVE", + "ERR_FILE_BAD_PATH", "ERR_FILE_NO_PERMISSION", "ERR_FILE_ALREADY_IN_USE", + "ERR_FILE_CANT_OPEN", "ERR_FILE_CANT_WRITE", "ERR_FILE_CANT_READ", "ERR_FILE_UNRECOGNIZED", + "ERR_FILE_CORRUPT", "ERR_FILE_MISSING_DEPENDENCIES", "ERR_FILE_EOF", "ERR_CANT_OPEN", + "ERR_CANT_CREATE", "ERR_QUERY_FAILED", "ERR_ALREADY_IN_USE", "ERR_LOCKED", "ERR_TIMEOUT", + "ERR_CANT_CONNECT", "ERR_CANT_RESOLVE", "ERR_CONNECTION_ERROR", "ERR_CANT_ACQUIRE_RESOURCE", + "ERR_CANT_FORK", "ERR_INVALID_DATA", "ERR_INVALID_PARAMETER", "ERR_ALREADY_EXISTS", + "ERR_DOES_NOT_EXIST", "ERR_DATABASE_CANT_READ", "ERR_DATABASE_CANT_WRITE", + "ERR_COMPILATION_FAILED", "ERR_METHOD_NOT_FOUND", "ERR_LINK_FAILED", "ERR_SCRIPT_FAILED", + "ERR_CYCLIC_LINK", "ERR_INVALID_DECLARATION", "ERR_DUPLICATE_SYMBOL", "ERR_PARSE_ERROR", + "ERR_BUSY", "ERR_SKIP", "ERR_HELP", "ERR_BUG", "ERR_PRINTER_ON_FIRE", "PROPERTY_HINT_NONE", + "PROPERTY_HINT_RANGE", "PROPERTY_HINT_ENUM", "PROPERTY_HINT_ENUM_SUGGESTION", + "PROPERTY_HINT_EXP_EASING", "PROPERTY_HINT_LINK", "PROPERTY_HINT_FLAGS", + "PROPERTY_HINT_LAYERS_2D_RENDER", "PROPERTY_HINT_LAYERS_2D_PHYSICS", + "PROPERTY_HINT_LAYERS_2D_NAVIGATION", "PROPERTY_HINT_LAYERS_3D_RENDER", + "PROPERTY_HINT_LAYERS_3D_PHYSICS", "PROPERTY_HINT_LAYERS_3D_NAVIGATION", "PROPERTY_HINT_FILE", + "PROPERTY_HINT_DIR", "PROPERTY_HINT_GLOBAL_FILE", "PROPERTY_HINT_GLOBAL_DIR", + "PROPERTY_HINT_RESOURCE_TYPE", "PROPERTY_HINT_MULTILINE_TEXT", "PROPERTY_HINT_EXPRESSION", + "PROPERTY_HINT_PLACEHOLDER_TEXT", "PROPERTY_HINT_COLOR_NO_ALPHA", + "PROPERTY_HINT_IMAGE_COMPRESS_LOSSY", "PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS", + "PROPERTY_HINT_OBJECT_ID", "PROPERTY_HINT_TYPE_STRING", + "PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE", "PROPERTY_HINT_METHOD_OF_VARIANT_TYPE", + "PROPERTY_HINT_METHOD_OF_BASE_TYPE", "PROPERTY_HINT_METHOD_OF_INSTANCE", + "PROPERTY_HINT_METHOD_OF_SCRIPT", "PROPERTY_HINT_PROPERTY_OF_VARIANT_TYPE", + "PROPERTY_HINT_PROPERTY_OF_BASE_TYPE", "PROPERTY_HINT_PROPERTY_OF_INSTANCE", + "PROPERTY_HINT_PROPERTY_OF_SCRIPT", "PROPERTY_HINT_OBJECT_TOO_BIG", + "PROPERTY_HINT_NODE_PATH_VALID_TYPES", "PROPERTY_HINT_SAVE_FILE", + "PROPERTY_HINT_GLOBAL_SAVE_FILE", "PROPERTY_HINT_INT_IS_OBJECTID", + "PROPERTY_HINT_INT_IS_POINTER", "PROPERTY_HINT_ARRAY_TYPE", "PROPERTY_HINT_LOCALE_ID", + "PROPERTY_HINT_LOCALIZABLE_STRING", "PROPERTY_HINT_NODE_TYPE", + "PROPERTY_HINT_HIDE_QUATERNION_EDIT", "PROPERTY_HINT_PASSWORD", "PROPERTY_HINT_MAX", + "PROPERTY_USAGE_NONE", "PROPERTY_USAGE_STORAGE", "PROPERTY_USAGE_EDITOR", + "PROPERTY_USAGE_CHECKABLE", "PROPERTY_USAGE_CHECKED", "PROPERTY_USAGE_INTERNATIONALIZED", + "PROPERTY_USAGE_GROUP", "PROPERTY_USAGE_CATEGORY", "PROPERTY_USAGE_SUBGROUP", + "PROPERTY_USAGE_CLASS_IS_BITFIELD", "PROPERTY_USAGE_NO_INSTANCE_STATE", + "PROPERTY_USAGE_RESTART_IF_CHANGED", "PROPERTY_USAGE_SCRIPT_VARIABLE", + "PROPERTY_USAGE_STORE_IF_NULL", "PROPERTY_USAGE_ANIMATE_AS_TRIGGER", + "PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED", "PROPERTY_USAGE_SCRIPT_DEFAULT_VALUE", + "PROPERTY_USAGE_CLASS_IS_ENUM", "PROPERTY_USAGE_NIL_IS_VARIANT", "PROPERTY_USAGE_INTERNAL", + "PROPERTY_USAGE_DO_NOT_SHARE_ON_DUPLICATE", "PROPERTY_USAGE_HIGH_END_GFX", + "PROPERTY_USAGE_NODE_PATH_FROM_SCENE_ROOT", "PROPERTY_USAGE_RESOURCE_NOT_PERSISTENT", + "PROPERTY_USAGE_KEYING_INCREMENTS", "PROPERTY_USAGE_DEFERRED_SET_RESOURCE", + "PROPERTY_USAGE_EDITOR_INSTANTIATE_OBJECT", "PROPERTY_USAGE_EDITOR_BASIC_SETTING", + "PROPERTY_USAGE_READ_ONLY", "PROPERTY_USAGE_ARRAY", "PROPERTY_USAGE_DEFAULT", + "PROPERTY_USAGE_DEFAULT_INTL", "PROPERTY_USAGE_NO_EDITOR", "METHOD_FLAG_NORMAL", + "METHOD_FLAG_EDITOR", "METHOD_FLAG_CONST", "METHOD_FLAG_VIRTUAL", "METHOD_FLAG_VARARG", + "METHOD_FLAG_STATIC", "METHOD_FLAG_OBJECT_CORE", "METHOD_FLAGS_DEFAULT", "TYPE_NIL", + "TYPE_BOOL", "TYPE_INT", "TYPE_FLOAT", "TYPE_STRING", "TYPE_VECTOR2", "TYPE_VECTOR2I", + "TYPE_RECT2", "TYPE_RECT2I", "TYPE_VECTOR3", "TYPE_VECTOR3I", "TYPE_TRANSFORM2D", + "TYPE_VECTOR4", "TYPE_VECTOR4I", "TYPE_PLANE", "TYPE_QUATERNION", "TYPE_AABB", "TYPE_BASIS", + "TYPE_TRANSFORM3D", "TYPE_PROJECTION", "TYPE_COLOR", "TYPE_STRING_NAME", "TYPE_NODE_PATH", + "TYPE_RID", "TYPE_OBJECT", "TYPE_CALLABLE", "TYPE_SIGNAL", "TYPE_DICTIONARY", "TYPE_ARRAY", + "TYPE_PACKED_BYTE_ARRAY", "TYPE_PACKED_INT32_ARRAY", "TYPE_PACKED_INT64_ARRAY", + "TYPE_PACKED_FLOAT32_ARRAY", "TYPE_PACKED_FLOAT64_ARRAY", "TYPE_PACKED_STRING_ARRAY", + "TYPE_PACKED_VECTOR2_ARRAY", "TYPE_PACKED_VECTOR3_ARRAY", "TYPE_PACKED_COLOR_ARRAY", + "TYPE_MAX", "OP_EQUAL", "OP_NOT_EQUAL", "OP_LESS", "OP_LESS_EQUAL", "OP_GREATER", + "OP_GREATER_EQUAL", "OP_ADD", "OP_SUBTRACT", "OP_MULTIPLY", "OP_DIVIDE", "OP_NEGATE", + "OP_POSITIVE", "OP_MODULE", "OP_POWER", "OP_SHIFT_LEFT", "OP_SHIFT_RIGHT", "OP_BIT_AND", + "OP_BIT_OR", "OP_BIT_XOR", "OP_BIT_NEGATE", "OP_AND", "OP_OR", "OP_XOR", "OP_NOT", "OP_IN", + // Godot's singletons + "OP_MAX", "AudioServer", "CameraServer", "ClassDB", "DisplayServer", "Engine", + "EngineDebugger", "Geometry2D", "Geometry3D", "GodotSharp", "IP", "Input", "InputMap", + "JavaClassWrapper", "JavaScriptBridge", "Marshalls", "NativeExtensionManager", + "NavigationMeshGenerator", "NavigationServer2D", "NavigationServer3D", "OS", "Performance", + "PhysicsServer2D", "PhysicsServer2DManager", "PhysicsServer3D", "PhysicsServer3DManager", + "ProjectSettings", "RenderingServer", "ResourceLoader", "ResourceSaver", "ResourceUID", + "TextServerManager", "ThemeDB", "Time", "TranslationServer", "WorkerThreadPool", "XRServer", + + // Tokens from GDScript + // https://github.com/godotengine/godot/blob/master/modules/gdscript/gdscript_tokenizer.cpp + // Logical + "and", "or", "not", + // Control flow + "if", "elif", "else", "for", "while", "break", "continue", "pass", "return", "match", + // Keywords – hey, namespace is here, and so is trait ! + "as", "assert", "await", "breakpoint", "class", "class_name", "const", "enum", "extends", + "func", "in", "is", "namespace", "preload", "self", "signal", "static", "super", "trait", + "var", "void", "yield", + // Constants + "PI", "TAU", "INF", "NaN", + + // Types TODO: extract all types from somewhere ; we're going to need all the Nodes, as well ?! + "float", "int", "String", "bool", "Dictionary", "Array", "Color", + "Quat", "Vector2", "Vector3", "Transform" + ); + } } diff --git a/samples/client/petstore/gdscript/.gitignore b/samples/client/petstore/gdscript/.gitignore new file mode 100644 index 000000000000..ab9304dace02 --- /dev/null +++ b/samples/client/petstore/gdscript/.gitignore @@ -0,0 +1,4 @@ +# Godot 4+ specific ignores +.godot/ + +*.import diff --git a/samples/client/petstore/gdscript/.openapi-generator/FILES b/samples/client/petstore/gdscript/.openapi-generator/FILES index b7c810143726..4538487dd240 100644 --- a/samples/client/petstore/gdscript/.openapi-generator/FILES +++ b/samples/client/petstore/gdscript/.openapi-generator/FILES @@ -1,3 +1,4 @@ +.openapi-generator-ignore README.md apis/PetApi.gd apis/StoreApi.gd diff --git a/samples/client/petstore/gdscript/Logger.gd b/samples/client/petstore/gdscript/Logger.gd new file mode 100644 index 000000000000..aca925fc3754 --- /dev/null +++ b/samples/client/petstore/gdscript/Logger.gd @@ -0,0 +1,46 @@ +extends Node + +# Singleton helper to log to console and some text edit. + +enum LOG_LEVEL { + DEBUG, # → see all + INFO, + WARN, + ERROR, + SILENT, # → see none +} + +var log_level := LOG_LEVEL.DEBUG +var text_edit_to_fill: TextEdit + +func __print(msg: String): + print(msg) + if text_edit_to_fill: + text_edit_to_fill.text += "%s\n" % msg + +func __printerr(msg: String): + printerr(msg) + if text_edit_to_fill: + text_edit_to_fill.text += "\nERROR: %s\n\n" % msg + +func debug(msg: String): + if self.log_level == LOG_LEVEL.DEBUG: + __print(msg) + +func info(msg: String): + inform(msg) + +func inform(msg: String): + if self.log_level == LOG_LEVEL.DEBUG || self.log_level == LOG_LEVEL.INFO: + __print(msg) + +func warn(msg: String): + if self.log_level != LOG_LEVEL.ERROR && self.log_level != LOG_LEVEL.SILENT: + __printerr(msg) + +func error(msg: String): + shout(msg) + +func shout(msg: String): + if self.log_level != LOG_LEVEL.SILENT: + __printerr(msg) diff --git a/samples/client/petstore/gdscript/README.md b/samples/client/petstore/gdscript/README.md index cf1e83b28ba8..82396e7b2ca1 100644 --- a/samples/client/petstore/gdscript/README.md +++ b/samples/client/petstore/gdscript/README.md @@ -1,4 +1,5 @@ # + This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters. This Godot 4 addon is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: diff --git a/samples/client/petstore/gdscript/apis/PetApi.gd b/samples/client/petstore/gdscript/apis/PetApi.gd index e6db0951f6dd..f8c6457bdd56 100644 --- a/samples/client/petstore/gdscript/apis/PetApi.gd +++ b/samples/client/petstore/gdscript/apis/PetApi.gd @@ -40,15 +40,15 @@ class PetApi: bee_request( bzz_method, bzz_path, bzz_query, - func(result, code, headers): + func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') - #print(result) - on_success.call(result) + #print(bzz_result) + on_success.call(bzz_result) , # ざわ‥ - func(error): + func(bzz_error): #printerr("FAILURE!") - #print(error) - on_failure.call(error) + #print(bzz_error) + on_failure.call(bzz_error) , # ざわ‥ ) @@ -82,15 +82,15 @@ class PetApi: bee_request( bzz_method, bzz_path, bzz_query, - func(result, code, headers): + func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') - #print(result) - on_success.call(result) + #print(bzz_result) + on_success.call(bzz_result) , # ざわ‥ - func(error): + func(bzz_error): #printerr("FAILURE!") - #print(error) - on_failure.call(error) + #print(bzz_error) + on_failure.call(bzz_error) , # ざわ‥ ) @@ -131,15 +131,15 @@ class PetApi: bee_request( bzz_method, bzz_path, bzz_query, - func(result, code, headers): + func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') - #print(result) - on_success.call(result) + #print(bzz_result) + on_success.call(bzz_result) , # ざわ‥ - func(error): + func(bzz_error): #printerr("FAILURE!") - #print(error) - on_failure.call(error) + #print(bzz_error) + on_failure.call(bzz_error) , # ざわ‥ ) @@ -181,15 +181,15 @@ class PetApi: bee_request( bzz_method, bzz_path, bzz_query, - func(result, code, headers): + func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') - #print(result) - on_success.call(result) + #print(bzz_result) + on_success.call(bzz_result) , # ざわ‥ - func(error): + func(bzz_error): #printerr("FAILURE!") - #print(error) - on_failure.call(error) + #print(bzz_error) + on_failure.call(bzz_error) , # ざわ‥ ) @@ -229,15 +229,15 @@ class PetApi: bee_request( bzz_method, bzz_path, bzz_query, - func(result, code, headers): + func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') - #print(result) - on_success.call(result) + #print(bzz_result) + on_success.call(bzz_result) , # ざわ‥ - func(error): + func(bzz_error): #printerr("FAILURE!") - #print(error) - on_failure.call(error) + #print(bzz_error) + on_failure.call(bzz_error) , # ざわ‥ ) @@ -275,15 +275,15 @@ class PetApi: bee_request( bzz_method, bzz_path, bzz_query, - func(result, code, headers): + func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') - #print(result) - on_success.call(result) + #print(bzz_result) + on_success.call(bzz_result) , # ざわ‥ - func(error): + func(bzz_error): #printerr("FAILURE!") - #print(error) - on_failure.call(error) + #print(bzz_error) + on_failure.call(bzz_error) , # ざわ‥ ) @@ -320,15 +320,15 @@ class PetApi: bee_request( bzz_method, bzz_path, bzz_query, - func(result, code, headers): + func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') - #print(result) - on_success.call(result) + #print(bzz_result) + on_success.call(bzz_result) , # ざわ‥ - func(error): + func(bzz_error): #printerr("FAILURE!") - #print(error) - on_failure.call(error) + #print(bzz_error) + on_failure.call(bzz_error) , # ざわ‥ ) @@ -372,15 +372,15 @@ class PetApi: bee_request( bzz_method, bzz_path, bzz_query, - func(result, code, headers): + func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') - #print(result) - on_success.call(result) + #print(bzz_result) + on_success.call(bzz_result) , # ざわ‥ - func(error): + func(bzz_error): #printerr("FAILURE!") - #print(error) - on_failure.call(error) + #print(bzz_error) + on_failure.call(bzz_error) , # ざわ‥ ) diff --git a/samples/client/petstore/gdscript/apis/StoreApi.gd b/samples/client/petstore/gdscript/apis/StoreApi.gd index e04c2234a577..f7a90a1d2cbf 100644 --- a/samples/client/petstore/gdscript/apis/StoreApi.gd +++ b/samples/client/petstore/gdscript/apis/StoreApi.gd @@ -35,15 +35,15 @@ class StoreApi: bee_request( bzz_method, bzz_path, bzz_query, - func(result, code, headers): + func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') - #print(result) - on_success.call(result) + #print(bzz_result) + on_success.call(bzz_result) , # ざわ‥ - func(error): + func(bzz_error): #printerr("FAILURE!") - #print(error) - on_failure.call(error) + #print(bzz_error) + on_failure.call(bzz_error) , # ざわ‥ ) @@ -80,15 +80,15 @@ class StoreApi: bee_request( bzz_method, bzz_path, bzz_query, - func(result, code, headers): + func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') - #print(result) - on_success.call(result) + #print(bzz_result) + on_success.call(bzz_result) , # ざわ‥ - func(error): + func(bzz_error): #printerr("FAILURE!") - #print(error) - on_failure.call(error) + #print(bzz_error) + on_failure.call(bzz_error) , # ざわ‥ ) @@ -128,15 +128,15 @@ class StoreApi: bee_request( bzz_method, bzz_path, bzz_query, - func(result, code, headers): + func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') - #print(result) - on_success.call(result) + #print(bzz_result) + on_success.call(bzz_result) , # ざわ‥ - func(error): + func(bzz_error): #printerr("FAILURE!") - #print(error) - on_failure.call(error) + #print(bzz_error) + on_failure.call(bzz_error) , # ざわ‥ ) @@ -174,15 +174,15 @@ class StoreApi: bee_request( bzz_method, bzz_path, bzz_query, - func(result, code, headers): + func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') - #print(result) - on_success.call(result) + #print(bzz_result) + on_success.call(bzz_result) , # ざわ‥ - func(error): + func(bzz_error): #printerr("FAILURE!") - #print(error) - on_failure.call(error) + #print(bzz_error) + on_failure.call(bzz_error) , # ざわ‥ ) diff --git a/samples/client/petstore/gdscript/apis/UserApi.gd b/samples/client/petstore/gdscript/apis/UserApi.gd index d5ec7f33e2f4..e35483e8dcc5 100644 --- a/samples/client/petstore/gdscript/apis/UserApi.gd +++ b/samples/client/petstore/gdscript/apis/UserApi.gd @@ -35,15 +35,15 @@ class UserApi: bee_request( bzz_method, bzz_path, bzz_query, - func(result, code, headers): + func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') - #print(result) - on_success.call(result) + #print(bzz_result) + on_success.call(bzz_result) , # ざわ‥ - func(error): + func(bzz_error): #printerr("FAILURE!") - #print(error) - on_failure.call(error) + #print(bzz_error) + on_failure.call(bzz_error) , # ざわ‥ ) @@ -74,15 +74,15 @@ class UserApi: bee_request( bzz_method, bzz_path, bzz_query, - func(result, code, headers): + func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') - #print(result) - on_success.call(result) + #print(bzz_result) + on_success.call(bzz_result) , # ざわ‥ - func(error): + func(bzz_error): #printerr("FAILURE!") - #print(error) - on_failure.call(error) + #print(bzz_error) + on_failure.call(bzz_error) , # ざわ‥ ) @@ -113,15 +113,15 @@ class UserApi: bee_request( bzz_method, bzz_path, bzz_query, - func(result, code, headers): + func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') - #print(result) - on_success.call(result) + #print(bzz_result) + on_success.call(bzz_result) , # ざわ‥ - func(error): + func(bzz_error): #printerr("FAILURE!") - #print(error) - on_failure.call(error) + #print(bzz_error) + on_failure.call(bzz_error) , # ざわ‥ ) @@ -154,15 +154,15 @@ class UserApi: bee_request( bzz_method, bzz_path, bzz_query, - func(result, code, headers): + func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') - #print(result) - on_success.call(result) + #print(bzz_result) + on_success.call(bzz_result) , # ざわ‥ - func(error): + func(bzz_error): #printerr("FAILURE!") - #print(error) - on_failure.call(error) + #print(bzz_error) + on_failure.call(bzz_error) , # ざわ‥ ) @@ -200,15 +200,15 @@ class UserApi: bee_request( bzz_method, bzz_path, bzz_query, - func(result, code, headers): + func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') - #print(result) - on_success.call(result) + #print(bzz_result) + on_success.call(bzz_result) , # ざわ‥ - func(error): + func(bzz_error): #printerr("FAILURE!") - #print(error) - on_failure.call(error) + #print(bzz_error) + on_failure.call(bzz_error) , # ざわ‥ ) @@ -251,15 +251,15 @@ class UserApi: bee_request( bzz_method, bzz_path, bzz_query, - func(result, code, headers): + func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') - #print(result) - on_success.call(result) + #print(bzz_result) + on_success.call(bzz_result) , # ざわ‥ - func(error): + func(bzz_error): #printerr("FAILURE!") - #print(error) - on_failure.call(error) + #print(bzz_error) + on_failure.call(bzz_error) , # ざわ‥ ) @@ -287,15 +287,15 @@ class UserApi: bee_request( bzz_method, bzz_path, bzz_query, - func(result, code, headers): + func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') - #print(result) - on_success.call(result) + #print(bzz_result) + on_success.call(bzz_result) , # ざわ‥ - func(error): + func(bzz_error): #printerr("FAILURE!") - #print(error) - on_failure.call(error) + #print(bzz_error) + on_failure.call(bzz_error) , # ざわ‥ ) @@ -331,15 +331,15 @@ class UserApi: bee_request( bzz_method, bzz_path, bzz_query, - func(result, code, headers): + func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') - #print(result) - on_success.call(result) + #print(bzz_result) + on_success.call(bzz_result) , # ざわ‥ - func(error): + func(bzz_error): #printerr("FAILURE!") - #print(error) - on_failure.call(error) + #print(bzz_error) + on_failure.call(bzz_error) , # ざわ‥ ) diff --git a/samples/client/petstore/gdscript/icon.svg b/samples/client/petstore/gdscript/icon.svg new file mode 100644 index 000000000000..adc26df6c2cd --- /dev/null +++ b/samples/client/petstore/gdscript/icon.svg @@ -0,0 +1 @@ + diff --git a/samples/client/petstore/gdscript/main.gd b/samples/client/petstore/gdscript/main.gd new file mode 100644 index 000000000000..a199e0cf5f8a --- /dev/null +++ b/samples/client/petstore/gdscript/main.gd @@ -0,0 +1,15 @@ +extends Control + + +func _ready(): + Logger.text_edit_to_fill = $HBoxContainer/LogDump + Logger.inform("Petstore demo is ready.") + + +func _on_exit_button_pressed(): + Logger.inform("Goodbye.") + get_tree().quit() + + +func _on_run_tests_button_pressed(): + pass # Replace with function body. diff --git a/samples/client/petstore/gdscript/main.tscn b/samples/client/petstore/gdscript/main.tscn new file mode 100644 index 000000000000..dc1ab64c58c2 --- /dev/null +++ b/samples/client/petstore/gdscript/main.tscn @@ -0,0 +1,62 @@ +[gd_scene load_steps=3 format=3 uid="uid://dyht2e7myo04l"] + +[ext_resource type="Script" path="res://main.gd" id="1_226ps"] + +[sub_resource type="CodeHighlighter" id="CodeHighlighter_mtjt2"] +number_color = Color(0, 0.843137, 0.341176, 1) +symbol_color = Color(1, 1, 1, 1) +function_color = Color(0.929412, 0.929412, 0.929412, 1) +member_variable_color = Color(0.764706, 0.764706, 0.764706, 1) + +[node name="Main" type="Control"] +layout_mode = 3 +anchors_preset = 15 +anchor_right = 1.0 +anchor_bottom = 1.0 +script = ExtResource("1_226ps") + +[node name="HBoxContainer" type="HBoxContainer" parent="."] +layout_mode = 1 +anchors_preset = 15 +anchor_right = 1.0 +anchor_bottom = 1.0 +grow_horizontal = 2 +grow_vertical = 2 + +[node name="VBoxContainer" type="VBoxContainer" parent="HBoxContainer"] +layout_mode = 2 +offset_right = 100.0 +offset_bottom = 648.0 + +[node name="RunTestsButton" type="Button" parent="HBoxContainer/VBoxContainer"] +layout_mode = 2 +offset_right = 100.0 +offset_bottom = 322.0 +size_flags_vertical = 3 +text = " Run Tests " + +[node name="ExitButton" type="Button" parent="HBoxContainer/VBoxContainer"] +layout_mode = 2 +offset_top = 326.0 +offset_right = 100.0 +offset_bottom = 648.0 +size_flags_vertical = 3 +text = " Exit " + +[node name="LogDump" type="TextEdit" parent="HBoxContainer"] +layout_mode = 2 +offset_left = 104.0 +offset_right = 1152.0 +offset_bottom = 648.0 +grow_horizontal = 2 +grow_vertical = 2 +size_flags_horizontal = 3 +editable = false +virtual_keyboard_enabled = false +middle_mouse_paste_enabled = false +wrap_mode = 1 +syntax_highlighter = SubResource("CodeHighlighter_mtjt2") +scroll_past_end_of_file = true + +[connection signal="pressed" from="HBoxContainer/VBoxContainer/RunTestsButton" to="." method="_on_run_tests_button_pressed"] +[connection signal="pressed" from="HBoxContainer/VBoxContainer/ExitButton" to="." method="_on_exit_button_pressed"] diff --git a/samples/client/petstore/gdscript/project.godot b/samples/client/petstore/gdscript/project.godot new file mode 100644 index 000000000000..4114b4e98eab --- /dev/null +++ b/samples/client/petstore/gdscript/project.godot @@ -0,0 +1,36 @@ +; Engine configuration file. +; It's best edited using the editor UI and not directly, +; since the parameters that go here are not all obvious. +; +; Format: +; [section] ; section goes between [] +; param=value ; assign values to parameters + +config_version=5 + +_global_script_classes=[{ +"base": "RefCounted", +"class": &"ApiBee", +"language": &"GDScript", +"path": "res://core/ApiBee.gd" +}, { +"base": "Resource", +"class": &"ApiError", +"language": &"GDScript", +"path": "res://core/ApiError.gd" +}] +_global_script_class_icons={ +"ApiBee": "", +"ApiError": "" +} + +[application] + +config/name="GDScript Petstore Client" +run/main_scene="res://main.tscn" +config/features=PackedStringArray("4.0", "Forward Plus") +config/icon="res://icon.svg" + +[autoload] + +Logger="*res://Logger.gd" From f7366fbf1c8933e709eb0b3c8198a939b21a9cce Mon Sep 17 00:00:00 2001 From: Goutte Date: Thu, 20 Oct 2022 00:43:30 +0200 Subject: [PATCH 05/56] fix(gdscript): do not use subclasses, use plain POGO (plain ol' godot object) One: I don't know how they work under-the-hood. Two: I'm very confused over-the-hood. Tri: We do not need them. --- .../languages/GdscriptClientCodegen.java | 2 + .../main/resources/gdscript/api.handlebars | 106 +-- .../main/resources/gdscript/model.handlebars | 34 +- .../gdscript/partials/api_headers.handlebars | 2 +- .../api_statement_class_name.handlebars | 1 + .../disclaimer_autogenerated.handlebars | 1 + .../partials/model_headers.handlebars | 1 + .../model_statement_class_name.handlebars | 1 + .../model_statement_extends.handlebars | 1 + .../partials/statement_class_name.handlebars | 1 + .../gdscript/.openapi-generator/FILES | 1 - .../client/petstore/gdscript/apis/PetApi.gd | 760 +++++++++--------- .../client/petstore/gdscript/apis/StoreApi.gd | 364 ++++----- .../client/petstore/gdscript/apis/UserApi.gd | 678 ++++++++-------- .../petstore/gdscript/models/ApiResponse.gd | 38 +- .../petstore/gdscript/models/Category.gd | 32 +- .../client/petstore/gdscript/models/Order.gd | 58 +- .../client/petstore/gdscript/models/Pet.gd | 62 +- .../client/petstore/gdscript/models/Tag.gd | 32 +- .../client/petstore/gdscript/models/User.gd | 70 +- 20 files changed, 1112 insertions(+), 1133 deletions(-) create mode 100644 modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_class_name.handlebars create mode 100644 modules/openapi-generator/src/main/resources/gdscript/partials/model_headers.handlebars create mode 100644 modules/openapi-generator/src/main/resources/gdscript/partials/model_statement_class_name.handlebars create mode 100644 modules/openapi-generator/src/main/resources/gdscript/partials/model_statement_extends.handlebars create mode 100644 modules/openapi-generator/src/main/resources/gdscript/partials/statement_class_name.handlebars diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java index 605669d4e9ea..49d3bd559b12 100644 --- a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java +++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java @@ -175,6 +175,8 @@ protected List getReservedWords() { "bzz_method", "bzz_path", "bzz_query", "bzz_result", "bzz_code", "bzz_headers", "bzz_error", + // Hmmm… Will be removed eventually. Promises ! ;) + "on_success", "on_failure", // Godot's Global Scope // https://github.com/godotengine/godot/blob/master/doc/classes/%40GlobalScope.xml diff --git a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars index 3d3d4adeedb4..4e1e79a074b3 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars @@ -1,77 +1,77 @@ {{>partials/api_headers}} + # API {{classname}} -{{>partials/api_statement_class}}: - {{>partials/api_statement_extends}} +{{>partials/api_statement_extends}} {{#with operations}} {{#each operation}} {{#if isDeprecated}} - # /!. DEPRECATED +# /!. DEPRECATED {{/if}} - # Operation {{operationId}} → {{httpMethod}} {{path}} +# Operation {{{operationId}}} → {{{httpMethod}}} {{{path}}} {{#if summary}} - # {{summary}} +# {{{summary}}} {{/if}} {{#if description}} - # - # {{description}} +# +# {{{description}}} {{/if}} {{#if notes}} - # - # {{notes}} +# +# {{{notes}}} {{/if}} - func {{operationIdSnakeCase}}( - {{#each allParams}} - # {{paramName}}{{#if dataType}}: {{dataType}}{{/if}}{{#if defaultValue}} = {{{defaultValue}}}{{/if}}{{#if example}} Eg: {{{example}}}{{/if}} - # {{description}} - {{paramName}}{{#if required}}{{#if dataType}}: {{{dataType}}}{{/if}}{{/if}}{{#unless required}} = {{#defaultValue}}{{{.}}}{{/defaultValue}}{{#unless defaultValue}}null{{/unless}}{{/unless}}, - {{/each}} - on_success: Callable, # func(result{{#if returnType}}: {{returnType}}{{/if}}) - on_failure: Callable # func(error: ApiError) - ): - # CollectionFormat: {{#if collectionFormat}}YES{{/if}}{{#unless collectionFormat}}NO{{/unless}} +func {{operationIdSnakeCase}}( + {{#each allParams}} + # {{paramName}}{{#if dataType}}: {{dataType}}{{/if}}{{#if defaultValue}} = {{{defaultValue}}}{{/if}}{{#if example}} Eg: {{{example}}}{{/if}} + # {{{description}}} + {{paramName}}{{#if required}}{{#if dataType}}: {{{dataType}}}{{/if}}{{/if}}{{#unless required}} = {{#defaultValue}}{{{.}}}{{/defaultValue}}{{#unless defaultValue}}null{{/unless}}{{/unless}}, + {{/each}} + on_success: Callable, # func(result{{#if returnType}}: {{returnType}}{{/if}}) + on_failure: Callable # func(error: ApiError) +): + # CollectionFormat: {{#if collectionFormat}}YES{{/if}}{{#unless collectionFormat}}NO{{/unless}} - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - # Compute the URL path to the API resource - var bzz_path := "{{{path}}}"{{#each pathParams}}.replace("{" + "{{baseName}}" + "}", bee_urlize_path_param({{{paramName}}})){{/each}} + # Compute the URL path to the API resource + var bzz_path := "{{{path}}}"{{#each pathParams}}.replace("{" + "{{baseName}}" + "}", bee_urlize_path_param({{{paramName}}})){{/each}} - # Collect the query parameters - # Note: we do not support multiple values for a single param (for now), nor arrays - var bzz_query := Dictionary() - {{#each queryParams}} - bzz_query["{{baseName}}"] = {{paramName}} - {{/each}} + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + var bzz_query := Dictionary() + {{#each queryParams}} + bzz_query["{{baseName}}"] = {{paramName}} + {{/each}} - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("{{httpMethod}}") + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("{{httpMethod}}") - {{#with returnProperty}} - # Will be used at some point for denormalization - # baseType = "{{{baseType}}}" - # openApiType = "{{{openApiType}}}" - # dataType = "{{{dataType}}}" - # complexType = "{{{complexType}}}" - # isArray = "{{{isArray}}}" - var bzz_return_type := "{{{baseType}}}" - {{/with}} + {{#with returnProperty}} + # Will be used at some point for denormalization + # baseType = "{{{baseType}}}" + # openApiType = "{{{openApiType}}}" + # dataType = "{{{dataType}}}" + # complexType = "{{{complexType}}}" + # isArray = "{{{isArray}}}" + var bzz_return_type := "{{{complexType}}}" + {{/with}} - bee_request( - bzz_method, bzz_path, bzz_query, - func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) - on_success.call(bzz_result) - , # ざわ‥ - func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) - on_failure.call(bzz_error) - , # ざわ‥ - ) + bee_request( + bzz_method, bzz_path, bzz_query, + func(bzz_result, bzz_code, bzz_headers): + #print('SUCCESS!') + #print(bzz_result) + on_success.call(bzz_result) + , # ざわ‥ + func(bzz_error): + #printerr("FAILURE!") + #print(bzz_error) + on_failure.call(bzz_error) + , # ざわ‥ + ) {{/each}} {{/with}} diff --git a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars index da64cc4a0c95..8d5d94b938ba 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars @@ -1,40 +1,36 @@ +{{>partials/api_headers}} + {{#each models}} {{#with model}} -# {{classname}} -# namespace: {{modelPackage}} -# package: {{invokerPackage}} -# author: OpenAPI Generator Community -# link: https://openapi-generator.tech - -# NOTE: This class is AUTO GENERATED by OpenAPI Generator (https://openapi-generator.tech). -# Best not edit the class manually. - # {{classname}} Model {{#if description}} # {{{description}}} {{/if}} -class {{classname}}: - extends RefCounted - class_name {{classname}} +# namespace: {{modelPackage}} +# invoker: {{invokerPackage}} + +{{>partials/api_statement_extends}} + +{{>partials/api_statement_class_name}} + {{#each vars}} {{#if deprecated}} - # /!. DEPRECATED +# /!. DEPRECATED {{/if}} {{#if description}} - # {{{description}}} +# {{{description}}} {{/if}} - # Type: {{dataType}} - # Required: {{#unless required}}False{{/unless}}{{#if required}}True{{/if}} +# Type: {{dataType}} +# Required: {{#unless required}}False{{/unless}}{{#if required}}True{{/if}} {{#if example}} - # Example: {{{example}}} +# Example: {{{example}}} {{/if}} - var {{name}}: {{dataType}}{{#if defaultValue}} = {{{defaultValue}}}{{/if}} +var {{name}}: {{dataType}}{{#if defaultValue}} = {{{defaultValue}}}{{/if}} {{/each}} - {{/with}} {{/each}} \ No newline at end of file diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/api_headers.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/api_headers.handlebars index 7949f58a71ba..abc3202e3550 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/partials/api_headers.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/api_headers.handlebars @@ -1 +1 @@ -{{>partials/disclaimer_autogenerated}} \ No newline at end of file +{{>partials/disclaimer_autogenerated}} diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_class_name.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_class_name.handlebars new file mode 100644 index 000000000000..d9bc3d09cb98 --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_class_name.handlebars @@ -0,0 +1 @@ +{{>partials/statement_class_name}} \ No newline at end of file diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/disclaimer_autogenerated.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/disclaimer_autogenerated.handlebars index c8d24dc182aa..cc37040af118 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/partials/disclaimer_autogenerated.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/disclaimer_autogenerated.handlebars @@ -1,3 +1,4 @@ # THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. # For more information on how to customize templates, see: # https://openapi-generator.tech +# The OpenAPI Generator Community, © Public Domain, 2022 \ No newline at end of file diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/model_headers.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/model_headers.handlebars new file mode 100644 index 000000000000..7949f58a71ba --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/model_headers.handlebars @@ -0,0 +1 @@ +{{>partials/disclaimer_autogenerated}} \ No newline at end of file diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/model_statement_class_name.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/model_statement_class_name.handlebars new file mode 100644 index 000000000000..d9bc3d09cb98 --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/model_statement_class_name.handlebars @@ -0,0 +1 @@ +{{>partials/statement_class_name}} \ No newline at end of file diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/model_statement_extends.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/model_statement_extends.handlebars new file mode 100644 index 000000000000..2a016ca16d51 --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/model_statement_extends.handlebars @@ -0,0 +1 @@ +extends RefCounted \ No newline at end of file diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/statement_class_name.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/statement_class_name.handlebars new file mode 100644 index 000000000000..a65cc1867eeb --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/statement_class_name.handlebars @@ -0,0 +1 @@ +class_name {{classname}} \ No newline at end of file diff --git a/samples/client/petstore/gdscript/.openapi-generator/FILES b/samples/client/petstore/gdscript/.openapi-generator/FILES index 4538487dd240..b7c810143726 100644 --- a/samples/client/petstore/gdscript/.openapi-generator/FILES +++ b/samples/client/petstore/gdscript/.openapi-generator/FILES @@ -1,4 +1,3 @@ -.openapi-generator-ignore README.md apis/PetApi.gd apis/StoreApi.gd diff --git a/samples/client/petstore/gdscript/apis/PetApi.gd b/samples/client/petstore/gdscript/apis/PetApi.gd index f8c6457bdd56..bf9ebd31a95f 100644 --- a/samples/client/petstore/gdscript/apis/PetApi.gd +++ b/samples/client/petstore/gdscript/apis/PetApi.gd @@ -1,386 +1,386 @@ # THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. # For more information on how to customize templates, see: # https://openapi-generator.tech +# The OpenAPI Generator Community, © Public Domain, 2022 # API PetApi -class PetApi: - extends ApiBee - - # Operation addPet → POST /pet - # Add a new pet to the store - func add_pet( - # pet: Pet - # Pet object that needs to be added to the store - pet: Pet, - on_success: Callable, # func(result: Pet) - on_failure: Callable # func(error: ApiError) - ): - # CollectionFormat: NO - - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - - # Compute the URL path to the API resource - var bzz_path := "/pet" - - # Collect the query parameters - # Note: we do not support multiple values for a single param (for now), nor arrays - var bzz_query := Dictionary() - - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("POST") - - # Will be used at some point for denormalization - # baseType = "Pet" - # openApiType = "Pet" - # dataType = "Pet" - # complexType = "Pet" - # isArray = "false" - var bzz_return_type := "Pet" - - bee_request( - bzz_method, bzz_path, bzz_query, - func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) - on_success.call(bzz_result) - , # ざわ‥ - func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) - on_failure.call(bzz_error) - , # ざわ‥ - ) - - # Operation deletePet → DELETE /pet/{petId} - # Deletes a pet - func delete_pet( - # petId: float Eg: 789 - # Pet id to delete - petId: float, - # apiKey: String Eg: apiKey_example - # - apiKey = null, - on_success: Callable, # func(result) - on_failure: Callable # func(error: ApiError) - ): - # CollectionFormat: NO - - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - - # Compute the URL path to the API resource - var bzz_path := "/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) - - # Collect the query parameters - # Note: we do not support multiple values for a single param (for now), nor arrays - var bzz_query := Dictionary() - - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("DELETE") - - - bee_request( - bzz_method, bzz_path, bzz_query, - func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) - on_success.call(bzz_result) - , # ざわ‥ - func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) - on_failure.call(bzz_error) - , # ざわ‥ - ) - - # Operation findPetsByStatus → GET /pet/findByStatus - # Finds Pets by status - # - # Multiple status values can be provided with comma separated strings - func find_pets_by_status( - # status: Array - # Status values that need to be considered for filter - status: Array, - on_success: Callable, # func(result: Array) - on_failure: Callable # func(error: ApiError) - ): - # CollectionFormat: NO - - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - - # Compute the URL path to the API resource - var bzz_path := "/pet/findByStatus" - - # Collect the query parameters - # Note: we do not support multiple values for a single param (for now), nor arrays - var bzz_query := Dictionary() - bzz_query["status"] = status - - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("GET") - - # Will be used at some point for denormalization - # baseType = "array" - # openApiType = "array" - # dataType = "Array" - # complexType = "Pet" - # isArray = "true" - var bzz_return_type := "array" - - bee_request( - bzz_method, bzz_path, bzz_query, - func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) - on_success.call(bzz_result) - , # ざわ‥ - func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) - on_failure.call(bzz_error) - , # ざわ‥ - ) - - # /!. DEPRECATED - # Operation findPetsByTags → GET /pet/findByTags - # Finds Pets by tags - # - # Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing. - func find_pets_by_tags( - # tags: Array - # Tags to filter by - tags: Array, - on_success: Callable, # func(result: Array) - on_failure: Callable # func(error: ApiError) - ): - # CollectionFormat: NO - - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - - # Compute the URL path to the API resource - var bzz_path := "/pet/findByTags" - - # Collect the query parameters - # Note: we do not support multiple values for a single param (for now), nor arrays - var bzz_query := Dictionary() - bzz_query["tags"] = tags - - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("GET") - - # Will be used at some point for denormalization - # baseType = "array" - # openApiType = "array" - # dataType = "Array" - # complexType = "Pet" - # isArray = "true" - var bzz_return_type := "array" - - bee_request( - bzz_method, bzz_path, bzz_query, - func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) - on_success.call(bzz_result) - , # ざわ‥ - func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) - on_failure.call(bzz_error) - , # ざわ‥ - ) - - # Operation getPetById → GET /pet/{petId} - # Find pet by ID - # - # Returns a single pet - func get_pet_by_id( - # petId: float Eg: 789 - # ID of pet to return - petId: float, - on_success: Callable, # func(result: Pet) - on_failure: Callable # func(error: ApiError) - ): - # CollectionFormat: NO - - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - - # Compute the URL path to the API resource - var bzz_path := "/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) - - # Collect the query parameters - # Note: we do not support multiple values for a single param (for now), nor arrays - var bzz_query := Dictionary() - - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("GET") - - # Will be used at some point for denormalization - # baseType = "Pet" - # openApiType = "Pet" - # dataType = "Pet" - # complexType = "Pet" - # isArray = "false" - var bzz_return_type := "Pet" - - bee_request( - bzz_method, bzz_path, bzz_query, - func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) - on_success.call(bzz_result) - , # ざわ‥ - func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) - on_failure.call(bzz_error) - , # ざわ‥ - ) - - # Operation updatePet → PUT /pet - # Update an existing pet - func update_pet( - # pet: Pet - # Pet object that needs to be added to the store - pet: Pet, - on_success: Callable, # func(result: Pet) - on_failure: Callable # func(error: ApiError) - ): - # CollectionFormat: NO - - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - - # Compute the URL path to the API resource - var bzz_path := "/pet" - - # Collect the query parameters - # Note: we do not support multiple values for a single param (for now), nor arrays - var bzz_query := Dictionary() - - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("PUT") - - # Will be used at some point for denormalization - # baseType = "Pet" - # openApiType = "Pet" - # dataType = "Pet" - # complexType = "Pet" - # isArray = "false" - var bzz_return_type := "Pet" - - bee_request( - bzz_method, bzz_path, bzz_query, - func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) - on_success.call(bzz_result) - , # ざわ‥ - func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) - on_failure.call(bzz_error) - , # ざわ‥ - ) - - # Operation updatePetWithForm → POST /pet/{petId} - # Updates a pet in the store with form data - func update_pet_with_form( - # petId: float Eg: 789 - # ID of pet that needs to be updated - petId: float, - # name: String Eg: name_example - # Updated name of the pet - name = null, - # status: String Eg: status_example - # Updated status of the pet - status = null, - on_success: Callable, # func(result) - on_failure: Callable # func(error: ApiError) - ): - # CollectionFormat: NO - - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - - # Compute the URL path to the API resource - var bzz_path := "/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) - - # Collect the query parameters - # Note: we do not support multiple values for a single param (for now), nor arrays - var bzz_query := Dictionary() - - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("POST") - - - bee_request( - bzz_method, bzz_path, bzz_query, - func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) - on_success.call(bzz_result) - , # ざわ‥ - func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) - on_failure.call(bzz_error) - , # ざわ‥ - ) - - # Operation uploadFile → POST /pet/{petId}/uploadImage - # uploads an image - func upload_file( - # petId: float Eg: 789 - # ID of pet to update - petId: float, - # additionalMetadata: String Eg: additionalMetadata_example - # Additional data to pass to server - additionalMetadata = null, - # file: File Eg: BINARY_DATA_HERE - # file to upload - file = null, - on_success: Callable, # func(result: ApiResponse) - on_failure: Callable # func(error: ApiError) - ): - # CollectionFormat: NO - - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - - # Compute the URL path to the API resource - var bzz_path := "/pet/{petId}/uploadImage".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) - - # Collect the query parameters - # Note: we do not support multiple values for a single param (for now), nor arrays - var bzz_query := Dictionary() - - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("POST") - - # Will be used at some point for denormalization - # baseType = "ApiResponse" - # openApiType = "ApiResponse" - # dataType = "ApiResponse" - # complexType = "ApiResponse" - # isArray = "false" - var bzz_return_type := "ApiResponse" - - bee_request( - bzz_method, bzz_path, bzz_query, - func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) - on_success.call(bzz_result) - , # ざわ‥ - func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) - on_failure.call(bzz_error) - , # ざわ‥ - ) +extends ApiBee + +# Operation addPet → POST /pet +# Add a new pet to the store +func add_pet( + # pet: Pet + # Pet object that needs to be added to the store + pet: Pet, + on_success: Callable, # func(result: Pet) + on_failure: Callable # func(error: ApiError) +): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/pet" + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + var bzz_query := Dictionary() + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("POST") + + # Will be used at some point for denormalization + # baseType = "Pet" + # openApiType = "Pet" + # dataType = "Pet" + # complexType = "Pet" + # isArray = "false" + var bzz_return_type := "Pet" + + bee_request( + bzz_method, bzz_path, bzz_query, + func(bzz_result, bzz_code, bzz_headers): + #print('SUCCESS!') + #print(bzz_result) + on_success.call(bzz_result) + , # ざわ‥ + func(bzz_error): + #printerr("FAILURE!") + #print(bzz_error) + on_failure.call(bzz_error) + , # ざわ‥ + ) + +# Operation deletePet → DELETE /pet/{petId} +# Deletes a pet +func delete_pet( + # petId: float Eg: 789 + # Pet id to delete + petId: float, + # apiKey: String Eg: apiKey_example + # + apiKey = null, + on_success: Callable, # func(result) + on_failure: Callable # func(error: ApiError) +): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + var bzz_query := Dictionary() + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("DELETE") + + + bee_request( + bzz_method, bzz_path, bzz_query, + func(bzz_result, bzz_code, bzz_headers): + #print('SUCCESS!') + #print(bzz_result) + on_success.call(bzz_result) + , # ざわ‥ + func(bzz_error): + #printerr("FAILURE!") + #print(bzz_error) + on_failure.call(bzz_error) + , # ざわ‥ + ) + +# Operation findPetsByStatus → GET /pet/findByStatus +# Finds Pets by status +# +# Multiple status values can be provided with comma separated strings +func find_pets_by_status( + # status: Array + # Status values that need to be considered for filter + status: Array, + on_success: Callable, # func(result: Array) + on_failure: Callable # func(error: ApiError) +): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/pet/findByStatus" + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + var bzz_query := Dictionary() + bzz_query["status"] = status + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("GET") + + # Will be used at some point for denormalization + # baseType = "array" + # openApiType = "array" + # dataType = "Array" + # complexType = "Pet" + # isArray = "true" + var bzz_return_type := "Pet" + + bee_request( + bzz_method, bzz_path, bzz_query, + func(bzz_result, bzz_code, bzz_headers): + #print('SUCCESS!') + #print(bzz_result) + on_success.call(bzz_result) + , # ざわ‥ + func(bzz_error): + #printerr("FAILURE!") + #print(bzz_error) + on_failure.call(bzz_error) + , # ざわ‥ + ) + +# /!. DEPRECATED +# Operation findPetsByTags → GET /pet/findByTags +# Finds Pets by tags +# +# Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing. +func find_pets_by_tags( + # tags: Array + # Tags to filter by + tags: Array, + on_success: Callable, # func(result: Array) + on_failure: Callable # func(error: ApiError) +): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/pet/findByTags" + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + var bzz_query := Dictionary() + bzz_query["tags"] = tags + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("GET") + + # Will be used at some point for denormalization + # baseType = "array" + # openApiType = "array" + # dataType = "Array" + # complexType = "Pet" + # isArray = "true" + var bzz_return_type := "Pet" + + bee_request( + bzz_method, bzz_path, bzz_query, + func(bzz_result, bzz_code, bzz_headers): + #print('SUCCESS!') + #print(bzz_result) + on_success.call(bzz_result) + , # ざわ‥ + func(bzz_error): + #printerr("FAILURE!") + #print(bzz_error) + on_failure.call(bzz_error) + , # ざわ‥ + ) + +# Operation getPetById → GET /pet/{petId} +# Find pet by ID +# +# Returns a single pet +func get_pet_by_id( + # petId: float Eg: 789 + # ID of pet to return + petId: float, + on_success: Callable, # func(result: Pet) + on_failure: Callable # func(error: ApiError) +): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + var bzz_query := Dictionary() + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("GET") + + # Will be used at some point for denormalization + # baseType = "Pet" + # openApiType = "Pet" + # dataType = "Pet" + # complexType = "Pet" + # isArray = "false" + var bzz_return_type := "Pet" + + bee_request( + bzz_method, bzz_path, bzz_query, + func(bzz_result, bzz_code, bzz_headers): + #print('SUCCESS!') + #print(bzz_result) + on_success.call(bzz_result) + , # ざわ‥ + func(bzz_error): + #printerr("FAILURE!") + #print(bzz_error) + on_failure.call(bzz_error) + , # ざわ‥ + ) + +# Operation updatePet → PUT /pet +# Update an existing pet +func update_pet( + # pet: Pet + # Pet object that needs to be added to the store + pet: Pet, + on_success: Callable, # func(result: Pet) + on_failure: Callable # func(error: ApiError) +): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/pet" + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + var bzz_query := Dictionary() + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("PUT") + + # Will be used at some point for denormalization + # baseType = "Pet" + # openApiType = "Pet" + # dataType = "Pet" + # complexType = "Pet" + # isArray = "false" + var bzz_return_type := "Pet" + + bee_request( + bzz_method, bzz_path, bzz_query, + func(bzz_result, bzz_code, bzz_headers): + #print('SUCCESS!') + #print(bzz_result) + on_success.call(bzz_result) + , # ざわ‥ + func(bzz_error): + #printerr("FAILURE!") + #print(bzz_error) + on_failure.call(bzz_error) + , # ざわ‥ + ) + +# Operation updatePetWithForm → POST /pet/{petId} +# Updates a pet in the store with form data +func update_pet_with_form( + # petId: float Eg: 789 + # ID of pet that needs to be updated + petId: float, + # name: String Eg: name_example + # Updated name of the pet + name = null, + # status: String Eg: status_example + # Updated status of the pet + status = null, + on_success: Callable, # func(result) + on_failure: Callable # func(error: ApiError) +): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + var bzz_query := Dictionary() + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("POST") + + + bee_request( + bzz_method, bzz_path, bzz_query, + func(bzz_result, bzz_code, bzz_headers): + #print('SUCCESS!') + #print(bzz_result) + on_success.call(bzz_result) + , # ざわ‥ + func(bzz_error): + #printerr("FAILURE!") + #print(bzz_error) + on_failure.call(bzz_error) + , # ざわ‥ + ) + +# Operation uploadFile → POST /pet/{petId}/uploadImage +# uploads an image +func upload_file( + # petId: float Eg: 789 + # ID of pet to update + petId: float, + # additionalMetadata: String Eg: additionalMetadata_example + # Additional data to pass to server + additionalMetadata = null, + # file: File Eg: BINARY_DATA_HERE + # file to upload + file = null, + on_success: Callable, # func(result: ApiResponse) + on_failure: Callable # func(error: ApiError) +): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/pet/{petId}/uploadImage".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + var bzz_query := Dictionary() + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("POST") + + # Will be used at some point for denormalization + # baseType = "ApiResponse" + # openApiType = "ApiResponse" + # dataType = "ApiResponse" + # complexType = "ApiResponse" + # isArray = "false" + var bzz_return_type := "ApiResponse" + + bee_request( + bzz_method, bzz_path, bzz_query, + func(bzz_result, bzz_code, bzz_headers): + #print('SUCCESS!') + #print(bzz_result) + on_success.call(bzz_result) + , # ざわ‥ + func(bzz_error): + #printerr("FAILURE!") + #print(bzz_error) + on_failure.call(bzz_error) + , # ざわ‥ + ) diff --git a/samples/client/petstore/gdscript/apis/StoreApi.gd b/samples/client/petstore/gdscript/apis/StoreApi.gd index f7a90a1d2cbf..0dccb4b8adab 100644 --- a/samples/client/petstore/gdscript/apis/StoreApi.gd +++ b/samples/client/petstore/gdscript/apis/StoreApi.gd @@ -1,188 +1,188 @@ # THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. # For more information on how to customize templates, see: # https://openapi-generator.tech +# The OpenAPI Generator Community, © Public Domain, 2022 # API StoreApi -class StoreApi: - extends ApiBee - - # Operation deleteOrder → DELETE /store/order/{orderId} - # Delete purchase order by ID - # - # For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors - func delete_order( - # orderId: String Eg: orderId_example - # ID of the order that needs to be deleted - orderId: String, - on_success: Callable, # func(result) - on_failure: Callable # func(error: ApiError) - ): - # CollectionFormat: NO - - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - - # Compute the URL path to the API resource - var bzz_path := "/store/order/{orderId}".replace("{" + "orderId" + "}", bee_urlize_path_param(orderId)) - - # Collect the query parameters - # Note: we do not support multiple values for a single param (for now), nor arrays - var bzz_query := Dictionary() - - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("DELETE") - - - bee_request( - bzz_method, bzz_path, bzz_query, - func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) - on_success.call(bzz_result) - , # ざわ‥ - func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) - on_failure.call(bzz_error) - , # ざわ‥ - ) - - # Operation getInventory → GET /store/inventory - # Returns pet inventories by status - # - # Returns a map of status codes to quantities - func get_inventory( - on_success: Callable, # func(result: Dictionary) - on_failure: Callable # func(error: ApiError) - ): - # CollectionFormat: NO - - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - - # Compute the URL path to the API resource - var bzz_path := "/store/inventory" - - # Collect the query parameters - # Note: we do not support multiple values for a single param (for now), nor arrays - var bzz_query := Dictionary() - - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("GET") - - # Will be used at some point for denormalization - # baseType = "map" - # openApiType = "object" - # dataType = "Dictionary" - # complexType = "integer" - # isArray = "false" - var bzz_return_type := "map" - - bee_request( - bzz_method, bzz_path, bzz_query, - func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) - on_success.call(bzz_result) - , # ざわ‥ - func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) - on_failure.call(bzz_error) - , # ざわ‥ - ) - - # Operation getOrderById → GET /store/order/{orderId} - # Find purchase order by ID - # - # For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions - func get_order_by_id( - # orderId: float Eg: 789 - # ID of pet that needs to be fetched - orderId: float, - on_success: Callable, # func(result: Order) - on_failure: Callable # func(error: ApiError) - ): - # CollectionFormat: NO - - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - - # Compute the URL path to the API resource - var bzz_path := "/store/order/{orderId}".replace("{" + "orderId" + "}", bee_urlize_path_param(orderId)) - - # Collect the query parameters - # Note: we do not support multiple values for a single param (for now), nor arrays - var bzz_query := Dictionary() - - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("GET") - - # Will be used at some point for denormalization - # baseType = "Order" - # openApiType = "Order" - # dataType = "Order" - # complexType = "Order" - # isArray = "false" - var bzz_return_type := "Order" - - bee_request( - bzz_method, bzz_path, bzz_query, - func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) - on_success.call(bzz_result) - , # ざわ‥ - func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) - on_failure.call(bzz_error) - , # ざわ‥ - ) - - # Operation placeOrder → POST /store/order - # Place an order for a pet - func place_order( - # order: Order - # order placed for purchasing the pet - order: Order, - on_success: Callable, # func(result: Order) - on_failure: Callable # func(error: ApiError) - ): - # CollectionFormat: NO - - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - - # Compute the URL path to the API resource - var bzz_path := "/store/order" - - # Collect the query parameters - # Note: we do not support multiple values for a single param (for now), nor arrays - var bzz_query := Dictionary() - - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("POST") - - # Will be used at some point for denormalization - # baseType = "Order" - # openApiType = "Order" - # dataType = "Order" - # complexType = "Order" - # isArray = "false" - var bzz_return_type := "Order" - - bee_request( - bzz_method, bzz_path, bzz_query, - func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) - on_success.call(bzz_result) - , # ざわ‥ - func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) - on_failure.call(bzz_error) - , # ざわ‥ - ) +extends ApiBee + +# Operation deleteOrder → DELETE /store/order/{orderId} +# Delete purchase order by ID +# +# For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors +func delete_order( + # orderId: String Eg: orderId_example + # ID of the order that needs to be deleted + orderId: String, + on_success: Callable, # func(result) + on_failure: Callable # func(error: ApiError) +): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/store/order/{orderId}".replace("{" + "orderId" + "}", bee_urlize_path_param(orderId)) + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + var bzz_query := Dictionary() + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("DELETE") + + + bee_request( + bzz_method, bzz_path, bzz_query, + func(bzz_result, bzz_code, bzz_headers): + #print('SUCCESS!') + #print(bzz_result) + on_success.call(bzz_result) + , # ざわ‥ + func(bzz_error): + #printerr("FAILURE!") + #print(bzz_error) + on_failure.call(bzz_error) + , # ざわ‥ + ) + +# Operation getInventory → GET /store/inventory +# Returns pet inventories by status +# +# Returns a map of status codes to quantities +func get_inventory( + on_success: Callable, # func(result: Dictionary) + on_failure: Callable # func(error: ApiError) +): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/store/inventory" + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + var bzz_query := Dictionary() + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("GET") + + # Will be used at some point for denormalization + # baseType = "map" + # openApiType = "object" + # dataType = "Dictionary" + # complexType = "integer" + # isArray = "false" + var bzz_return_type := "integer" + + bee_request( + bzz_method, bzz_path, bzz_query, + func(bzz_result, bzz_code, bzz_headers): + #print('SUCCESS!') + #print(bzz_result) + on_success.call(bzz_result) + , # ざわ‥ + func(bzz_error): + #printerr("FAILURE!") + #print(bzz_error) + on_failure.call(bzz_error) + , # ざわ‥ + ) + +# Operation getOrderById → GET /store/order/{orderId} +# Find purchase order by ID +# +# For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions +func get_order_by_id( + # orderId: float Eg: 789 + # ID of pet that needs to be fetched + orderId: float, + on_success: Callable, # func(result: Order) + on_failure: Callable # func(error: ApiError) +): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/store/order/{orderId}".replace("{" + "orderId" + "}", bee_urlize_path_param(orderId)) + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + var bzz_query := Dictionary() + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("GET") + + # Will be used at some point for denormalization + # baseType = "Order" + # openApiType = "Order" + # dataType = "Order" + # complexType = "Order" + # isArray = "false" + var bzz_return_type := "Order" + + bee_request( + bzz_method, bzz_path, bzz_query, + func(bzz_result, bzz_code, bzz_headers): + #print('SUCCESS!') + #print(bzz_result) + on_success.call(bzz_result) + , # ざわ‥ + func(bzz_error): + #printerr("FAILURE!") + #print(bzz_error) + on_failure.call(bzz_error) + , # ざわ‥ + ) + +# Operation placeOrder → POST /store/order +# Place an order for a pet +func place_order( + # order: Order + # order placed for purchasing the pet + order: Order, + on_success: Callable, # func(result: Order) + on_failure: Callable # func(error: ApiError) +): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/store/order" + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + var bzz_query := Dictionary() + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("POST") + + # Will be used at some point for denormalization + # baseType = "Order" + # openApiType = "Order" + # dataType = "Order" + # complexType = "Order" + # isArray = "false" + var bzz_return_type := "Order" + + bee_request( + bzz_method, bzz_path, bzz_query, + func(bzz_result, bzz_code, bzz_headers): + #print('SUCCESS!') + #print(bzz_result) + on_success.call(bzz_result) + , # ざわ‥ + func(bzz_error): + #printerr("FAILURE!") + #print(bzz_error) + on_failure.call(bzz_error) + , # ざわ‥ + ) diff --git a/samples/client/petstore/gdscript/apis/UserApi.gd b/samples/client/petstore/gdscript/apis/UserApi.gd index e35483e8dcc5..b118065ed1c7 100644 --- a/samples/client/petstore/gdscript/apis/UserApi.gd +++ b/samples/client/petstore/gdscript/apis/UserApi.gd @@ -1,345 +1,345 @@ # THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. # For more information on how to customize templates, see: # https://openapi-generator.tech +# The OpenAPI Generator Community, © Public Domain, 2022 # API UserApi -class UserApi: - extends ApiBee - - # Operation createUser → POST /user - # Create user - # - # This can only be done by the logged in user. - func create_user( - # user: User - # Created user object - user: User, - on_success: Callable, # func(result) - on_failure: Callable # func(error: ApiError) - ): - # CollectionFormat: NO - - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - - # Compute the URL path to the API resource - var bzz_path := "/user" - - # Collect the query parameters - # Note: we do not support multiple values for a single param (for now), nor arrays - var bzz_query := Dictionary() - - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("POST") - - - bee_request( - bzz_method, bzz_path, bzz_query, - func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) - on_success.call(bzz_result) - , # ざわ‥ - func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) - on_failure.call(bzz_error) - , # ざわ‥ - ) - - # Operation createUsersWithArrayInput → POST /user/createWithArray - # Creates list of users with given input array - func create_users_with_array_input( - # user: Array - # List of user object - user: Array, - on_success: Callable, # func(result) - on_failure: Callable # func(error: ApiError) - ): - # CollectionFormat: NO - - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - - # Compute the URL path to the API resource - var bzz_path := "/user/createWithArray" - - # Collect the query parameters - # Note: we do not support multiple values for a single param (for now), nor arrays - var bzz_query := Dictionary() - - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("POST") - - - bee_request( - bzz_method, bzz_path, bzz_query, - func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) - on_success.call(bzz_result) - , # ざわ‥ - func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) - on_failure.call(bzz_error) - , # ざわ‥ - ) - - # Operation createUsersWithListInput → POST /user/createWithList - # Creates list of users with given input array - func create_users_with_list_input( - # user: Array - # List of user object - user: Array, - on_success: Callable, # func(result) - on_failure: Callable # func(error: ApiError) - ): - # CollectionFormat: NO - - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - - # Compute the URL path to the API resource - var bzz_path := "/user/createWithList" - - # Collect the query parameters - # Note: we do not support multiple values for a single param (for now), nor arrays - var bzz_query := Dictionary() - - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("POST") - - - bee_request( - bzz_method, bzz_path, bzz_query, - func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) - on_success.call(bzz_result) - , # ざわ‥ - func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) - on_failure.call(bzz_error) - , # ざわ‥ - ) - - # Operation deleteUser → DELETE /user/{username} - # Delete user - # - # This can only be done by the logged in user. - func delete_user( - # username: String Eg: username_example - # The name that needs to be deleted - username: String, - on_success: Callable, # func(result) - on_failure: Callable # func(error: ApiError) - ): - # CollectionFormat: NO - - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - - # Compute the URL path to the API resource - var bzz_path := "/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) - - # Collect the query parameters - # Note: we do not support multiple values for a single param (for now), nor arrays - var bzz_query := Dictionary() - - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("DELETE") - - - bee_request( - bzz_method, bzz_path, bzz_query, - func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) - on_success.call(bzz_result) - , # ざわ‥ - func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) - on_failure.call(bzz_error) - , # ざわ‥ - ) - - # Operation getUserByName → GET /user/{username} - # Get user by user name - func get_user_by_name( - # username: String Eg: username_example - # The name that needs to be fetched. Use user1 for testing. - username: String, - on_success: Callable, # func(result: User) - on_failure: Callable # func(error: ApiError) - ): - # CollectionFormat: NO - - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - - # Compute the URL path to the API resource - var bzz_path := "/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) - - # Collect the query parameters - # Note: we do not support multiple values for a single param (for now), nor arrays - var bzz_query := Dictionary() - - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("GET") - - # Will be used at some point for denormalization - # baseType = "User" - # openApiType = "User" - # dataType = "User" - # complexType = "User" - # isArray = "false" - var bzz_return_type := "User" - - bee_request( - bzz_method, bzz_path, bzz_query, - func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) - on_success.call(bzz_result) - , # ざわ‥ - func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) - on_failure.call(bzz_error) - , # ざわ‥ - ) - - # Operation loginUser → GET /user/login - # Logs user into the system - func login_user( - # username: String Eg: username_example - # The user name for login - username: String, - # password: String Eg: password_example - # The password for login in clear text - password: String, - on_success: Callable, # func(result: String) - on_failure: Callable # func(error: ApiError) - ): - # CollectionFormat: NO - - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - - # Compute the URL path to the API resource - var bzz_path := "/user/login" - - # Collect the query parameters - # Note: we do not support multiple values for a single param (for now), nor arrays - var bzz_query := Dictionary() - bzz_query["username"] = username - bzz_query["password"] = password - - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("GET") - - # Will be used at some point for denormalization - # baseType = "string" - # openApiType = "string" - # dataType = "String" - # complexType = "string" - # isArray = "false" - var bzz_return_type := "string" - - bee_request( - bzz_method, bzz_path, bzz_query, - func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) - on_success.call(bzz_result) - , # ざわ‥ - func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) - on_failure.call(bzz_error) - , # ざわ‥ - ) - - # Operation logoutUser → GET /user/logout - # Logs out current logged in user session - func logout_user( - on_success: Callable, # func(result) - on_failure: Callable # func(error: ApiError) - ): - # CollectionFormat: NO - - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - - # Compute the URL path to the API resource - var bzz_path := "/user/logout" - - # Collect the query parameters - # Note: we do not support multiple values for a single param (for now), nor arrays - var bzz_query := Dictionary() - - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("GET") - - - bee_request( - bzz_method, bzz_path, bzz_query, - func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) - on_success.call(bzz_result) - , # ざわ‥ - func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) - on_failure.call(bzz_error) - , # ざわ‥ - ) - - # Operation updateUser → PUT /user/{username} - # Updated user - # - # This can only be done by the logged in user. - func update_user( - # username: String Eg: username_example - # name that need to be deleted - username: String, - # user: User - # Updated user object - user: User, - on_success: Callable, # func(result) - on_failure: Callable # func(error: ApiError) - ): - # CollectionFormat: NO - - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - - # Compute the URL path to the API resource - var bzz_path := "/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) - - # Collect the query parameters - # Note: we do not support multiple values for a single param (for now), nor arrays - var bzz_query := Dictionary() - - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("PUT") - - - bee_request( - bzz_method, bzz_path, bzz_query, - func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) - on_success.call(bzz_result) - , # ざわ‥ - func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) - on_failure.call(bzz_error) - , # ざわ‥ - ) +extends ApiBee + +# Operation createUser → POST /user +# Create user +# +# This can only be done by the logged in user. +func create_user( + # user: User + # Created user object + user: User, + on_success: Callable, # func(result) + on_failure: Callable # func(error: ApiError) +): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/user" + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + var bzz_query := Dictionary() + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("POST") + + + bee_request( + bzz_method, bzz_path, bzz_query, + func(bzz_result, bzz_code, bzz_headers): + #print('SUCCESS!') + #print(bzz_result) + on_success.call(bzz_result) + , # ざわ‥ + func(bzz_error): + #printerr("FAILURE!") + #print(bzz_error) + on_failure.call(bzz_error) + , # ざわ‥ + ) + +# Operation createUsersWithArrayInput → POST /user/createWithArray +# Creates list of users with given input array +func create_users_with_array_input( + # user: Array + # List of user object + user: Array, + on_success: Callable, # func(result) + on_failure: Callable # func(error: ApiError) +): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/user/createWithArray" + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + var bzz_query := Dictionary() + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("POST") + + + bee_request( + bzz_method, bzz_path, bzz_query, + func(bzz_result, bzz_code, bzz_headers): + #print('SUCCESS!') + #print(bzz_result) + on_success.call(bzz_result) + , # ざわ‥ + func(bzz_error): + #printerr("FAILURE!") + #print(bzz_error) + on_failure.call(bzz_error) + , # ざわ‥ + ) + +# Operation createUsersWithListInput → POST /user/createWithList +# Creates list of users with given input array +func create_users_with_list_input( + # user: Array + # List of user object + user: Array, + on_success: Callable, # func(result) + on_failure: Callable # func(error: ApiError) +): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/user/createWithList" + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + var bzz_query := Dictionary() + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("POST") + + + bee_request( + bzz_method, bzz_path, bzz_query, + func(bzz_result, bzz_code, bzz_headers): + #print('SUCCESS!') + #print(bzz_result) + on_success.call(bzz_result) + , # ざわ‥ + func(bzz_error): + #printerr("FAILURE!") + #print(bzz_error) + on_failure.call(bzz_error) + , # ざわ‥ + ) + +# Operation deleteUser → DELETE /user/{username} +# Delete user +# +# This can only be done by the logged in user. +func delete_user( + # username: String Eg: username_example + # The name that needs to be deleted + username: String, + on_success: Callable, # func(result) + on_failure: Callable # func(error: ApiError) +): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + var bzz_query := Dictionary() + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("DELETE") + + + bee_request( + bzz_method, bzz_path, bzz_query, + func(bzz_result, bzz_code, bzz_headers): + #print('SUCCESS!') + #print(bzz_result) + on_success.call(bzz_result) + , # ざわ‥ + func(bzz_error): + #printerr("FAILURE!") + #print(bzz_error) + on_failure.call(bzz_error) + , # ざわ‥ + ) + +# Operation getUserByName → GET /user/{username} +# Get user by user name +func get_user_by_name( + # username: String Eg: username_example + # The name that needs to be fetched. Use user1 for testing. + username: String, + on_success: Callable, # func(result: User) + on_failure: Callable # func(error: ApiError) +): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + var bzz_query := Dictionary() + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("GET") + + # Will be used at some point for denormalization + # baseType = "User" + # openApiType = "User" + # dataType = "User" + # complexType = "User" + # isArray = "false" + var bzz_return_type := "User" + + bee_request( + bzz_method, bzz_path, bzz_query, + func(bzz_result, bzz_code, bzz_headers): + #print('SUCCESS!') + #print(bzz_result) + on_success.call(bzz_result) + , # ざわ‥ + func(bzz_error): + #printerr("FAILURE!") + #print(bzz_error) + on_failure.call(bzz_error) + , # ざわ‥ + ) + +# Operation loginUser → GET /user/login +# Logs user into the system +func login_user( + # username: String Eg: username_example + # The user name for login + username: String, + # password: String Eg: password_example + # The password for login in clear text + password: String, + on_success: Callable, # func(result: String) + on_failure: Callable # func(error: ApiError) +): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/user/login" + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + var bzz_query := Dictionary() + bzz_query["username"] = username + bzz_query["password"] = password + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("GET") + + # Will be used at some point for denormalization + # baseType = "string" + # openApiType = "string" + # dataType = "String" + # complexType = "string" + # isArray = "false" + var bzz_return_type := "string" + + bee_request( + bzz_method, bzz_path, bzz_query, + func(bzz_result, bzz_code, bzz_headers): + #print('SUCCESS!') + #print(bzz_result) + on_success.call(bzz_result) + , # ざわ‥ + func(bzz_error): + #printerr("FAILURE!") + #print(bzz_error) + on_failure.call(bzz_error) + , # ざわ‥ + ) + +# Operation logoutUser → GET /user/logout +# Logs out current logged in user session +func logout_user( + on_success: Callable, # func(result) + on_failure: Callable # func(error: ApiError) +): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/user/logout" + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + var bzz_query := Dictionary() + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("GET") + + + bee_request( + bzz_method, bzz_path, bzz_query, + func(bzz_result, bzz_code, bzz_headers): + #print('SUCCESS!') + #print(bzz_result) + on_success.call(bzz_result) + , # ざわ‥ + func(bzz_error): + #printerr("FAILURE!") + #print(bzz_error) + on_failure.call(bzz_error) + , # ざわ‥ + ) + +# Operation updateUser → PUT /user/{username} +# Updated user +# +# This can only be done by the logged in user. +func update_user( + # username: String Eg: username_example + # name that need to be deleted + username: String, + # user: User + # Updated user object + user: User, + on_success: Callable, # func(result) + on_failure: Callable # func(error: ApiError) +): + # CollectionFormat: NO + + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames + # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource + var bzz_path := "/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) + + # Collect the query parameters + # Note: we do not support multiple values for a single param (for now), nor arrays + var bzz_query := Dictionary() + + # Convert the HTTP method to something Godot understands + var bzz_method := bee_convert_http_method("PUT") + + + bee_request( + bzz_method, bzz_path, bzz_query, + func(bzz_result, bzz_code, bzz_headers): + #print('SUCCESS!') + #print(bzz_result) + on_success.call(bzz_result) + , # ざわ‥ + func(bzz_error): + #printerr("FAILURE!") + #print(bzz_error) + on_failure.call(bzz_error) + , # ざわ‥ + ) diff --git a/samples/client/petstore/gdscript/models/ApiResponse.gd b/samples/client/petstore/gdscript/models/ApiResponse.gd index 55bf17fe8382..5e4dc8eeaf5c 100644 --- a/samples/client/petstore/gdscript/models/ApiResponse.gd +++ b/samples/client/petstore/gdscript/models/ApiResponse.gd @@ -1,33 +1,29 @@ -# ApiResponse -# namespace: models -# package: -# author: OpenAPI Generator Community -# link: https://openapi-generator.tech - -# NOTE: This class is AUTO GENERATED by OpenAPI Generator (https://openapi-generator.tech). -# Best not edit the class manually. - +# THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. +# For more information on how to customize templates, see: +# https://openapi-generator.tech +# The OpenAPI Generator Community, © Public Domain, 2022 # ApiResponse Model # Describes the result of uploading an image resource -class ApiResponse: - extends RefCounted - class_name ApiResponse +# namespace: models +# invoker: - # Type: int - # Required: False - var code: int +extends ApiBee +class_name ApiResponse +# Type: int +# Required: False +var code: int - # Type: String - # Required: False - var type: String +# Type: String +# Required: False +var type: String - # Type: String - # Required: False - var message: String +# Type: String +# Required: False +var message: String diff --git a/samples/client/petstore/gdscript/models/Category.gd b/samples/client/petstore/gdscript/models/Category.gd index 4187bb37a88a..e6ed82f1e784 100644 --- a/samples/client/petstore/gdscript/models/Category.gd +++ b/samples/client/petstore/gdscript/models/Category.gd @@ -1,28 +1,24 @@ -# Category -# namespace: models -# package: -# author: OpenAPI Generator Community -# link: https://openapi-generator.tech - -# NOTE: This class is AUTO GENERATED by OpenAPI Generator (https://openapi-generator.tech). -# Best not edit the class manually. - +# THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. +# For more information on how to customize templates, see: +# https://openapi-generator.tech +# The OpenAPI Generator Community, © Public Domain, 2022 # Category Model # A category for a pet -class Category: - extends RefCounted - class_name Category +# namespace: models +# invoker: - # Type: float - # Required: False - var id: float +extends ApiBee +class_name Category +# Type: float +# Required: False +var id: float - # Type: String - # Required: False - var name: String +# Type: String +# Required: False +var name: String diff --git a/samples/client/petstore/gdscript/models/Order.gd b/samples/client/petstore/gdscript/models/Order.gd index 49e1f43b22c9..b67705324d86 100644 --- a/samples/client/petstore/gdscript/models/Order.gd +++ b/samples/client/petstore/gdscript/models/Order.gd @@ -1,49 +1,45 @@ -# Order -# namespace: models -# package: -# author: OpenAPI Generator Community -# link: https://openapi-generator.tech - -# NOTE: This class is AUTO GENERATED by OpenAPI Generator (https://openapi-generator.tech). -# Best not edit the class manually. - +# THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. +# For more information on how to customize templates, see: +# https://openapi-generator.tech +# The OpenAPI Generator Community, © Public Domain, 2022 # Order Model # An order for a pets from the pet store -class Order: - extends RefCounted - class_name Order +# namespace: models +# invoker: - # Type: float - # Required: False - var id: float +extends ApiBee +class_name Order +# Type: float +# Required: False +var id: float - # Type: float - # Required: False - var petId: float +# Type: float +# Required: False +var petId: float - # Type: int - # Required: False - var quantity: int +# Type: int +# Required: False +var quantity: int - # Type: DateTime - # Required: False - var shipDate: DateTime +# Type: DateTime +# Required: False +var shipDate: DateTime - # Order Status - # Type: String - # Required: False - var status: String +# Order Status +# Type: String +# Required: False +var status: String - # Type: bool - # Required: False - var complete: bool = false +# Type: bool +# Required: False +var complete: bool = false diff --git a/samples/client/petstore/gdscript/models/Pet.gd b/samples/client/petstore/gdscript/models/Pet.gd index 9bc75d87062a..c56acb95e800 100644 --- a/samples/client/petstore/gdscript/models/Pet.gd +++ b/samples/client/petstore/gdscript/models/Pet.gd @@ -1,51 +1,47 @@ -# Pet -# namespace: models -# package: -# author: OpenAPI Generator Community -# link: https://openapi-generator.tech - -# NOTE: This class is AUTO GENERATED by OpenAPI Generator (https://openapi-generator.tech). -# Best not edit the class manually. - +# THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. +# For more information on how to customize templates, see: +# https://openapi-generator.tech +# The OpenAPI Generator Community, © Public Domain, 2022 # Pet Model # A pet for sale in the pet store -class Pet: - extends RefCounted - class_name Pet +# namespace: models +# invoker: - # Type: float - # Required: False - var id: float +extends ApiBee +class_name Pet +# Type: float +# Required: False +var id: float - # Type: Category - # Required: False - var category: Category +# Type: Category +# Required: False +var category: Category - # Type: String - # Required: True - # Example: doggie - var name: String +# Type: String +# Required: True +# Example: doggie +var name: String - # Type: Array - # Required: True - var photoUrls: Array +# Type: Array +# Required: True +var photoUrls: Array - # Type: Array - # Required: False - var tags: Array +# Type: Array +# Required: False +var tags: Array - # /!. DEPRECATED - # pet status in the store - # Type: String - # Required: False - var status: String +# /!. DEPRECATED +# pet status in the store +# Type: String +# Required: False +var status: String diff --git a/samples/client/petstore/gdscript/models/Tag.gd b/samples/client/petstore/gdscript/models/Tag.gd index e4eb666338c0..7ba43a75f552 100644 --- a/samples/client/petstore/gdscript/models/Tag.gd +++ b/samples/client/petstore/gdscript/models/Tag.gd @@ -1,28 +1,24 @@ -# Tag -# namespace: models -# package: -# author: OpenAPI Generator Community -# link: https://openapi-generator.tech - -# NOTE: This class is AUTO GENERATED by OpenAPI Generator (https://openapi-generator.tech). -# Best not edit the class manually. - +# THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. +# For more information on how to customize templates, see: +# https://openapi-generator.tech +# The OpenAPI Generator Community, © Public Domain, 2022 # Tag Model # A tag for a pet -class Tag: - extends RefCounted - class_name Tag +# namespace: models +# invoker: - # Type: float - # Required: False - var id: float +extends ApiBee +class_name Tag +# Type: float +# Required: False +var id: float - # Type: String - # Required: False - var name: String +# Type: String +# Required: False +var name: String diff --git a/samples/client/petstore/gdscript/models/User.gd b/samples/client/petstore/gdscript/models/User.gd index f1f0ce14766e..aef534a1c19f 100644 --- a/samples/client/petstore/gdscript/models/User.gd +++ b/samples/client/petstore/gdscript/models/User.gd @@ -1,59 +1,55 @@ -# User -# namespace: models -# package: -# author: OpenAPI Generator Community -# link: https://openapi-generator.tech - -# NOTE: This class is AUTO GENERATED by OpenAPI Generator (https://openapi-generator.tech). -# Best not edit the class manually. - +# THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. +# For more information on how to customize templates, see: +# https://openapi-generator.tech +# The OpenAPI Generator Community, © Public Domain, 2022 # User Model # A User who is purchasing from the pet store -class User: - extends RefCounted - class_name User +# namespace: models +# invoker: - # Type: float - # Required: False - var id: float +extends ApiBee +class_name User +# Type: float +# Required: False +var id: float - # Type: String - # Required: False - var username: String +# Type: String +# Required: False +var username: String - # Type: String - # Required: False - var firstName: String +# Type: String +# Required: False +var firstName: String - # Type: String - # Required: False - var lastName: String +# Type: String +# Required: False +var lastName: String - # Type: String - # Required: False - var email: String +# Type: String +# Required: False +var email: String - # Type: String - # Required: False - var password: String +# Type: String +# Required: False +var password: String - # Type: String - # Required: False - var phone: String +# Type: String +# Required: False +var phone: String - # User Status - # Type: int - # Required: False - var userStatus: int +# User Status +# Type: int +# Required: False +var userStatus: int From 722b56bd4fc2eb6b84410eb326797971a13cfd46 Mon Sep 17 00:00:00 2001 From: Goutte Date: Thu, 20 Oct 2022 00:49:22 +0200 Subject: [PATCH 06/56] refacto(gdscript): move demo files to their own directory I know I'm making a lot of commits for not much, but now I'm opening the sample files with Godot as well, and doing unholy things with filesystems, so I'm not taking any chances. It's all going to be squashed anyway. :) --- .../petstore/gdscript/{ => demo}/Logger.gd | 0 .../petstore/gdscript/{ => demo}/main.gd | 0 .../petstore/gdscript/{ => demo}/main.tscn | 6 ++- .../client/petstore/gdscript/project.godot | 42 +++++++++++++++++-- 4 files changed, 43 insertions(+), 5 deletions(-) rename samples/client/petstore/gdscript/{ => demo}/Logger.gd (100%) rename samples/client/petstore/gdscript/{ => demo}/main.gd (100%) rename samples/client/petstore/gdscript/{ => demo}/main.tscn (92%) diff --git a/samples/client/petstore/gdscript/Logger.gd b/samples/client/petstore/gdscript/demo/Logger.gd similarity index 100% rename from samples/client/petstore/gdscript/Logger.gd rename to samples/client/petstore/gdscript/demo/Logger.gd diff --git a/samples/client/petstore/gdscript/main.gd b/samples/client/petstore/gdscript/demo/main.gd similarity index 100% rename from samples/client/petstore/gdscript/main.gd rename to samples/client/petstore/gdscript/demo/main.gd diff --git a/samples/client/petstore/gdscript/main.tscn b/samples/client/petstore/gdscript/demo/main.tscn similarity index 92% rename from samples/client/petstore/gdscript/main.tscn rename to samples/client/petstore/gdscript/demo/main.tscn index dc1ab64c58c2..e2dbb73e9684 100644 --- a/samples/client/petstore/gdscript/main.tscn +++ b/samples/client/petstore/gdscript/demo/main.tscn @@ -1,6 +1,6 @@ [gd_scene load_steps=3 format=3 uid="uid://dyht2e7myo04l"] -[ext_resource type="Script" path="res://main.gd" id="1_226ps"] +[ext_resource type="Script" path="res://demo/main.gd" id="1_sbv1b"] [sub_resource type="CodeHighlighter" id="CodeHighlighter_mtjt2"] number_color = Color(0, 0.843137, 0.341176, 1) @@ -13,7 +13,9 @@ layout_mode = 3 anchors_preset = 15 anchor_right = 1.0 anchor_bottom = 1.0 -script = ExtResource("1_226ps") +grow_horizontal = 2 +grow_vertical = 2 +script = ExtResource("1_sbv1b") [node name="HBoxContainer" type="HBoxContainer" parent="."] layout_mode = 1 diff --git a/samples/client/petstore/gdscript/project.godot b/samples/client/petstore/gdscript/project.godot index 4114b4e98eab..18e6215c1c6b 100644 --- a/samples/client/petstore/gdscript/project.godot +++ b/samples/client/petstore/gdscript/project.godot @@ -18,19 +18,55 @@ _global_script_classes=[{ "class": &"ApiError", "language": &"GDScript", "path": "res://core/ApiError.gd" +}, { +"base": "ApiBee", +"class": &"ApiResponse", +"language": &"GDScript", +"path": "res://models/ApiResponse.gd" +}, { +"base": "ApiBee", +"class": &"Category", +"language": &"GDScript", +"path": "res://models/Category.gd" +}, { +"base": "ApiBee", +"class": &"Order", +"language": &"GDScript", +"path": "res://models/Order.gd" +}, { +"base": "ApiBee", +"class": &"Pet", +"language": &"GDScript", +"path": "res://models/Pet.gd" +}, { +"base": "ApiBee", +"class": &"Tag", +"language": &"GDScript", +"path": "res://models/Tag.gd" +}, { +"base": "ApiBee", +"class": &"User", +"language": &"GDScript", +"path": "res://models/User.gd" }] _global_script_class_icons={ "ApiBee": "", -"ApiError": "" +"ApiError": "", +"ApiResponse": "", +"Category": "", +"Order": "", +"Pet": "", +"Tag": "", +"User": "" } [application] config/name="GDScript Petstore Client" -run/main_scene="res://main.tscn" +run/main_scene="res://demo/main.tscn" config/features=PackedStringArray("4.0", "Forward Plus") config/icon="res://icon.svg" [autoload] -Logger="*res://Logger.gd" +Logger="*res://demo/Logger.gd" From 77e3b85437a5fde0ea41ab9322a4191a1ca3757b Mon Sep 17 00:00:00 2001 From: Goutte Date: Thu, 20 Oct 2022 04:17:31 +0200 Subject: [PATCH 07/56] fix(gdscript): sample as a Godot project It works ! I can now write integration tests in GDScript. The real work starts now. /spend 25h --- .../languages/GdscriptClientCodegen.java | 4 +- .../main/resources/gdscript/ApiBee.handlebars | 31 ++++++- .../resources/gdscript/ApiError.handlebars | 12 +++ .../main/resources/gdscript/api.handlebars | 10 ++- .../main/resources/gdscript/model.handlebars | 4 +- .../client/petstore/gdscript/apis/PetApi.gd | 58 ++++++++------ .../client/petstore/gdscript/apis/StoreApi.gd | 30 ++++--- .../client/petstore/gdscript/apis/UserApi.gd | 58 ++++++++------ .../client/petstore/gdscript/core/ApiBee.gd | 31 ++++++- .../client/petstore/gdscript/core/ApiError.gd | 12 +++ samples/client/petstore/gdscript/demo/main.gd | 80 +++++++++++++++++-- .../petstore/gdscript/models/ApiResponse.gd | 2 +- .../petstore/gdscript/models/Category.gd | 2 +- .../client/petstore/gdscript/models/Order.gd | 6 +- .../client/petstore/gdscript/models/Pet.gd | 2 +- .../client/petstore/gdscript/models/Tag.gd | 2 +- .../client/petstore/gdscript/models/User.gd | 2 +- .../client/petstore/gdscript/project.godot | 36 +++++++-- 18 files changed, 284 insertions(+), 98 deletions(-) diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java index 49d3bd559b12..4a290e59f55b 100644 --- a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java +++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java @@ -73,8 +73,8 @@ public GdscriptClientCodegen() { typeMapping.put("map", "Dictionary"); typeMapping.put("set", "Array"); typeMapping.put("date", "string"); - // FIXME: handle DateTime somehow - //typeMapping.put("DateTime", "Date"); + // FIXME: handle DateTime somehow (with Time singleton) + typeMapping.put("DateTime", "Dictionary"); //typeMapping.put("binary", "any"); typeMapping.put("file", "File"); typeMapping.put("ByteArray", "Array"); diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars index f6b434c3bf80..d697a685dad0 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars @@ -66,10 +66,7 @@ func bee_disable_ssl(): func bee_next_loop_iteration(): - # Use this when it works, on release (beta3 now) -# return Engine.get_main_loop().idle_frame - # For now, this works - return RenderingServer.frame_post_draw + return Engine.get_main_loop().process_frame func bee_connect_client_if_needed( @@ -285,6 +282,32 @@ func bee_do_request_text( else: response_text = response_bytes.get_string_from_ascii() + if response_code >= 500: + var error := ApiError.new() + error.internal_code = ERR_PRINTER_ON_FIRE + error.identifier = "apibee.response.5xx" + error.message = "%s: request to `%s' made the server hiccup with a %d." % [ + self.bee_name, path, response_code + ] + on_failure.call(error) + return + elif response_code >= 400: + var error := ApiError.new() + error.identifier = "apibee.response.4xx" + error.message = "%s: request to `%s' was denied with a %d." % [ + self.bee_name, path, response_code + ] + on_failure.call(error) + return + elif response_code >= 300: + var error := ApiError.new() + error.identifier = "apibee.response.3xx" + error.message = "%s: request to `%s' was redirected with a %d. We do not support redirects in that client yet." % [ + self.bee_name, path, response_code + ] + on_failure.call(error) + return + # Should we close ? #self.bee_client.close() diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiError.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiError.handlebars index fd32f3fe04f1..f20540891b4e 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiError.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiError.handlebars @@ -13,3 +13,15 @@ class_name ApiError # The HTTP response code, if any. (usually >= 400) @export var response_code := HTTPClient.RESPONSE_OK + + +func _to_string() -> String: + var s := "" + + if identifier: + s += "%s\n" % identifier + if message: + s += "%s\n" % message + + return s + diff --git a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars index 4e1e79a074b3..ce9be4e810e9 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars @@ -1,9 +1,10 @@ {{>partials/api_headers}} - # API {{classname}} {{>partials/api_statement_extends}} +{{>partials/api_statement_class_name}} + {{#with operations}} {{#each operation}} @@ -28,8 +29,8 @@ func {{operationIdSnakeCase}}( # {{{description}}} {{paramName}}{{#if required}}{{#if dataType}}: {{{dataType}}}{{/if}}{{/if}}{{#unless required}} = {{#defaultValue}}{{{.}}}{{/defaultValue}}{{#unless defaultValue}}null{{/unless}}{{/unless}}, {{/each}} - on_success: Callable, # func(result{{#if returnType}}: {{returnType}}{{/if}}) - on_failure: Callable # func(error: ApiError) + on_success: Callable = Callable(), # func(result{{#if returnType}}: {{returnType}}{{/if}}) + on_failure: Callable = Callable(), # func(error: ApiError) ): # CollectionFormat: {{#if collectionFormat}}YES{{/if}}{{#unless collectionFormat}}NO{{/unless}} @@ -37,7 +38,8 @@ func {{operationIdSnakeCase}}( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. # Compute the URL path to the API resource - var bzz_path := "{{{path}}}"{{#each pathParams}}.replace("{" + "{{baseName}}" + "}", bee_urlize_path_param({{{paramName}}})){{/each}} + var bzz_path := "{{{contextPath}}}{{{path}}}"{{#each pathParams}}.replace("{" + "{{baseName}}" + "}", bee_urlize_path_param({{{paramName}}})){{/each}} + # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays diff --git a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars index 8d5d94b938ba..eef91deec837 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars @@ -10,9 +10,9 @@ # namespace: {{modelPackage}} # invoker: {{invokerPackage}} -{{>partials/api_statement_extends}} +{{>partials/model_statement_extends}} -{{>partials/api_statement_class_name}} +{{>partials/model_statement_class_name}} {{#each vars}} diff --git a/samples/client/petstore/gdscript/apis/PetApi.gd b/samples/client/petstore/gdscript/apis/PetApi.gd index bf9ebd31a95f..67a55a464b64 100644 --- a/samples/client/petstore/gdscript/apis/PetApi.gd +++ b/samples/client/petstore/gdscript/apis/PetApi.gd @@ -2,9 +2,9 @@ # For more information on how to customize templates, see: # https://openapi-generator.tech # The OpenAPI Generator Community, © Public Domain, 2022 - # API PetApi extends ApiBee +class_name PetApi # Operation addPet → POST /pet # Add a new pet to the store @@ -12,8 +12,8 @@ func add_pet( # pet: Pet # Pet object that needs to be added to the store pet: Pet, - on_success: Callable, # func(result: Pet) - on_failure: Callable # func(error: ApiError) + on_success: Callable = Callable(), # func(result: Pet) + on_failure: Callable = Callable(), # func(error: ApiError) ): # CollectionFormat: NO @@ -21,7 +21,8 @@ func add_pet( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. # Compute the URL path to the API resource - var bzz_path := "/pet" + var bzz_path := "/v2/pet" + # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -61,8 +62,8 @@ func delete_pet( # apiKey: String Eg: apiKey_example # apiKey = null, - on_success: Callable, # func(result) - on_failure: Callable # func(error: ApiError) + on_success: Callable = Callable(), # func(result) + on_failure: Callable = Callable(), # func(error: ApiError) ): # CollectionFormat: NO @@ -70,7 +71,8 @@ func delete_pet( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. # Compute the URL path to the API resource - var bzz_path := "/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + var bzz_path := "/v2/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -102,8 +104,8 @@ func find_pets_by_status( # status: Array # Status values that need to be considered for filter status: Array, - on_success: Callable, # func(result: Array) - on_failure: Callable # func(error: ApiError) + on_success: Callable = Callable(), # func(result: Array) + on_failure: Callable = Callable(), # func(error: ApiError) ): # CollectionFormat: NO @@ -111,7 +113,8 @@ func find_pets_by_status( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. # Compute the URL path to the API resource - var bzz_path := "/pet/findByStatus" + var bzz_path := "/v2/pet/findByStatus" + # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -152,8 +155,8 @@ func find_pets_by_tags( # tags: Array # Tags to filter by tags: Array, - on_success: Callable, # func(result: Array) - on_failure: Callable # func(error: ApiError) + on_success: Callable = Callable(), # func(result: Array) + on_failure: Callable = Callable(), # func(error: ApiError) ): # CollectionFormat: NO @@ -161,7 +164,8 @@ func find_pets_by_tags( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. # Compute the URL path to the API resource - var bzz_path := "/pet/findByTags" + var bzz_path := "/v2/pet/findByTags" + # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -201,8 +205,8 @@ func get_pet_by_id( # petId: float Eg: 789 # ID of pet to return petId: float, - on_success: Callable, # func(result: Pet) - on_failure: Callable # func(error: ApiError) + on_success: Callable = Callable(), # func(result: Pet) + on_failure: Callable = Callable(), # func(error: ApiError) ): # CollectionFormat: NO @@ -210,7 +214,8 @@ func get_pet_by_id( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. # Compute the URL path to the API resource - var bzz_path := "/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + var bzz_path := "/v2/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -247,8 +252,8 @@ func update_pet( # pet: Pet # Pet object that needs to be added to the store pet: Pet, - on_success: Callable, # func(result: Pet) - on_failure: Callable # func(error: ApiError) + on_success: Callable = Callable(), # func(result: Pet) + on_failure: Callable = Callable(), # func(error: ApiError) ): # CollectionFormat: NO @@ -256,7 +261,8 @@ func update_pet( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. # Compute the URL path to the API resource - var bzz_path := "/pet" + var bzz_path := "/v2/pet" + # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -299,8 +305,8 @@ func update_pet_with_form( # status: String Eg: status_example # Updated status of the pet status = null, - on_success: Callable, # func(result) - on_failure: Callable # func(error: ApiError) + on_success: Callable = Callable(), # func(result) + on_failure: Callable = Callable(), # func(error: ApiError) ): # CollectionFormat: NO @@ -308,7 +314,8 @@ func update_pet_with_form( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. # Compute the URL path to the API resource - var bzz_path := "/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + var bzz_path := "/v2/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -344,8 +351,8 @@ func upload_file( # file: File Eg: BINARY_DATA_HERE # file to upload file = null, - on_success: Callable, # func(result: ApiResponse) - on_failure: Callable # func(error: ApiError) + on_success: Callable = Callable(), # func(result: ApiResponse) + on_failure: Callable = Callable(), # func(error: ApiError) ): # CollectionFormat: NO @@ -353,7 +360,8 @@ func upload_file( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. # Compute the URL path to the API resource - var bzz_path := "/pet/{petId}/uploadImage".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + var bzz_path := "/v2/pet/{petId}/uploadImage".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays diff --git a/samples/client/petstore/gdscript/apis/StoreApi.gd b/samples/client/petstore/gdscript/apis/StoreApi.gd index 0dccb4b8adab..bbefe28a9c0b 100644 --- a/samples/client/petstore/gdscript/apis/StoreApi.gd +++ b/samples/client/petstore/gdscript/apis/StoreApi.gd @@ -2,9 +2,9 @@ # For more information on how to customize templates, see: # https://openapi-generator.tech # The OpenAPI Generator Community, © Public Domain, 2022 - # API StoreApi extends ApiBee +class_name StoreApi # Operation deleteOrder → DELETE /store/order/{orderId} # Delete purchase order by ID @@ -14,8 +14,8 @@ func delete_order( # orderId: String Eg: orderId_example # ID of the order that needs to be deleted orderId: String, - on_success: Callable, # func(result) - on_failure: Callable # func(error: ApiError) + on_success: Callable = Callable(), # func(result) + on_failure: Callable = Callable(), # func(error: ApiError) ): # CollectionFormat: NO @@ -23,7 +23,8 @@ func delete_order( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. # Compute the URL path to the API resource - var bzz_path := "/store/order/{orderId}".replace("{" + "orderId" + "}", bee_urlize_path_param(orderId)) + var bzz_path := "/v2/store/order/{orderId}".replace("{" + "orderId" + "}", bee_urlize_path_param(orderId)) + # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -52,8 +53,8 @@ func delete_order( # # Returns a map of status codes to quantities func get_inventory( - on_success: Callable, # func(result: Dictionary) - on_failure: Callable # func(error: ApiError) + on_success: Callable = Callable(), # func(result: Dictionary) + on_failure: Callable = Callable(), # func(error: ApiError) ): # CollectionFormat: NO @@ -61,7 +62,8 @@ func get_inventory( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. # Compute the URL path to the API resource - var bzz_path := "/store/inventory" + var bzz_path := "/v2/store/inventory" + # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -100,8 +102,8 @@ func get_order_by_id( # orderId: float Eg: 789 # ID of pet that needs to be fetched orderId: float, - on_success: Callable, # func(result: Order) - on_failure: Callable # func(error: ApiError) + on_success: Callable = Callable(), # func(result: Order) + on_failure: Callable = Callable(), # func(error: ApiError) ): # CollectionFormat: NO @@ -109,7 +111,8 @@ func get_order_by_id( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. # Compute the URL path to the API resource - var bzz_path := "/store/order/{orderId}".replace("{" + "orderId" + "}", bee_urlize_path_param(orderId)) + var bzz_path := "/v2/store/order/{orderId}".replace("{" + "orderId" + "}", bee_urlize_path_param(orderId)) + # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -146,8 +149,8 @@ func place_order( # order: Order # order placed for purchasing the pet order: Order, - on_success: Callable, # func(result: Order) - on_failure: Callable # func(error: ApiError) + on_success: Callable = Callable(), # func(result: Order) + on_failure: Callable = Callable(), # func(error: ApiError) ): # CollectionFormat: NO @@ -155,7 +158,8 @@ func place_order( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. # Compute the URL path to the API resource - var bzz_path := "/store/order" + var bzz_path := "/v2/store/order" + # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays diff --git a/samples/client/petstore/gdscript/apis/UserApi.gd b/samples/client/petstore/gdscript/apis/UserApi.gd index b118065ed1c7..942464d4664f 100644 --- a/samples/client/petstore/gdscript/apis/UserApi.gd +++ b/samples/client/petstore/gdscript/apis/UserApi.gd @@ -2,9 +2,9 @@ # For more information on how to customize templates, see: # https://openapi-generator.tech # The OpenAPI Generator Community, © Public Domain, 2022 - # API UserApi extends ApiBee +class_name UserApi # Operation createUser → POST /user # Create user @@ -14,8 +14,8 @@ func create_user( # user: User # Created user object user: User, - on_success: Callable, # func(result) - on_failure: Callable # func(error: ApiError) + on_success: Callable = Callable(), # func(result) + on_failure: Callable = Callable(), # func(error: ApiError) ): # CollectionFormat: NO @@ -23,7 +23,8 @@ func create_user( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. # Compute the URL path to the API resource - var bzz_path := "/user" + var bzz_path := "/v2/user" + # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -53,8 +54,8 @@ func create_users_with_array_input( # user: Array # List of user object user: Array, - on_success: Callable, # func(result) - on_failure: Callable # func(error: ApiError) + on_success: Callable = Callable(), # func(result) + on_failure: Callable = Callable(), # func(error: ApiError) ): # CollectionFormat: NO @@ -62,7 +63,8 @@ func create_users_with_array_input( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. # Compute the URL path to the API resource - var bzz_path := "/user/createWithArray" + var bzz_path := "/v2/user/createWithArray" + # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -92,8 +94,8 @@ func create_users_with_list_input( # user: Array # List of user object user: Array, - on_success: Callable, # func(result) - on_failure: Callable # func(error: ApiError) + on_success: Callable = Callable(), # func(result) + on_failure: Callable = Callable(), # func(error: ApiError) ): # CollectionFormat: NO @@ -101,7 +103,8 @@ func create_users_with_list_input( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. # Compute the URL path to the API resource - var bzz_path := "/user/createWithList" + var bzz_path := "/v2/user/createWithList" + # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -133,8 +136,8 @@ func delete_user( # username: String Eg: username_example # The name that needs to be deleted username: String, - on_success: Callable, # func(result) - on_failure: Callable # func(error: ApiError) + on_success: Callable = Callable(), # func(result) + on_failure: Callable = Callable(), # func(error: ApiError) ): # CollectionFormat: NO @@ -142,7 +145,8 @@ func delete_user( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. # Compute the URL path to the API resource - var bzz_path := "/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) + var bzz_path := "/v2/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) + # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -172,8 +176,8 @@ func get_user_by_name( # username: String Eg: username_example # The name that needs to be fetched. Use user1 for testing. username: String, - on_success: Callable, # func(result: User) - on_failure: Callable # func(error: ApiError) + on_success: Callable = Callable(), # func(result: User) + on_failure: Callable = Callable(), # func(error: ApiError) ): # CollectionFormat: NO @@ -181,7 +185,8 @@ func get_user_by_name( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. # Compute the URL path to the API resource - var bzz_path := "/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) + var bzz_path := "/v2/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) + # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -221,8 +226,8 @@ func login_user( # password: String Eg: password_example # The password for login in clear text password: String, - on_success: Callable, # func(result: String) - on_failure: Callable # func(error: ApiError) + on_success: Callable = Callable(), # func(result: String) + on_failure: Callable = Callable(), # func(error: ApiError) ): # CollectionFormat: NO @@ -230,7 +235,8 @@ func login_user( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. # Compute the URL path to the API resource - var bzz_path := "/user/login" + var bzz_path := "/v2/user/login" + # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -266,8 +272,8 @@ func login_user( # Operation logoutUser → GET /user/logout # Logs out current logged in user session func logout_user( - on_success: Callable, # func(result) - on_failure: Callable # func(error: ApiError) + on_success: Callable = Callable(), # func(result) + on_failure: Callable = Callable(), # func(error: ApiError) ): # CollectionFormat: NO @@ -275,7 +281,8 @@ func logout_user( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. # Compute the URL path to the API resource - var bzz_path := "/user/logout" + var bzz_path := "/v2/user/logout" + # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -310,8 +317,8 @@ func update_user( # user: User # Updated user object user: User, - on_success: Callable, # func(result) - on_failure: Callable # func(error: ApiError) + on_success: Callable = Callable(), # func(result) + on_failure: Callable = Callable(), # func(error: ApiError) ): # CollectionFormat: NO @@ -319,7 +326,8 @@ func update_user( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. # Compute the URL path to the API resource - var bzz_path := "/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) + var bzz_path := "/v2/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) + # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays diff --git a/samples/client/petstore/gdscript/core/ApiBee.gd b/samples/client/petstore/gdscript/core/ApiBee.gd index f6b434c3bf80..d697a685dad0 100644 --- a/samples/client/petstore/gdscript/core/ApiBee.gd +++ b/samples/client/petstore/gdscript/core/ApiBee.gd @@ -66,10 +66,7 @@ func bee_disable_ssl(): func bee_next_loop_iteration(): - # Use this when it works, on release (beta3 now) -# return Engine.get_main_loop().idle_frame - # For now, this works - return RenderingServer.frame_post_draw + return Engine.get_main_loop().process_frame func bee_connect_client_if_needed( @@ -285,6 +282,32 @@ func bee_do_request_text( else: response_text = response_bytes.get_string_from_ascii() + if response_code >= 500: + var error := ApiError.new() + error.internal_code = ERR_PRINTER_ON_FIRE + error.identifier = "apibee.response.5xx" + error.message = "%s: request to `%s' made the server hiccup with a %d." % [ + self.bee_name, path, response_code + ] + on_failure.call(error) + return + elif response_code >= 400: + var error := ApiError.new() + error.identifier = "apibee.response.4xx" + error.message = "%s: request to `%s' was denied with a %d." % [ + self.bee_name, path, response_code + ] + on_failure.call(error) + return + elif response_code >= 300: + var error := ApiError.new() + error.identifier = "apibee.response.3xx" + error.message = "%s: request to `%s' was redirected with a %d. We do not support redirects in that client yet." % [ + self.bee_name, path, response_code + ] + on_failure.call(error) + return + # Should we close ? #self.bee_client.close() diff --git a/samples/client/petstore/gdscript/core/ApiError.gd b/samples/client/petstore/gdscript/core/ApiError.gd index fd32f3fe04f1..f20540891b4e 100644 --- a/samples/client/petstore/gdscript/core/ApiError.gd +++ b/samples/client/petstore/gdscript/core/ApiError.gd @@ -13,3 +13,15 @@ class_name ApiError # The HTTP response code, if any. (usually >= 400) @export var response_code := HTTPClient.RESPONSE_OK + + +func _to_string() -> String: + var s := "" + + if identifier: + s += "%s\n" % identifier + if message: + s += "%s\n" % message + + return s + diff --git a/samples/client/petstore/gdscript/demo/main.gd b/samples/client/petstore/gdscript/demo/main.gd index a199e0cf5f8a..405bfc960f7b 100644 --- a/samples/client/petstore/gdscript/demo/main.gd +++ b/samples/client/petstore/gdscript/demo/main.gd @@ -1,15 +1,85 @@ extends Control +# Note: we also log to /tmp/gdscript_petstore.log +# And since I can't figure out how to set an exit code, +# we will need to parse that log (read its last line) to assess +# whether the test suite passed or not. (when integrating with CI) +const LAST_LINE_SUITE_FAILED := "ERROR" +const LAST_LINE_SUITE_PASSED := "OK" + + +@onready var log_text_edit := $HBoxContainer/LogDump + + +var failed := false + + func _ready(): - Logger.text_edit_to_fill = $HBoxContainer/LogDump + $HBoxContainer/VBoxContainer/RunTestsButton.grab_focus() + Logger.text_edit_to_fill = log_text_edit Logger.inform("Petstore demo is ready.") + if is_headless(): + run_all_tests() + #gtfo() + + +func _on_run_tests_button_pressed(): + run_all_tests() func _on_exit_button_pressed(): - Logger.inform("Goodbye.") - get_tree().quit() + gtfo() -func _on_run_tests_button_pressed(): - pass # Replace with function body. +func gtfo(err_code := 0): + Engine.get_main_loop().quit(err_code) + + +func is_headless() -> bool: + # I have no shame, and no idea how to detect --headless + #print(OS.get_cmdline_args()) # empty + #print(OS.get_cmdline_user_args()) # empty + #print(OS.get_environment("HEADLESS")) # works, but cumbersome + return "" == RenderingServer.get_video_adapter_name() + + +func fail(msg: String): + Logger.error(msg) + Logger.inform(LAST_LINE_SUITE_FAILED) + failed = true + gtfo(1) + + +func run_all_tests(): + log_text_edit.text = "" + run_test_01() + + # Oh no that won't work ; async woes + if not failed: + Logger.inform(LAST_LINE_SUITE_PASSED) + + +func run_test_01(): + Logger.inform("Running test 01…") + + var monkey = Pet.new() + monkey.name = "Grégoire" + monkey.tags = ['tree', 'fur'] + + var pet_api := PetApi.new() + pet_api.bee_port = 81 + pet_api.add_pet( + monkey, + func(result): + print("Added monkey.") + , + func(error): + Logger.warn("OH NOES!") + Logger.warn(str(error)) + , + ) + + + + diff --git a/samples/client/petstore/gdscript/models/ApiResponse.gd b/samples/client/petstore/gdscript/models/ApiResponse.gd index 5e4dc8eeaf5c..e770bfcf1db5 100644 --- a/samples/client/petstore/gdscript/models/ApiResponse.gd +++ b/samples/client/petstore/gdscript/models/ApiResponse.gd @@ -8,7 +8,7 @@ # namespace: models # invoker: -extends ApiBee +extends RefCounted class_name ApiResponse # Type: int diff --git a/samples/client/petstore/gdscript/models/Category.gd b/samples/client/petstore/gdscript/models/Category.gd index e6ed82f1e784..0abdb8216c1d 100644 --- a/samples/client/petstore/gdscript/models/Category.gd +++ b/samples/client/petstore/gdscript/models/Category.gd @@ -8,7 +8,7 @@ # namespace: models # invoker: -extends ApiBee +extends RefCounted class_name Category # Type: float diff --git a/samples/client/petstore/gdscript/models/Order.gd b/samples/client/petstore/gdscript/models/Order.gd index b67705324d86..61f2fc597210 100644 --- a/samples/client/petstore/gdscript/models/Order.gd +++ b/samples/client/petstore/gdscript/models/Order.gd @@ -8,7 +8,7 @@ # namespace: models # invoker: -extends ApiBee +extends RefCounted class_name Order # Type: float @@ -26,9 +26,9 @@ var petId: float var quantity: int -# Type: DateTime +# Type: Dictionary # Required: False -var shipDate: DateTime +var shipDate: Dictionary # Order Status diff --git a/samples/client/petstore/gdscript/models/Pet.gd b/samples/client/petstore/gdscript/models/Pet.gd index c56acb95e800..d694d4455c1e 100644 --- a/samples/client/petstore/gdscript/models/Pet.gd +++ b/samples/client/petstore/gdscript/models/Pet.gd @@ -8,7 +8,7 @@ # namespace: models # invoker: -extends ApiBee +extends RefCounted class_name Pet # Type: float diff --git a/samples/client/petstore/gdscript/models/Tag.gd b/samples/client/petstore/gdscript/models/Tag.gd index 7ba43a75f552..b697d7a38db2 100644 --- a/samples/client/petstore/gdscript/models/Tag.gd +++ b/samples/client/petstore/gdscript/models/Tag.gd @@ -8,7 +8,7 @@ # namespace: models # invoker: -extends ApiBee +extends RefCounted class_name Tag # Type: float diff --git a/samples/client/petstore/gdscript/models/User.gd b/samples/client/petstore/gdscript/models/User.gd index aef534a1c19f..2c881cbd2f4d 100644 --- a/samples/client/petstore/gdscript/models/User.gd +++ b/samples/client/petstore/gdscript/models/User.gd @@ -8,7 +8,7 @@ # namespace: models # invoker: -extends ApiBee +extends RefCounted class_name User # Type: float diff --git a/samples/client/petstore/gdscript/project.godot b/samples/client/petstore/gdscript/project.godot index 18e6215c1c6b..927cdf8e8c08 100644 --- a/samples/client/petstore/gdscript/project.godot +++ b/samples/client/petstore/gdscript/project.godot @@ -19,35 +19,50 @@ _global_script_classes=[{ "language": &"GDScript", "path": "res://core/ApiError.gd" }, { -"base": "ApiBee", +"base": "RefCounted", "class": &"ApiResponse", "language": &"GDScript", "path": "res://models/ApiResponse.gd" }, { -"base": "ApiBee", +"base": "RefCounted", "class": &"Category", "language": &"GDScript", "path": "res://models/Category.gd" }, { -"base": "ApiBee", +"base": "RefCounted", "class": &"Order", "language": &"GDScript", "path": "res://models/Order.gd" }, { -"base": "ApiBee", +"base": "RefCounted", "class": &"Pet", "language": &"GDScript", "path": "res://models/Pet.gd" }, { "base": "ApiBee", +"class": &"PetApi", +"language": &"GDScript", +"path": "res://apis/PetApi.gd" +}, { +"base": "ApiBee", +"class": &"StoreApi", +"language": &"GDScript", +"path": "res://apis/StoreApi.gd" +}, { +"base": "RefCounted", "class": &"Tag", "language": &"GDScript", "path": "res://models/Tag.gd" }, { -"base": "ApiBee", +"base": "RefCounted", "class": &"User", "language": &"GDScript", "path": "res://models/User.gd" +}, { +"base": "ApiBee", +"class": &"UserApi", +"language": &"GDScript", +"path": "res://apis/UserApi.gd" }] _global_script_class_icons={ "ApiBee": "", @@ -56,13 +71,17 @@ _global_script_class_icons={ "Category": "", "Order": "", "Pet": "", +"PetApi": "", +"StoreApi": "", "Tag": "", -"User": "" +"User": "", +"UserApi": "" } [application] config/name="GDScript Petstore Client" +config/description="A demo of the generated GDScript client for the petstore sample." run/main_scene="res://demo/main.tscn" config/features=PackedStringArray("4.0", "Forward Plus") config/icon="res://icon.svg" @@ -70,3 +89,8 @@ config/icon="res://icon.svg" [autoload] Logger="*res://demo/Logger.gd" + +[debug] + +file_logging/enable_file_logging=true +file_logging/log_path="/tmp/gdscript_petstore.log" From e3d07b5c182f3b077bcd0e170170cfd87ae0d362 Mon Sep 17 00:00:00 2001 From: Goutte Date: Thu, 20 Oct 2022 07:07:39 +0200 Subject: [PATCH 08/56] feat(gdscript): serialize and send body params The test suite is now past its first hurdle, the 415 HTTP status code, and went straight into an unexpected error 500. I suspect the server does not like me trying to set the pet id at 0, because that's what we're trying to do right now. Godot is crashing a lot, mostly because I don't know how to make Callable.NOOP and my current solution hints at optional on_success and on_failure, yet if we omit them the engine will ragequit. --- .../main/resources/gdscript/ApiBee.handlebars | 48 ++++++++++++--- .../main/resources/gdscript/api.handlebars | 10 +++- .../main/resources/gdscript/model.handlebars | 7 +++ .../client/petstore/gdscript/apis/PetApi.gd | 58 ++++++++++-------- .../client/petstore/gdscript/apis/StoreApi.gd | 29 +++++---- .../client/petstore/gdscript/apis/UserApi.gd | 60 +++++++++++-------- .../client/petstore/gdscript/core/ApiBee.gd | 48 ++++++++++++--- samples/client/petstore/gdscript/demo/main.gd | 50 +++++++++------- .../petstore/gdscript/models/ApiResponse.gd | 7 +++ .../petstore/gdscript/models/Category.gd | 6 ++ .../client/petstore/gdscript/models/Order.gd | 10 ++++ .../client/petstore/gdscript/models/Pet.gd | 10 ++++ .../client/petstore/gdscript/models/Tag.gd | 6 ++ .../client/petstore/gdscript/models/User.gd | 12 ++++ 14 files changed, 258 insertions(+), 103 deletions(-) diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars index d697a685dad0..19681427f404 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars @@ -131,12 +131,13 @@ func bee_request( method: int, # one of HTTPClient.METHOD_XXXXX path: String, query: Dictionary, + body, # Variant that will be serialized on_success: Callable, # func(response: Variant, responseCode: int, responseHeaders: Dictionary) on_failure: Callable, # func(error: ApiError) ): bee_request_text( - method, path, query, + method, path, query, body, func(responseText, responseCode, responseHeaders): var mime: String = responseHeaders['Mime'] var deserializedResponse: Dictionary @@ -179,12 +180,13 @@ func bee_request_text( method: int, # one of HTTPClient.METHOD_XXXXX path: String, query: Dictionary, + body, # Variant that will be serialized on_success: Callable, # func(responseText: String, responseCode: int, responseHeaders: Dictionary) on_failure: Callable, # func(error: ApiError) ): bee_connect_client_if_needed( func(): - bee_do_request_text(method, path, query, on_success, on_failure) + bee_do_request_text(method, path, query, body, on_success, on_failure) , func(error): on_failure.call(error) @@ -197,25 +199,31 @@ func bee_do_request_text( method: int, # one of HTTPClient.METHOD_XXXXX path: String, query: Dictionary, + body, # Variant that will be serialized on_success: Callable, # func(responseText: String, responseCode: int, responseHeaders: Dictionary) on_failure: Callable, # func(error: ApiError) ): - # How can we help users define more / override these? + # TODO: How can we help users define more / override these? # 1. template overrides # 2. CLI args # 3. YAML Config file + # 4. class property var headers = [ - "User-Agent: Pirulo/1.0 (Godot)", - "Accept: */*", + "User-Agent: Stigmergiac/1.0 (Godot)", + "Accept: application/json", + "Content-Type: application/json", ] + # TODO: Handle other serialization schemes (json+ld, xml…) + var body_serialized = JSON.stringify(body.normalize()) + var path_queried := path var query_string := self.bee_client.query_string_from_dict(query) if query_string: path_queried = "%s?%s" % [path, query_string] - var requesting := self.bee_client.request(method, path_queried, headers) + var requesting := self.bee_client.request(method, path_queried, headers, body_serialized) if requesting != OK: var error := ApiError.new() error.internal_code = requesting @@ -253,9 +261,6 @@ func bee_do_request_text( response_headers['Encoding'] = encoding response_headers['Mime'] = mime - prints("RESPONSE CODE:", response_code) - prints("RESPONSE HEADERS:", response_headers) - # TODO: cap the size of this, perhaps? var response_bytes := PackedByteArray() @@ -270,6 +275,8 @@ func bee_do_request_text( else: # Yummy data has arrived response_bytes = response_bytes + chunk + prints("RESPONSE CODE:", response_code) + prints("RESPONSE HEADERS:", response_headers) print("RESPONSE SIZE: %d bytes " % response_bytes.size()) var response_text: String @@ -289,6 +296,9 @@ func bee_do_request_text( error.message = "%s: request to `%s' made the server hiccup with a %d." % [ self.bee_name, path, response_code ] + error.message += "\n%s" % [ + bee_format_error_response(response_text) + ] on_failure.call(error) return elif response_code >= 400: @@ -297,6 +307,9 @@ func bee_do_request_text( error.message = "%s: request to `%s' was denied with a %d." % [ self.bee_name, path, response_code ] + error.message += "\n%s" % [ + bee_format_error_response(response_text) + ] on_failure.call(error) return elif response_code >= 300: @@ -342,3 +355,20 @@ func bee_escape_path_param(value: String) -> String: # TODO: escape for URL return value + +func bee_format_error_response(response: String) -> String: + # TODO: handle other (de)serialization schemes + var parser := JSON.new() + var parsing := parser.parse(response) + if OK != parsing: + return response + if not (parser.data is Dictionary): + return response + var s := "ERROR" + if parser.data.has("code"): + s += " %d" % parser.data['code'] + if parser.data.has("message"): + s += "\n%s" % parser.data['message'] + else: + return response + return s diff --git a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars index ce9be4e810e9..2e286f47997c 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars @@ -40,6 +40,8 @@ func {{operationIdSnakeCase}}( # Compute the URL path to the API resource var bzz_path := "{{{contextPath}}}{{{path}}}"{{#each pathParams}}.replace("{" + "{{baseName}}" + "}", bee_urlize_path_param({{{paramName}}})){{/each}} + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := bee_convert_http_method("{{httpMethod}}") # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -48,8 +50,10 @@ func {{operationIdSnakeCase}}( bzz_query["{{baseName}}"] = {{paramName}} {{/each}} - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("{{httpMethod}}") + var bzz_body + {{#each bodyParams}} + bzz_body = {{paramName}} + {{/each}} {{#with returnProperty}} # Will be used at some point for denormalization @@ -62,7 +66,7 @@ func {{operationIdSnakeCase}}( {{/with}} bee_request( - bzz_method, bzz_path, bzz_query, + bzz_method, bzz_path, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) diff --git a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars index eef91deec837..8336844fc6ad 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars @@ -32,5 +32,12 @@ var {{name}}: {{dataType}}{{#if defaultValue}} = {{{defaultValue}}}{{/if}} {{/each}} +func normalize() -> Dictionary: + return { +{{#each vars}} + "{{name}}": self.{{name}}, +{{/each}} + } + {{/with}} {{/each}} \ No newline at end of file diff --git a/samples/client/petstore/gdscript/apis/PetApi.gd b/samples/client/petstore/gdscript/apis/PetApi.gd index 67a55a464b64..77f2490225f6 100644 --- a/samples/client/petstore/gdscript/apis/PetApi.gd +++ b/samples/client/petstore/gdscript/apis/PetApi.gd @@ -23,13 +23,15 @@ func add_pet( # Compute the URL path to the API resource var bzz_path := "/v2/pet" + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := bee_convert_http_method("POST") # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("POST") + var bzz_body + bzz_body = pet # Will be used at some point for denormalization # baseType = "Pet" @@ -40,7 +42,7 @@ func add_pet( var bzz_return_type := "Pet" bee_request( - bzz_method, bzz_path, bzz_query, + bzz_method, bzz_path, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -73,17 +75,18 @@ func delete_pet( # Compute the URL path to the API resource var bzz_path := "/v2/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := bee_convert_http_method("DELETE") # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("DELETE") + var bzz_body bee_request( - bzz_method, bzz_path, bzz_query, + bzz_method, bzz_path, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -115,14 +118,15 @@ func find_pets_by_status( # Compute the URL path to the API resource var bzz_path := "/v2/pet/findByStatus" + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := bee_convert_http_method("GET") # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() bzz_query["status"] = status - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("GET") + var bzz_body # Will be used at some point for denormalization # baseType = "array" @@ -133,7 +137,7 @@ func find_pets_by_status( var bzz_return_type := "Pet" bee_request( - bzz_method, bzz_path, bzz_query, + bzz_method, bzz_path, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -166,14 +170,15 @@ func find_pets_by_tags( # Compute the URL path to the API resource var bzz_path := "/v2/pet/findByTags" + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := bee_convert_http_method("GET") # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() bzz_query["tags"] = tags - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("GET") + var bzz_body # Will be used at some point for denormalization # baseType = "array" @@ -184,7 +189,7 @@ func find_pets_by_tags( var bzz_return_type := "Pet" bee_request( - bzz_method, bzz_path, bzz_query, + bzz_method, bzz_path, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -216,13 +221,14 @@ func get_pet_by_id( # Compute the URL path to the API resource var bzz_path := "/v2/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := bee_convert_http_method("GET") # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("GET") + var bzz_body # Will be used at some point for denormalization # baseType = "Pet" @@ -233,7 +239,7 @@ func get_pet_by_id( var bzz_return_type := "Pet" bee_request( - bzz_method, bzz_path, bzz_query, + bzz_method, bzz_path, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -263,13 +269,15 @@ func update_pet( # Compute the URL path to the API resource var bzz_path := "/v2/pet" + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := bee_convert_http_method("PUT") # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("PUT") + var bzz_body + bzz_body = pet # Will be used at some point for denormalization # baseType = "Pet" @@ -280,7 +288,7 @@ func update_pet( var bzz_return_type := "Pet" bee_request( - bzz_method, bzz_path, bzz_query, + bzz_method, bzz_path, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -316,17 +324,18 @@ func update_pet_with_form( # Compute the URL path to the API resource var bzz_path := "/v2/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := bee_convert_http_method("POST") # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("POST") + var bzz_body bee_request( - bzz_method, bzz_path, bzz_query, + bzz_method, bzz_path, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -362,13 +371,14 @@ func upload_file( # Compute the URL path to the API resource var bzz_path := "/v2/pet/{petId}/uploadImage".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := bee_convert_http_method("POST") # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("POST") + var bzz_body # Will be used at some point for denormalization # baseType = "ApiResponse" @@ -379,7 +389,7 @@ func upload_file( var bzz_return_type := "ApiResponse" bee_request( - bzz_method, bzz_path, bzz_query, + bzz_method, bzz_path, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) diff --git a/samples/client/petstore/gdscript/apis/StoreApi.gd b/samples/client/petstore/gdscript/apis/StoreApi.gd index bbefe28a9c0b..699e1da60ac0 100644 --- a/samples/client/petstore/gdscript/apis/StoreApi.gd +++ b/samples/client/petstore/gdscript/apis/StoreApi.gd @@ -25,17 +25,18 @@ func delete_order( # Compute the URL path to the API resource var bzz_path := "/v2/store/order/{orderId}".replace("{" + "orderId" + "}", bee_urlize_path_param(orderId)) + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := bee_convert_http_method("DELETE") # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("DELETE") + var bzz_body bee_request( - bzz_method, bzz_path, bzz_query, + bzz_method, bzz_path, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -64,13 +65,14 @@ func get_inventory( # Compute the URL path to the API resource var bzz_path := "/v2/store/inventory" + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := bee_convert_http_method("GET") # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("GET") + var bzz_body # Will be used at some point for denormalization # baseType = "map" @@ -81,7 +83,7 @@ func get_inventory( var bzz_return_type := "integer" bee_request( - bzz_method, bzz_path, bzz_query, + bzz_method, bzz_path, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -113,13 +115,14 @@ func get_order_by_id( # Compute the URL path to the API resource var bzz_path := "/v2/store/order/{orderId}".replace("{" + "orderId" + "}", bee_urlize_path_param(orderId)) + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := bee_convert_http_method("GET") # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("GET") + var bzz_body # Will be used at some point for denormalization # baseType = "Order" @@ -130,7 +133,7 @@ func get_order_by_id( var bzz_return_type := "Order" bee_request( - bzz_method, bzz_path, bzz_query, + bzz_method, bzz_path, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -160,13 +163,15 @@ func place_order( # Compute the URL path to the API resource var bzz_path := "/v2/store/order" + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := bee_convert_http_method("POST") # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("POST") + var bzz_body + bzz_body = order # Will be used at some point for denormalization # baseType = "Order" @@ -177,7 +182,7 @@ func place_order( var bzz_return_type := "Order" bee_request( - bzz_method, bzz_path, bzz_query, + bzz_method, bzz_path, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) diff --git a/samples/client/petstore/gdscript/apis/UserApi.gd b/samples/client/petstore/gdscript/apis/UserApi.gd index 942464d4664f..b7e936abd167 100644 --- a/samples/client/petstore/gdscript/apis/UserApi.gd +++ b/samples/client/petstore/gdscript/apis/UserApi.gd @@ -25,17 +25,19 @@ func create_user( # Compute the URL path to the API resource var bzz_path := "/v2/user" + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := bee_convert_http_method("POST") # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("POST") + var bzz_body + bzz_body = user bee_request( - bzz_method, bzz_path, bzz_query, + bzz_method, bzz_path, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -65,17 +67,19 @@ func create_users_with_array_input( # Compute the URL path to the API resource var bzz_path := "/v2/user/createWithArray" + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := bee_convert_http_method("POST") # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("POST") + var bzz_body + bzz_body = user bee_request( - bzz_method, bzz_path, bzz_query, + bzz_method, bzz_path, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -105,17 +109,19 @@ func create_users_with_list_input( # Compute the URL path to the API resource var bzz_path := "/v2/user/createWithList" + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := bee_convert_http_method("POST") # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("POST") + var bzz_body + bzz_body = user bee_request( - bzz_method, bzz_path, bzz_query, + bzz_method, bzz_path, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -147,17 +153,18 @@ func delete_user( # Compute the URL path to the API resource var bzz_path := "/v2/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := bee_convert_http_method("DELETE") # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("DELETE") + var bzz_body bee_request( - bzz_method, bzz_path, bzz_query, + bzz_method, bzz_path, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -187,13 +194,14 @@ func get_user_by_name( # Compute the URL path to the API resource var bzz_path := "/v2/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := bee_convert_http_method("GET") # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("GET") + var bzz_body # Will be used at some point for denormalization # baseType = "User" @@ -204,7 +212,7 @@ func get_user_by_name( var bzz_return_type := "User" bee_request( - bzz_method, bzz_path, bzz_query, + bzz_method, bzz_path, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -237,6 +245,8 @@ func login_user( # Compute the URL path to the API resource var bzz_path := "/v2/user/login" + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := bee_convert_http_method("GET") # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -244,8 +254,7 @@ func login_user( bzz_query["username"] = username bzz_query["password"] = password - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("GET") + var bzz_body # Will be used at some point for denormalization # baseType = "string" @@ -256,7 +265,7 @@ func login_user( var bzz_return_type := "string" bee_request( - bzz_method, bzz_path, bzz_query, + bzz_method, bzz_path, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -283,17 +292,18 @@ func logout_user( # Compute the URL path to the API resource var bzz_path := "/v2/user/logout" + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := bee_convert_http_method("GET") # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("GET") + var bzz_body bee_request( - bzz_method, bzz_path, bzz_query, + bzz_method, bzz_path, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -328,17 +338,19 @@ func update_user( # Compute the URL path to the API resource var bzz_path := "/v2/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := bee_convert_http_method("PUT") # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - # Convert the HTTP method to something Godot understands - var bzz_method := bee_convert_http_method("PUT") + var bzz_body + bzz_body = user bee_request( - bzz_method, bzz_path, bzz_query, + bzz_method, bzz_path, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) diff --git a/samples/client/petstore/gdscript/core/ApiBee.gd b/samples/client/petstore/gdscript/core/ApiBee.gd index d697a685dad0..19681427f404 100644 --- a/samples/client/petstore/gdscript/core/ApiBee.gd +++ b/samples/client/petstore/gdscript/core/ApiBee.gd @@ -131,12 +131,13 @@ func bee_request( method: int, # one of HTTPClient.METHOD_XXXXX path: String, query: Dictionary, + body, # Variant that will be serialized on_success: Callable, # func(response: Variant, responseCode: int, responseHeaders: Dictionary) on_failure: Callable, # func(error: ApiError) ): bee_request_text( - method, path, query, + method, path, query, body, func(responseText, responseCode, responseHeaders): var mime: String = responseHeaders['Mime'] var deserializedResponse: Dictionary @@ -179,12 +180,13 @@ func bee_request_text( method: int, # one of HTTPClient.METHOD_XXXXX path: String, query: Dictionary, + body, # Variant that will be serialized on_success: Callable, # func(responseText: String, responseCode: int, responseHeaders: Dictionary) on_failure: Callable, # func(error: ApiError) ): bee_connect_client_if_needed( func(): - bee_do_request_text(method, path, query, on_success, on_failure) + bee_do_request_text(method, path, query, body, on_success, on_failure) , func(error): on_failure.call(error) @@ -197,25 +199,31 @@ func bee_do_request_text( method: int, # one of HTTPClient.METHOD_XXXXX path: String, query: Dictionary, + body, # Variant that will be serialized on_success: Callable, # func(responseText: String, responseCode: int, responseHeaders: Dictionary) on_failure: Callable, # func(error: ApiError) ): - # How can we help users define more / override these? + # TODO: How can we help users define more / override these? # 1. template overrides # 2. CLI args # 3. YAML Config file + # 4. class property var headers = [ - "User-Agent: Pirulo/1.0 (Godot)", - "Accept: */*", + "User-Agent: Stigmergiac/1.0 (Godot)", + "Accept: application/json", + "Content-Type: application/json", ] + # TODO: Handle other serialization schemes (json+ld, xml…) + var body_serialized = JSON.stringify(body.normalize()) + var path_queried := path var query_string := self.bee_client.query_string_from_dict(query) if query_string: path_queried = "%s?%s" % [path, query_string] - var requesting := self.bee_client.request(method, path_queried, headers) + var requesting := self.bee_client.request(method, path_queried, headers, body_serialized) if requesting != OK: var error := ApiError.new() error.internal_code = requesting @@ -253,9 +261,6 @@ func bee_do_request_text( response_headers['Encoding'] = encoding response_headers['Mime'] = mime - prints("RESPONSE CODE:", response_code) - prints("RESPONSE HEADERS:", response_headers) - # TODO: cap the size of this, perhaps? var response_bytes := PackedByteArray() @@ -270,6 +275,8 @@ func bee_do_request_text( else: # Yummy data has arrived response_bytes = response_bytes + chunk + prints("RESPONSE CODE:", response_code) + prints("RESPONSE HEADERS:", response_headers) print("RESPONSE SIZE: %d bytes " % response_bytes.size()) var response_text: String @@ -289,6 +296,9 @@ func bee_do_request_text( error.message = "%s: request to `%s' made the server hiccup with a %d." % [ self.bee_name, path, response_code ] + error.message += "\n%s" % [ + bee_format_error_response(response_text) + ] on_failure.call(error) return elif response_code >= 400: @@ -297,6 +307,9 @@ func bee_do_request_text( error.message = "%s: request to `%s' was denied with a %d." % [ self.bee_name, path, response_code ] + error.message += "\n%s" % [ + bee_format_error_response(response_text) + ] on_failure.call(error) return elif response_code >= 300: @@ -342,3 +355,20 @@ func bee_escape_path_param(value: String) -> String: # TODO: escape for URL return value + +func bee_format_error_response(response: String) -> String: + # TODO: handle other (de)serialization schemes + var parser := JSON.new() + var parsing := parser.parse(response) + if OK != parsing: + return response + if not (parser.data is Dictionary): + return response + var s := "ERROR" + if parser.data.has("code"): + s += " %d" % parser.data['code'] + if parser.data.has("message"): + s += "\n%s" % parser.data['message'] + else: + return response + return s diff --git a/samples/client/petstore/gdscript/demo/main.gd b/samples/client/petstore/gdscript/demo/main.gd index 405bfc960f7b..c0151a714a77 100644 --- a/samples/client/petstore/gdscript/demo/main.gd +++ b/samples/client/petstore/gdscript/demo/main.gd @@ -1,14 +1,8 @@ extends Control +signal test_ended -# Note: we also log to /tmp/gdscript_petstore.log -# And since I can't figure out how to set an exit code, -# we will need to parse that log (read its last line) to assess -# whether the test suite passed or not. (when integrating with CI) -const LAST_LINE_SUITE_FAILED := "ERROR" -const LAST_LINE_SUITE_PASSED := "OK" - - +@onready var run_tests_button := $HBoxContainer/VBoxContainer/RunTestsButton @onready var log_text_edit := $HBoxContainer/LogDump @@ -16,16 +10,18 @@ var failed := false func _ready(): - $HBoxContainer/VBoxContainer/RunTestsButton.grab_focus() + # Note: we also log to /tmp/gdscript_petstore.log Logger.text_edit_to_fill = log_text_edit Logger.inform("Petstore demo is ready.") + if is_headless(): - run_all_tests() - #gtfo() + run_all_tests(func(): gtfo()) + else: + run_tests_button.grab_focus() func _on_run_tests_button_pressed(): - run_all_tests() + run_all_tests(func(): pass) func _on_exit_button_pressed(): @@ -37,7 +33,7 @@ func gtfo(err_code := 0): func is_headless() -> bool: - # I have no shame, and no idea how to detect --headless + # I have no shame, and no other idea how to detect --headless #print(OS.get_cmdline_args()) # empty #print(OS.get_cmdline_user_args()) # empty #print(OS.get_environment("HEADLESS")) # works, but cumbersome @@ -46,24 +42,27 @@ func is_headless() -> bool: func fail(msg: String): Logger.error(msg) - Logger.inform(LAST_LINE_SUITE_FAILED) failed = true gtfo(1) -func run_all_tests(): +func run_all_tests(on_done := Callable()): log_text_edit.text = "" + var started_at := Time.get_ticks_msec() run_test_01() - - # Oh no that won't work ; async woes - if not failed: - Logger.inform(LAST_LINE_SUITE_PASSED) + await test_ended +# run_test_02() +# await test_ended + # … + var ended_at := Time.get_ticks_msec() + Logger.inform("Ran tests for %.2fs" % [0.001 * (ended_at - started_at)]) + on_done.call() func run_test_01(): Logger.inform("Running test 01…") - var monkey = Pet.new() + var monkey := Pet.new() monkey.name = "Grégoire" monkey.tags = ['tree', 'fur'] @@ -73,10 +72,17 @@ func run_test_01(): monkey, func(result): print("Added monkey.") + emit_signal("test_ended") , + #func(error: ApiError): # ← straight up crash, try again later func(error): - Logger.warn("OH NOES!") - Logger.warn(str(error)) + # OH GOSH THIS CRASHES AS WELL (works with RefCounted) + # (but error does have type ApiError) +# if not (error is ApiError): +# fail("Error in on_failure callback has the wrong type.") + printerr("ERROR!") + fail(str(error)) + emit_signal("test_ended") , ) diff --git a/samples/client/petstore/gdscript/models/ApiResponse.gd b/samples/client/petstore/gdscript/models/ApiResponse.gd index e770bfcf1db5..c74eef8ab4e6 100644 --- a/samples/client/petstore/gdscript/models/ApiResponse.gd +++ b/samples/client/petstore/gdscript/models/ApiResponse.gd @@ -27,3 +27,10 @@ var message: String +func normalize() -> Dictionary: + return { + "code": self.code, + "type": self.type, + "message": self.message, + } + diff --git a/samples/client/petstore/gdscript/models/Category.gd b/samples/client/petstore/gdscript/models/Category.gd index 0abdb8216c1d..3139a16e99d6 100644 --- a/samples/client/petstore/gdscript/models/Category.gd +++ b/samples/client/petstore/gdscript/models/Category.gd @@ -22,3 +22,9 @@ var name: String +func normalize() -> Dictionary: + return { + "id": self.id, + "name": self.name, + } + diff --git a/samples/client/petstore/gdscript/models/Order.gd b/samples/client/petstore/gdscript/models/Order.gd index 61f2fc597210..48ffbe2ccb69 100644 --- a/samples/client/petstore/gdscript/models/Order.gd +++ b/samples/client/petstore/gdscript/models/Order.gd @@ -43,3 +43,13 @@ var complete: bool = false +func normalize() -> Dictionary: + return { + "id": self.id, + "petId": self.petId, + "quantity": self.quantity, + "shipDate": self.shipDate, + "status": self.status, + "complete": self.complete, + } + diff --git a/samples/client/petstore/gdscript/models/Pet.gd b/samples/client/petstore/gdscript/models/Pet.gd index d694d4455c1e..6158132d850d 100644 --- a/samples/client/petstore/gdscript/models/Pet.gd +++ b/samples/client/petstore/gdscript/models/Pet.gd @@ -45,3 +45,13 @@ var status: String +func normalize() -> Dictionary: + return { + "id": self.id, + "category": self.category, + "name": self.name, + "photoUrls": self.photoUrls, + "tags": self.tags, + "status": self.status, + } + diff --git a/samples/client/petstore/gdscript/models/Tag.gd b/samples/client/petstore/gdscript/models/Tag.gd index b697d7a38db2..992d7b283ea3 100644 --- a/samples/client/petstore/gdscript/models/Tag.gd +++ b/samples/client/petstore/gdscript/models/Tag.gd @@ -22,3 +22,9 @@ var name: String +func normalize() -> Dictionary: + return { + "id": self.id, + "name": self.name, + } + diff --git a/samples/client/petstore/gdscript/models/User.gd b/samples/client/petstore/gdscript/models/User.gd index 2c881cbd2f4d..2a9f9bc851df 100644 --- a/samples/client/petstore/gdscript/models/User.gd +++ b/samples/client/petstore/gdscript/models/User.gd @@ -53,3 +53,15 @@ var userStatus: int +func normalize() -> Dictionary: + return { + "id": self.id, + "username": self.username, + "firstName": self.firstName, + "lastName": self.lastName, + "email": self.email, + "password": self.password, + "phone": self.phone, + "userStatus": self.userStatus, + } + From ec62d550e18cc84558159776e604a4841bfded16 Mon Sep 17 00:00:00 2001 From: Goutte Date: Thu, 20 Oct 2022 20:24:56 +0200 Subject: [PATCH 09/56] feat(gdscript): check request body for required yet missing properties Now we'll get a nice error when we forget to set a required property. The demo is now able to: - connect - create a user - login as that user - create a pet --- .../main/resources/gdscript/ApiBee.handlebars | 24 ++++- .../main/resources/gdscript/model.handlebars | 33 ++++++- .../client/petstore/gdscript/core/ApiBee.gd | 24 ++++- samples/client/petstore/gdscript/demo/main.gd | 59 +++++++++++- .../petstore/gdscript/models/ApiResponse.gd | 43 +++++++-- .../petstore/gdscript/models/Category.gd | 34 ++++++- .../client/petstore/gdscript/models/Order.gd | 70 +++++++++++--- .../client/petstore/gdscript/models/Pet.gd | 80 +++++++++++++--- .../client/petstore/gdscript/models/Tag.gd | 34 ++++++- .../client/petstore/gdscript/models/User.gd | 94 +++++++++++++++---- 10 files changed, 424 insertions(+), 71 deletions(-) diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars index 19681427f404..18a55906fcea 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars @@ -208,15 +208,30 @@ func bee_do_request_text( # 1. template overrides # 2. CLI args # 3. YAML Config file - # 4. class property + # 4. class property/method (needed anyway for auth) var headers = [ "User-Agent: Stigmergiac/1.0 (Godot)", "Accept: application/json", "Content-Type: application/json", + "api_key: special-key", ] # TODO: Handle other serialization schemes (json+ld, xml…) - var body_serialized = JSON.stringify(body.normalize()) + var body_normalized = body + if body is Object: + if body.has_method('bee_collect_missing_properties'): + var missing_properties : Array = body.bee_collect_missing_properties() + if missing_properties: + var error := ApiError.new() + error.identifier = "apibee.request.body.missing_properties" + error.message = "%s: `%s' is missing required properties %s." % [ + self.bee_name, body.bee_class_name, missing_properties + ] + on_failure.call(error) + return + if body.has_method('bee_normalize'): + body_normalized = body.bee_normalize() + var body_serialized = JSON.stringify(body_normalized) var path_queried := path var query_string := self.bee_client.query_string_from_dict(query) @@ -275,6 +290,11 @@ func bee_do_request_text( else: # Yummy data has arrived response_bytes = response_bytes + chunk + print("REQUEST") + print("%s %s" % [method, path_queried]) + print("Headers: %s" % [str(headers)]) + prints(body_serialized) + prints("RESPONSE CODE:", response_code) prints("RESPONSE HEADERS:", response_headers) print("RESPONSE SIZE: %d bytes " % response_bytes.size()) diff --git a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars index 8336844fc6ad..61c53d9a4a39 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars @@ -15,6 +15,11 @@ {{>partials/model_statement_class_name}} +# It's convenient to know the class name, for error messages. +# https://github.com/godotengine/godot/issues/21789 +var bee_class_name := "{{classname}}" + + {{#each vars}} {{#if deprecated}} # /!. DEPRECATED @@ -27,12 +32,36 @@ {{#if example}} # Example: {{{example}}} {{/if}} -var {{name}}: {{dataType}}{{#if defaultValue}} = {{{defaultValue}}}{{/if}} +var {{name}}: {{dataType}}{{#if defaultValue}} = {{{defaultValue}}}{{/if}}: + set(value): + __{{name}}__was__set = true + {{name}} = value +var __{{name}}__was__set := false + +{{/each}} +func bee_collect_missing_properties() -> Array: + var bzz_missing_properties := Array() +{{#each vars}} +{{#if required}} + if not self.__{{name}}__was__set: + bzz_missing_properties.append("{{name}}") +{{/if}} {{/each}} + return bzz_missing_properties + + +func bee_normalize() -> Dictionary: + var bzz_dictionary := Dictionary() +{{#each vars}} + if self.__{{name}}__was__set: + bzz_dictionary["{{name}}"] = self.{{name}} +{{/each}} + return bzz_dictionary + -func normalize() -> Dictionary: +func bee_normalize_fully() -> Dictionary: return { {{#each vars}} "{{name}}": self.{{name}}, diff --git a/samples/client/petstore/gdscript/core/ApiBee.gd b/samples/client/petstore/gdscript/core/ApiBee.gd index 19681427f404..18a55906fcea 100644 --- a/samples/client/petstore/gdscript/core/ApiBee.gd +++ b/samples/client/petstore/gdscript/core/ApiBee.gd @@ -208,15 +208,30 @@ func bee_do_request_text( # 1. template overrides # 2. CLI args # 3. YAML Config file - # 4. class property + # 4. class property/method (needed anyway for auth) var headers = [ "User-Agent: Stigmergiac/1.0 (Godot)", "Accept: application/json", "Content-Type: application/json", + "api_key: special-key", ] # TODO: Handle other serialization schemes (json+ld, xml…) - var body_serialized = JSON.stringify(body.normalize()) + var body_normalized = body + if body is Object: + if body.has_method('bee_collect_missing_properties'): + var missing_properties : Array = body.bee_collect_missing_properties() + if missing_properties: + var error := ApiError.new() + error.identifier = "apibee.request.body.missing_properties" + error.message = "%s: `%s' is missing required properties %s." % [ + self.bee_name, body.bee_class_name, missing_properties + ] + on_failure.call(error) + return + if body.has_method('bee_normalize'): + body_normalized = body.bee_normalize() + var body_serialized = JSON.stringify(body_normalized) var path_queried := path var query_string := self.bee_client.query_string_from_dict(query) @@ -275,6 +290,11 @@ func bee_do_request_text( else: # Yummy data has arrived response_bytes = response_bytes + chunk + print("REQUEST") + print("%s %s" % [method, path_queried]) + print("Headers: %s" % [str(headers)]) + prints(body_serialized) + prints("RESPONSE CODE:", response_code) prints("RESPONSE HEADERS:", response_headers) print("RESPONSE SIZE: %d bytes " % response_bytes.size()) diff --git a/samples/client/petstore/gdscript/demo/main.gd b/samples/client/petstore/gdscript/demo/main.gd index c0151a714a77..f6498d5b9a8a 100644 --- a/samples/client/petstore/gdscript/demo/main.gd +++ b/samples/client/petstore/gdscript/demo/main.gd @@ -43,7 +43,8 @@ func is_headless() -> bool: func fail(msg: String): Logger.error(msg) failed = true - gtfo(1) + if is_headless(): + gtfo(1) func run_all_tests(on_done := Callable()): @@ -62,12 +63,60 @@ func run_all_tests(on_done := Callable()): func run_test_01(): Logger.inform("Running test 01…") - var monkey := Pet.new() - monkey.name = "Grégoire" - monkey.tags = ['tree', 'fur'] + var rick := User.new() + rick.username = "Rick" + rick.password = "ytrom&" + var user_api := UserApi.new() + user_api.bee_port = 8081 + user_api.create_user( + rick, + func(result): + print("Created user %s." % rick.username) + print(result) + authenticate( + rick.username, rick.password, + func(): + add_monkey() + ) + , + func(error): + printerr("ERROR!") + fail(str(error)) + emit_signal("test_ended") + ) + + +var api_key: String + + +func authenticate(username: String, password: String, on_done: Callable): + var user_api := UserApi.new() + user_api.bee_port = 8081 + user_api.login_user( + username, password, + func(result): + prints("Login Response:", result) + #api_key = result + on_done.call() + , + func(error): + prints("NO SNEAKERS", error) + fail(str(error)) + emit_signal("test_ended") + , + ) + + +func add_monkey(): + + var monkey := Pet.new() + monkey.name = "Gregoire" + #monkey.photoUrls = ['urlA', 'urlB'] + #monkey.tags = ['tree', 'fur'] + var pet_api := PetApi.new() - pet_api.bee_port = 81 + pet_api.bee_port = 8081 pet_api.add_pet( monkey, func(result): diff --git a/samples/client/petstore/gdscript/models/ApiResponse.gd b/samples/client/petstore/gdscript/models/ApiResponse.gd index c74eef8ab4e6..412a4e3837d3 100644 --- a/samples/client/petstore/gdscript/models/ApiResponse.gd +++ b/samples/client/petstore/gdscript/models/ApiResponse.gd @@ -11,23 +11,54 @@ extends RefCounted class_name ApiResponse +# It's convenient to know the class name, for error messages. +# https://github.com/godotengine/godot/issues/21789 +var bee_class_name := "ApiResponse" + + # Type: int # Required: False -var code: int - +var code: int: + set(value): + __code__was__set = true + code = value +var __code__was__set := false # Type: String # Required: False -var type: String - +var type: String: + set(value): + __type__was__set = true + type = value +var __type__was__set := false # Type: String # Required: False -var message: String +var message: String: + set(value): + __message__was__set = true + message = value +var __message__was__set := false + + + +func bee_collect_missing_properties() -> Array: + var bzz_missing_properties := Array() + return bzz_missing_properties + +func bee_normalize() -> Dictionary: + var bzz_dictionary := Dictionary() + if self.__code__was__set: + bzz_dictionary["code"] = self.code + if self.__type__was__set: + bzz_dictionary["type"] = self.type + if self.__message__was__set: + bzz_dictionary["message"] = self.message + return bzz_dictionary -func normalize() -> Dictionary: +func bee_normalize_fully() -> Dictionary: return { "code": self.code, "type": self.type, diff --git a/samples/client/petstore/gdscript/models/Category.gd b/samples/client/petstore/gdscript/models/Category.gd index 3139a16e99d6..923c390d6ff9 100644 --- a/samples/client/petstore/gdscript/models/Category.gd +++ b/samples/client/petstore/gdscript/models/Category.gd @@ -11,18 +11,44 @@ extends RefCounted class_name Category +# It's convenient to know the class name, for error messages. +# https://github.com/godotengine/godot/issues/21789 +var bee_class_name := "Category" + + # Type: float # Required: False -var id: float - +var id: float: + set(value): + __id__was__set = true + id = value +var __id__was__set := false # Type: String # Required: False -var name: String +var name: String: + set(value): + __name__was__set = true + name = value +var __name__was__set := false + + + +func bee_collect_missing_properties() -> Array: + var bzz_missing_properties := Array() + return bzz_missing_properties + +func bee_normalize() -> Dictionary: + var bzz_dictionary := Dictionary() + if self.__id__was__set: + bzz_dictionary["id"] = self.id + if self.__name__was__set: + bzz_dictionary["name"] = self.name + return bzz_dictionary -func normalize() -> Dictionary: +func bee_normalize_fully() -> Dictionary: return { "id": self.id, "name": self.name, diff --git a/samples/client/petstore/gdscript/models/Order.gd b/samples/client/petstore/gdscript/models/Order.gd index 48ffbe2ccb69..a538c89ff316 100644 --- a/samples/client/petstore/gdscript/models/Order.gd +++ b/samples/client/petstore/gdscript/models/Order.gd @@ -11,39 +11,85 @@ extends RefCounted class_name Order -# Type: float -# Required: False -var id: float +# It's convenient to know the class name, for error messages. +# https://github.com/godotengine/godot/issues/21789 +var bee_class_name := "Order" # Type: float # Required: False -var petId: float +var id: float: + set(value): + __id__was__set = true + id = value +var __id__was__set := false +# Type: float +# Required: False +var petId: float: + set(value): + __petId__was__set = true + petId = value +var __petId__was__set := false # Type: int # Required: False -var quantity: int - +var quantity: int: + set(value): + __quantity__was__set = true + quantity = value +var __quantity__was__set := false # Type: Dictionary # Required: False -var shipDate: Dictionary - +var shipDate: Dictionary: + set(value): + __shipDate__was__set = true + shipDate = value +var __shipDate__was__set := false # Order Status # Type: String # Required: False -var status: String - +var status: String: + set(value): + __status__was__set = true + status = value +var __status__was__set := false # Type: bool # Required: False -var complete: bool = false +var complete: bool = false: + set(value): + __complete__was__set = true + complete = value +var __complete__was__set := false + + + +func bee_collect_missing_properties() -> Array: + var bzz_missing_properties := Array() + return bzz_missing_properties + +func bee_normalize() -> Dictionary: + var bzz_dictionary := Dictionary() + if self.__id__was__set: + bzz_dictionary["id"] = self.id + if self.__petId__was__set: + bzz_dictionary["petId"] = self.petId + if self.__quantity__was__set: + bzz_dictionary["quantity"] = self.quantity + if self.__shipDate__was__set: + bzz_dictionary["shipDate"] = self.shipDate + if self.__status__was__set: + bzz_dictionary["status"] = self.status + if self.__complete__was__set: + bzz_dictionary["complete"] = self.complete + return bzz_dictionary -func normalize() -> Dictionary: +func bee_normalize_fully() -> Dictionary: return { "id": self.id, "petId": self.petId, diff --git a/samples/client/petstore/gdscript/models/Pet.gd b/samples/client/petstore/gdscript/models/Pet.gd index 6158132d850d..5cb44bdf26c2 100644 --- a/samples/client/petstore/gdscript/models/Pet.gd +++ b/samples/client/petstore/gdscript/models/Pet.gd @@ -11,41 +11,91 @@ extends RefCounted class_name Pet +# It's convenient to know the class name, for error messages. +# https://github.com/godotengine/godot/issues/21789 +var bee_class_name := "Pet" + + # Type: float # Required: False -var id: float - +var id: float: + set(value): + __id__was__set = true + id = value +var __id__was__set := false # Type: Category # Required: False -var category: Category - +var category: Category: + set(value): + __category__was__set = true + category = value +var __category__was__set := false # Type: String # Required: True # Example: doggie -var name: String - +var name: String: + set(value): + __name__was__set = true + name = value +var __name__was__set := false # Type: Array # Required: True -var photoUrls: Array - +var photoUrls: Array: + set(value): + __photoUrls__was__set = true + photoUrls = value +var __photoUrls__was__set := false # Type: Array # Required: False -var tags: Array - +var tags: Array: + set(value): + __tags__was__set = true + tags = value +var __tags__was__set := false # /!. DEPRECATED # pet status in the store # Type: String # Required: False -var status: String - - - -func normalize() -> Dictionary: +var status: String: + set(value): + __status__was__set = true + status = value +var __status__was__set := false + + + +func bee_collect_missing_properties() -> Array: + var bzz_missing_properties := Array() + if not self.__name__was__set: + bzz_missing_properties.append("name") + if not self.__photoUrls__was__set: + bzz_missing_properties.append("photoUrls") + return bzz_missing_properties + + +func bee_normalize() -> Dictionary: + var bzz_dictionary := Dictionary() + if self.__id__was__set: + bzz_dictionary["id"] = self.id + if self.__category__was__set: + bzz_dictionary["category"] = self.category + if self.__name__was__set: + bzz_dictionary["name"] = self.name + if self.__photoUrls__was__set: + bzz_dictionary["photoUrls"] = self.photoUrls + if self.__tags__was__set: + bzz_dictionary["tags"] = self.tags + if self.__status__was__set: + bzz_dictionary["status"] = self.status + return bzz_dictionary + + +func bee_normalize_fully() -> Dictionary: return { "id": self.id, "category": self.category, diff --git a/samples/client/petstore/gdscript/models/Tag.gd b/samples/client/petstore/gdscript/models/Tag.gd index 992d7b283ea3..baacef49b936 100644 --- a/samples/client/petstore/gdscript/models/Tag.gd +++ b/samples/client/petstore/gdscript/models/Tag.gd @@ -11,18 +11,44 @@ extends RefCounted class_name Tag +# It's convenient to know the class name, for error messages. +# https://github.com/godotengine/godot/issues/21789 +var bee_class_name := "Tag" + + # Type: float # Required: False -var id: float - +var id: float: + set(value): + __id__was__set = true + id = value +var __id__was__set := false # Type: String # Required: False -var name: String +var name: String: + set(value): + __name__was__set = true + name = value +var __name__was__set := false + + + +func bee_collect_missing_properties() -> Array: + var bzz_missing_properties := Array() + return bzz_missing_properties + +func bee_normalize() -> Dictionary: + var bzz_dictionary := Dictionary() + if self.__id__was__set: + bzz_dictionary["id"] = self.id + if self.__name__was__set: + bzz_dictionary["name"] = self.name + return bzz_dictionary -func normalize() -> Dictionary: +func bee_normalize_fully() -> Dictionary: return { "id": self.id, "name": self.name, diff --git a/samples/client/petstore/gdscript/models/User.gd b/samples/client/petstore/gdscript/models/User.gd index 2a9f9bc851df..30e72e135f9f 100644 --- a/samples/client/petstore/gdscript/models/User.gd +++ b/samples/client/petstore/gdscript/models/User.gd @@ -11,49 +11,105 @@ extends RefCounted class_name User +# It's convenient to know the class name, for error messages. +# https://github.com/godotengine/godot/issues/21789 +var bee_class_name := "User" + + # Type: float # Required: False -var id: float - +var id: float: + set(value): + __id__was__set = true + id = value +var __id__was__set := false # Type: String # Required: False -var username: String - +var username: String: + set(value): + __username__was__set = true + username = value +var __username__was__set := false # Type: String # Required: False -var firstName: String - +var firstName: String: + set(value): + __firstName__was__set = true + firstName = value +var __firstName__was__set := false # Type: String # Required: False -var lastName: String - +var lastName: String: + set(value): + __lastName__was__set = true + lastName = value +var __lastName__was__set := false # Type: String # Required: False -var email: String - +var email: String: + set(value): + __email__was__set = true + email = value +var __email__was__set := false # Type: String # Required: False -var password: String - +var password: String: + set(value): + __password__was__set = true + password = value +var __password__was__set := false # Type: String # Required: False -var phone: String - +var phone: String: + set(value): + __phone__was__set = true + phone = value +var __phone__was__set := false # User Status # Type: int # Required: False -var userStatus: int - - - -func normalize() -> Dictionary: +var userStatus: int: + set(value): + __userStatus__was__set = true + userStatus = value +var __userStatus__was__set := false + + + +func bee_collect_missing_properties() -> Array: + var bzz_missing_properties := Array() + return bzz_missing_properties + + +func bee_normalize() -> Dictionary: + var bzz_dictionary := Dictionary() + if self.__id__was__set: + bzz_dictionary["id"] = self.id + if self.__username__was__set: + bzz_dictionary["username"] = self.username + if self.__firstName__was__set: + bzz_dictionary["firstName"] = self.firstName + if self.__lastName__was__set: + bzz_dictionary["lastName"] = self.lastName + if self.__email__was__set: + bzz_dictionary["email"] = self.email + if self.__password__was__set: + bzz_dictionary["password"] = self.password + if self.__phone__was__set: + bzz_dictionary["phone"] = self.phone + if self.__userStatus__was__set: + bzz_dictionary["userStatus"] = self.userStatus + return bzz_dictionary + + +func bee_normalize_fully() -> Dictionary: return { "id": self.id, "username": self.username, From b4030569703e3ea2bfed9d8e5b07cb6cca33f946 Mon Sep 17 00:00:00 2001 From: Goutte Date: Thu, 20 Oct 2022 21:08:04 +0200 Subject: [PATCH 10/56] feat(gdscript): namespace core classes as well with apiPrefixName This makes our usage of `class_name` a little more acceptable. --- .../languages/GdscriptClientCodegen.java | 6 ++-- .../main/resources/gdscript/ApiBee.handlebars | 32 ++++++++++--------- .../resources/gdscript/ApiError.handlebars | 2 +- .../src/main/resources/gdscript/README.md | 30 +++++++++++++++++ .../partials/api_base_class_name.handlebars | 1 + .../partials/api_error_class_name.handlebars | 1 + .../partials/api_statement_extends.handlebars | 2 +- .../client/petstore/gdscript/core/ApiBee.gd | 4 ++- samples/client/petstore/gdscript/demo/main.gd | 2 +- 9 files changed, 59 insertions(+), 21 deletions(-) create mode 100644 modules/openapi-generator/src/main/resources/gdscript/README.md create mode 100644 modules/openapi-generator/src/main/resources/gdscript/partials/api_base_class_name.handlebars create mode 100644 modules/openapi-generator/src/main/resources/gdscript/partials/api_error_class_name.handlebars diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java index 4a290e59f55b..72dfcff9a525 100644 --- a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java +++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java @@ -48,8 +48,8 @@ public GdscriptClientCodegen() { apiPackage = "apis"; modelPackage = "models"; - supportingFiles.add(new SupportingFile("ApiBee.handlebars", "core", "ApiBee.gd")); - supportingFiles.add(new SupportingFile("ApiError.handlebars", "core", "ApiError.gd")); + supportingFiles.add(new SupportingFile("ApiBee.handlebars", "core", getApiNamePrefix() + "ApiBee.gd")); + supportingFiles.add(new SupportingFile("ApiError.handlebars", "core", getApiNamePrefix() + "ApiError.gd")); supportingFiles.add(new SupportingFile("README.handlebars", "", "README.md")); @@ -165,6 +165,8 @@ protected List getReservedWords() { // FIXME: Missing Nodes and other Objects globally available (RefCounted, Sprite2D, etc.) // FIXME: Missing primitive types (Rect…) return Arrays.asList( + // Local properties used in Model classes + "bee_class_name", // Local method names used in base API class "bee_connect_client_if_needed", "bee_request", "bee_request_text", "bee_do_request_text", "bee_convert_http_method", "bee_urlize_path_param", "bee_escape_path_param", diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars index 18a55906fcea..ca53c2a79f94 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars @@ -1,5 +1,7 @@ extends RefCounted -class_name ApiBee # We name it for now (KISS), but eventually I'd like to remove this. +# We class_name it for now (KISS), but eventually I'd like to remove this. +# Not trivial, though, because that means preloads and absolute paths. +class_name {{>partials/api_base_class_name}} # Base class for all generated API endpoints. @@ -71,7 +73,7 @@ func bee_next_loop_iteration(): func bee_connect_client_if_needed( on_success: Callable, # func() - on_failure: Callable, # func(error: ApiError) + on_failure: Callable, # func(error: {{>partials/api_error_class_name}}) #finally: Callable, ): if ( @@ -92,7 +94,7 @@ func bee_connect_client_if_needed( self.__bee_ssl_enabled, self.__bee_verify_host ) if connecting != OK: - var error := ApiError.new() + var error := {{>partials/api_error_class_name}}.new() error.internal_code = connecting error.identifier = "apibee.connect_to_host.failure" error.message = "%s: failed to connect to `%s' port %d with error %d" % [ @@ -114,7 +116,7 @@ func bee_connect_client_if_needed( await bee_next_loop_iteration() if self.bee_client.get_status() != HTTPClient.STATUS_CONNECTED: - var error := ApiError.new() + var error := {{>partials/api_error_class_name}}.new() error.internal_code = connecting error.identifier = "apibee.connect_to_host.wrong_status" error.message = "%s: failed to connect to `%s' port %d, with client status %d" % [ @@ -133,7 +135,7 @@ func bee_request( query: Dictionary, body, # Variant that will be serialized on_success: Callable, # func(response: Variant, responseCode: int, responseHeaders: Dictionary) - on_failure: Callable, # func(error: ApiError) + on_failure: Callable, # func(error: {{>partials/api_error_class_name}}) ): bee_request_text( @@ -147,7 +149,7 @@ func bee_request( var parser := JSON.new() var parsing := parser.parse(responseText) if OK != parsing: - var error := ApiError.new() + var error := {{>partials/api_error_class_name}}.new() error.internal_code = parsing error.identifier = "apibee.deserialize.cannot_parse_json" error.message = "%s: failed to parse JSON at line %d.\n%s" % [ @@ -158,7 +160,7 @@ func bee_request( deserializedResponse = parser.data denormalizedResponse = deserializedResponse # FIXME else: - var error := ApiError.new() + var error := {{>partials/api_error_class_name}}.new() error.internal_code = ERR_INVALID_DATA error.identifier = "apibee.deserialize.mime_type_unsupported" error.message = "%s: mime type `%s' is not supported (yet)" % [ @@ -182,7 +184,7 @@ func bee_request_text( query: Dictionary, body, # Variant that will be serialized on_success: Callable, # func(responseText: String, responseCode: int, responseHeaders: Dictionary) - on_failure: Callable, # func(error: ApiError) + on_failure: Callable, # func(error: {{>partials/api_error_class_name}}) ): bee_connect_client_if_needed( func(): @@ -201,7 +203,7 @@ func bee_do_request_text( query: Dictionary, body, # Variant that will be serialized on_success: Callable, # func(responseText: String, responseCode: int, responseHeaders: Dictionary) - on_failure: Callable, # func(error: ApiError) + on_failure: Callable, # func(error: {{>partials/api_error_class_name}}) ): # TODO: How can we help users define more / override these? @@ -222,7 +224,7 @@ func bee_do_request_text( if body.has_method('bee_collect_missing_properties'): var missing_properties : Array = body.bee_collect_missing_properties() if missing_properties: - var error := ApiError.new() + var error := {{>partials/api_error_class_name}}.new() error.identifier = "apibee.request.body.missing_properties" error.message = "%s: `%s' is missing required properties %s." % [ self.bee_name, body.bee_class_name, missing_properties @@ -240,7 +242,7 @@ func bee_do_request_text( var requesting := self.bee_client.request(method, path_queried, headers, body_serialized) if requesting != OK: - var error := ApiError.new() + var error := {{>partials/api_error_class_name}}.new() error.internal_code = requesting error.identifier = "apibee.request.failure" error.message = "%s: failed to request to path `%s'." % [ @@ -259,7 +261,7 @@ func bee_do_request_text( # if OS.has_feature("web") or async: if not self.bee_client.has_response(): - var error := ApiError.new() + var error := {{>partials/api_error_class_name}}.new() error.identifier = "apibee.request.no_response" error.message = "%s: request to `%s' yielded no response whatsoever." % [ self.bee_name, path @@ -310,7 +312,7 @@ func bee_do_request_text( response_text = response_bytes.get_string_from_ascii() if response_code >= 500: - var error := ApiError.new() + var error := {{>partials/api_error_class_name}}.new() error.internal_code = ERR_PRINTER_ON_FIRE error.identifier = "apibee.response.5xx" error.message = "%s: request to `%s' made the server hiccup with a %d." % [ @@ -322,7 +324,7 @@ func bee_do_request_text( on_failure.call(error) return elif response_code >= 400: - var error := ApiError.new() + var error := {{>partials/api_error_class_name}}.new() error.identifier = "apibee.response.4xx" error.message = "%s: request to `%s' was denied with a %d." % [ self.bee_name, path, response_code @@ -333,7 +335,7 @@ func bee_do_request_text( on_failure.call(error) return elif response_code >= 300: - var error := ApiError.new() + var error := {{>partials/api_error_class_name}}.new() error.identifier = "apibee.response.3xx" error.message = "%s: request to `%s' was redirected with a %d. We do not support redirects in that client yet." % [ self.bee_name, path, response_code diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiError.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiError.handlebars index f20540891b4e..5b6ddf2584f3 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiError.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiError.handlebars @@ -1,5 +1,5 @@ extends Resource -class_name ApiError +class_name {{>partials/api_error_class_name}} # Helps finding the error in the code, among other things. # Could be a UUID, or even a translation key, so long as it's unique. diff --git a/modules/openapi-generator/src/main/resources/gdscript/README.md b/modules/openapi-generator/src/main/resources/gdscript/README.md new file mode 100644 index 000000000000..543cbe5435a6 --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/README.md @@ -0,0 +1,30 @@ +In here are the `handlebars` templates used to generate the GDScript client. + +All files without the `.handlebars` extension (including this very `README.md` file) are ignored. + +You can copy them all (or parts) and override them as needed. + + +## Domain Overview + + +### ApiBee + +Base class for all Api endpoints classes. +Holds most of the nitty-gritty. + + +### ApiError + +Godot does not have an `Exception` (`try / catch`) mechanism, by design. + +> It actually makes _some_ sense in the volatile environment that are video games, +> due to their gigantic amount of user inputs and userland data, +> inherent complexity, low stakes, and entertainment value of glitches. + +Therefore, whenever there's trouble in paradise, we pass around an `ApiError` object. (a `RefCounted`, don't worry about garbage collection) + + + + + diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/api_base_class_name.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/api_base_class_name.handlebars new file mode 100644 index 000000000000..0a4e767ee42e --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/api_base_class_name.handlebars @@ -0,0 +1 @@ +{{apiNamePrefix}}ApiBee \ No newline at end of file diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/api_error_class_name.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/api_error_class_name.handlebars new file mode 100644 index 000000000000..f1d8d606faa6 --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/api_error_class_name.handlebars @@ -0,0 +1 @@ +{{apiNamePrefix}}ApiError \ No newline at end of file diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_extends.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_extends.handlebars index 7809e0efdf0a..40d581d706b0 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_extends.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_extends.handlebars @@ -1 +1 @@ -extends ApiBee \ No newline at end of file +extends {{>partials/api_base_class_name}} \ No newline at end of file diff --git a/samples/client/petstore/gdscript/core/ApiBee.gd b/samples/client/petstore/gdscript/core/ApiBee.gd index 18a55906fcea..da4ab32e5cd1 100644 --- a/samples/client/petstore/gdscript/core/ApiBee.gd +++ b/samples/client/petstore/gdscript/core/ApiBee.gd @@ -1,5 +1,7 @@ extends RefCounted -class_name ApiBee # We name it for now (KISS), but eventually I'd like to remove this. +# We class_name it for now (KISS), but eventually I'd like to remove this. +# Not trivial, though, because that means preloads and absolute paths. +class_name ApiBee # Base class for all generated API endpoints. diff --git a/samples/client/petstore/gdscript/demo/main.gd b/samples/client/petstore/gdscript/demo/main.gd index f6498d5b9a8a..359a6dc3ff65 100644 --- a/samples/client/petstore/gdscript/demo/main.gd +++ b/samples/client/petstore/gdscript/demo/main.gd @@ -112,7 +112,7 @@ func add_monkey(): var monkey := Pet.new() monkey.name = "Gregoire" - #monkey.photoUrls = ['urlA', 'urlB'] + monkey.photoUrls = ['urlA', 'urlB'] #monkey.tags = ['tree', 'fur'] var pet_api := PetApi.new() From 1b83f570b2f1561eb4b64e61a814a6136cd1155d Mon Sep 17 00:00:00 2001 From: Goutte Date: Fri, 21 Oct 2022 03:32:01 +0200 Subject: [PATCH 11/56] feat(gdscript): support prefixes and suffixes for class names This will crutch namespacing well enough for most uses. --- bin/configs/gdscript-petstore.yaml | 3 + .../languages/GdscriptClientCodegen.java | 75 ++++++++++++++++--- .../main/resources/gdscript/api.handlebars | 1 + .../main/resources/gdscript/model.handlebars | 9 ++- .../partials/api_base_class_name.handlebars | 2 +- .../partials/api_error_class_name.handlebars | 2 +- .../gdscript/partials/data_type.handlebars | 2 + .../model_statement_extends.handlebars | 2 + .../GdscriptClientCodegenOptionsProvider.java | 52 +++++++------ .../gdscript/.openapi-generator/FILES | 22 +++--- .../apis/{PetApi.gd => DemoPetApi.gd} | 19 ++--- .../apis/{StoreApi.gd => DemoStoreApi.gd} | 13 ++-- .../apis/{UserApi.gd => DemoUserApi.gd} | 19 ++--- .../core/{ApiBee.gd => DemoApiBee .gd} | 30 ++++---- .../core/{ApiError.gd => DemoApiError .gd} | 2 +- samples/client/petstore/gdscript/demo/main.gd | 10 +-- .../{ApiResponse.gd => DemoApiResponse.gd} | 8 +- .../models/{Category.gd => DemoCategory.gd} | 8 +- .../models/{Order.gd => DemoOrder.gd} | 9 +-- .../gdscript/models/{Pet.gd => DemoPet.gd} | 13 ++-- .../gdscript/models/{Tag.gd => DemoTag.gd} | 8 +- .../gdscript/models/{User.gd => DemoUser.gd} | 8 +- .../client/petstore/gdscript/project.godot | 72 +++++++++--------- 23 files changed, 226 insertions(+), 163 deletions(-) create mode 100644 modules/openapi-generator/src/main/resources/gdscript/partials/data_type.handlebars rename samples/client/petstore/gdscript/apis/{PetApi.gd => DemoPetApi.gd} (98%) rename samples/client/petstore/gdscript/apis/{StoreApi.gd => DemoStoreApi.gd} (97%) rename samples/client/petstore/gdscript/apis/{UserApi.gd => DemoUserApi.gd} (98%) rename samples/client/petstore/gdscript/core/{ApiBee.gd => DemoApiBee .gd} (95%) rename samples/client/petstore/gdscript/core/{ApiError.gd => DemoApiError .gd} (95%) rename samples/client/petstore/gdscript/models/{ApiResponse.gd => DemoApiResponse.gd} (93%) rename samples/client/petstore/gdscript/models/{Category.gd => DemoCategory.gd} (92%) rename samples/client/petstore/gdscript/models/{Order.gd => DemoOrder.gd} (95%) rename samples/client/petstore/gdscript/models/{Pet.gd => DemoPet.gd} (94%) rename samples/client/petstore/gdscript/models/{Tag.gd => DemoTag.gd} (94%) rename samples/client/petstore/gdscript/models/{User.gd => DemoUser.gd} (97%) diff --git a/bin/configs/gdscript-petstore.yaml b/bin/configs/gdscript-petstore.yaml index ae90278e87b8..3dbcc21cfb91 100644 --- a/bin/configs/gdscript-petstore.yaml +++ b/bin/configs/gdscript-petstore.yaml @@ -4,3 +4,6 @@ inputSpec: modules/openapi-generator/src/test/resources/3_0/petstore.yaml templateDir: modules/openapi-generator/src/main/resources/gdscript additionalProperties: hideGenerationTimestamp: "true" + apiNamePrefix: Demo + modelNamePrefix: Demo + coreNamePrefix: Demo \ No newline at end of file diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java index 72dfcff9a525..fc5b9f97cba2 100644 --- a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java +++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java @@ -12,16 +12,43 @@ import org.openapitools.codegen.api.TemplatingEngineAdapter; import org.openapitools.codegen.templating.HandlebarsEngineAdapter; -import org.openapitools.codegen.utils.ModelUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import static org.openapitools.codegen.utils.StringUtils.camelize; + public class GdscriptClientCodegen extends DefaultCodegen implements CodegenConfig { + + // All generated GDScript classes (including core) will use this prefix both in class_name and file name. + public static final String CORE_NAME_PREFIX = "coreNamePrefix"; + public static final String CORE_NAME_SUFFIX = "coreNameSuffix"; + // Perhaps for the README's title ? Any chars allowed ? public static final String PROJECT_NAME = "projectName"; @SuppressWarnings("FieldCanBeLocal") private final Logger LOGGER = LoggerFactory.getLogger(GdscriptClientCodegen.class); + // Perhaps an IDE issue but it can't find the module + //protected String coreNamePrefix = org.openapitools.codegen.options.GdscriptClientCodegenOptionsProvider.CORE_NAME_PREFIX_VALUE; + protected String coreNamePrefix = ""; + protected String coreNameSuffix = ""; + + public void setCoreNamePrefix(String prefix) { + coreNamePrefix = prefix; + } + + public String getCoreNamePrefix() { + return coreNamePrefix; + } + + public String getCoreNameSuffix() { + return coreNameSuffix; + } + + public void setCoreNameSuffix(String coreNameSuffix) { + this.coreNameSuffix = coreNameSuffix; + } + public CodegenType getTag() { return CodegenType.CLIENT; } @@ -41,18 +68,13 @@ public GdscriptClientCodegen() { // Since most users will set the output dir, we need to document that fact. String addonName = "oas." + "petstore"; // TODO: replace "petstore" from CLI or YAML or both (how?) outputFolder = "generated-code" + File.separator + "gdscript" + File.separator + "addons" + File.separator + addonName; - modelTemplateFiles.put("model.handlebars", ".gd"); - apiTemplateFiles.put("api.handlebars", ".gd"); - embeddedTemplateDir = templateDir = "gdscript"; apiPackage = "apis"; modelPackage = "models"; - supportingFiles.add(new SupportingFile("ApiBee.handlebars", "core", getApiNamePrefix() + "ApiBee.gd")); - supportingFiles.add(new SupportingFile("ApiError.handlebars", "core", getApiNamePrefix() + "ApiError.gd")); - supportingFiles.add(new SupportingFile("README.handlebars", "", "README.md")); - - + modelTemplateFiles.put("model.handlebars", ".gd"); + apiTemplateFiles.put("api.handlebars", ".gd"); + // more supported files are defined in processOpts() setReservedWordsLowerCase(getReservedWords()); @@ -85,6 +107,7 @@ public GdscriptClientCodegen() { // TODO: add meaningful parameters cliOptions.add(new CliOption(PROJECT_NAME, "The name of the project !!")); + cliOptions.add(new CliOption(CORE_NAME_PREFIX, "PascalCase prefix added to all generated classes")); // This constructor is ran twice, because … reasons. LOGGER.warn("THIS GENERATOR IS UNSAFE AND MALICIOUS OAS3 YAML FILES MAY HURT YOU."); @@ -98,10 +121,29 @@ public String defaultTemplatingEngine() { return "handlebars"; } + + public void processAdditionalProperties() { + if (additionalProperties.containsKey(CORE_NAME_PREFIX)) { + setCoreNamePrefix((String) additionalProperties.get(CORE_NAME_PREFIX)); + } else { + additionalProperties.put(CORE_NAME_PREFIX, ""); + } + if (additionalProperties.containsKey(CORE_NAME_SUFFIX)) { + setCoreNameSuffix((String) additionalProperties.get(CORE_NAME_SUFFIX)); + } else { + additionalProperties.put(CORE_NAME_SUFFIX, ""); + } + } + @Override public void processOpts() { super.processOpts(); + processAdditionalProperties(); + supportingFiles.add(new SupportingFile("ApiBee.handlebars", "core", toCoreFilename("ApiBee") + ".gd")); + supportingFiles.add(new SupportingFile("ApiError.handlebars", "core", toCoreFilename("ApiError") + ".gd")); + supportingFiles.add(new SupportingFile("README.handlebars", "", "README.md")); + // Ensure we're using the appropriate template engine, and configure it while we're at it. // We had to use handlebars because the truthy value of mustache includes `""` and `"null"`, // and things went south for default values and examples (but descriptions were OK, somehow) @@ -133,6 +175,19 @@ public String escapeQuotationMark(String input) { ; } + // In GDScript we want our file names to match our class names. + // This ensures we get the (optional) prefix and suffix added to the file name. + // Perhaps we'll even do (optional) snake_case in here later on. + @Override + public String toModelFilename(String name) { + return toModelName(name); + } + + public String toCoreFilename(String name) { + return camelize(getCoreNamePrefix() + '_' + name + '_' + getCoreNameSuffix()); + } + + // When example is "null" (with quotes), mustache's {{#example}} triggers // Not sure why this happens on {{#example}} but not {{#description}} // Perhaps I'm just using mustache wrong… Anyway, it's voodoo. @@ -161,6 +216,8 @@ public String toDefaultValue(Schema schema) { return ""; } + // We are generous with the keywords, but what is actually accepted by GDScript ir more lenient + // than what is properly highlighted in the editor. Readability matters ? protected List getReservedWords() { // FIXME: Missing Nodes and other Objects globally available (RefCounted, Sprite2D, etc.) // FIXME: Missing primitive types (Rect…) diff --git a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars index 2e286f47997c..fddec8097d64 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars @@ -1,6 +1,7 @@ {{>partials/api_headers}} # API {{classname}} + {{>partials/api_statement_extends}} {{>partials/api_statement_class_name}} diff --git a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars index 61c53d9a4a39..b2389673a264 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars @@ -8,7 +8,6 @@ # {{{description}}} {{/if}} # namespace: {{modelPackage}} -# invoker: {{invokerPackage}} {{>partials/model_statement_extends}} @@ -27,12 +26,15 @@ var bee_class_name := "{{classname}}" {{#if description}} # {{{description}}} {{/if}} -# Type: {{dataType}} +# Type: {{>partials/data_type}} # Required: {{#unless required}}False{{/unless}}{{#if required}}True{{/if}} {{#if example}} # Example: {{{example}}} {{/if}} -var {{name}}: {{dataType}}{{#if defaultValue}} = {{{defaultValue}}}{{/if}}: +{{#if isEnum}} +# Allowed values: +{{/if}} +var {{name}}: {{>partials/data_type}}{{#if defaultValue}} = {{{defaultValue}}}{{/if}}: set(value): __{{name}}__was__set = true {{name}} = value @@ -40,7 +42,6 @@ var __{{name}}__was__set := false {{/each}} - func bee_collect_missing_properties() -> Array: var bzz_missing_properties := Array() {{#each vars}} diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/api_base_class_name.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/api_base_class_name.handlebars index 0a4e767ee42e..08057a5269b3 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/partials/api_base_class_name.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/api_base_class_name.handlebars @@ -1 +1 @@ -{{apiNamePrefix}}ApiBee \ No newline at end of file +{{coreNamePrefix}}ApiBee{{coreNameSuffix}} \ No newline at end of file diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/api_error_class_name.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/api_error_class_name.handlebars index f1d8d606faa6..f38073b6e89f 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/partials/api_error_class_name.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/api_error_class_name.handlebars @@ -1 +1 @@ -{{apiNamePrefix}}ApiError \ No newline at end of file +{{coreNamePrefix}}ApiError{{coreNameSuffix}} \ No newline at end of file diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/data_type.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/data_type.handlebars new file mode 100644 index 000000000000..7a98a4b87727 --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/data_type.handlebars @@ -0,0 +1,2 @@ +{{#if isModel}}{{modelNamePrefix}}{{dataType}}{{modelNameSuffix}}{{/if~}} +{{#unless isModel}}{{dataType}}{{/unless}} \ No newline at end of file diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/model_statement_extends.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/model_statement_extends.handlebars index 2a016ca16d51..4f464a3977e6 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/partials/model_statement_extends.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/model_statement_extends.handlebars @@ -1 +1,3 @@ +{{! TODO: extend Resource and add @export annots -- more work for you if you want ~}} +{{! extends Resource ~}} extends RefCounted \ No newline at end of file diff --git a/modules/openapi-generator/src/test/java/org/openapitools/codegen/options/GdscriptClientCodegenOptionsProvider.java b/modules/openapi-generator/src/test/java/org/openapitools/codegen/options/GdscriptClientCodegenOptionsProvider.java index 00dc67cae542..ea289e15b3df 100644 --- a/modules/openapi-generator/src/test/java/org/openapitools/codegen/options/GdscriptClientCodegenOptionsProvider.java +++ b/modules/openapi-generator/src/test/java/org/openapitools/codegen/options/GdscriptClientCodegenOptionsProvider.java @@ -4,34 +4,30 @@ import org.openapitools.codegen.languages.GdscriptClientCodegen; import com.google.common.collect.ImmutableMap; -import org.openapitools.codegen.languages.PhpClientCodegen; import java.util.Map; public class GdscriptClientCodegenOptionsProvider implements OptionsProvider { - public static final String PROJECT_NAME_VALUE = "OpenAPI"; - - //These options weren't checked: - // legacyDiscriminatorBehavior, - // enumUnknownDefaultCase, - // sortModelPropertiesByRequiredFlag, - // sortParamsByRequiredFlag, - // ensureUniqueParams, - // allowUnicodeIdentifiers, - // prependFormOrBodyParameters, - // disallowAdditionalPropertiesIfNotPresent. - public static final String MODEL_PACKAGE_VALUE = "package"; - public static final String API_PACKAGE_VALUE = "apiPackage"; + + public static final String PROJECT_NAME_VALUE = "GDScript OAS Client"; + public static final String CORE_NAME_PREFIX_VALUE = ""; + public static final String CORE_NAME_SUFFIX_VALUE = ""; + +// public static final String MODEL_PACKAGE_VALUE = "package"; +// public static final String API_PACKAGE_VALUE = "apiPackage"; +// public static final String VARIABLE_NAMING_CONVENTION_VALUE = "snake_case"; +// public static final String INVOKER_PACKAGE_VALUE = "OpenAPITools\\Client\\Php"; +// public static final String PACKAGE_NAME_VALUE = "OpenAPIToolsClient-php"; +// public static final String SRC_BASE_PATH_VALUE = "libPhp"; +// public static final String ARTIFACT_VERSION_VALUE = "1.0.0-SNAPSHOT"; + public static final String SORT_PARAMS_VALUE = "false"; public static final String SORT_MODEL_PROPERTIES_VALUE = "false"; public static final String ENSURE_UNIQUE_PARAMS_VALUE = "true"; -// public static final String VARIABLE_NAMING_CONVENTION_VALUE = "snake_case"; - public static final String INVOKER_PACKAGE_VALUE = "OpenAPITools\\Client\\Php"; - public static final String PACKAGE_NAME_VALUE = "OpenAPIToolsClient-php"; -// public static final String SRC_BASE_PATH_VALUE = "libPhp"; - public static final String ARTIFACT_VERSION_VALUE = "1.0.0-SNAPSHOT"; public static final String ALLOW_UNICODE_IDENTIFIERS_VALUE = "false"; public static final String PREPEND_FORM_OR_BODY_PARAMETERS_VALUE = "true"; + public static final String LEGACY_DISCRIMINATOR_BEHAVIOR_VALUE = "true"; + public static final String NO_ADDITIONAL_PROPERTIES_VALUE = "true"; public static final String ENUM_UNKNOWN_DEFAULT_CASE_VALUE = "false"; @Override @@ -43,22 +39,30 @@ public String getLanguage() { public Map createOptions() { ImmutableMap.Builder builder = new ImmutableMap.Builder(); return builder + .put(GdscriptClientCodegen.PROJECT_NAME, PROJECT_NAME_VALUE) + .put(GdscriptClientCodegen.CORE_NAME_PREFIX, CORE_NAME_PREFIX_VALUE) + .put(GdscriptClientCodegen.CORE_NAME_SUFFIX, CORE_NAME_SUFFIX_VALUE) + + // > "le remblai, c'était mieux avant" // .put(CodegenConstants.API_PACKAGE, API_PACKAGE_VALUE) - .put(CodegenConstants.SORT_PARAMS_BY_REQUIRED_FLAG, SORT_PARAMS_VALUE) - .put(CodegenConstants.SORT_MODEL_PROPERTIES_BY_REQUIRED_FLAG, SORT_MODEL_PROPERTIES_VALUE) - .put(CodegenConstants.ENSURE_UNIQUE_PARAMS, ENSURE_UNIQUE_PARAMS_VALUE) // .put(PhpClientCodegen.VARIABLE_NAMING_CONVENTION, VARIABLE_NAMING_CONVENTION_VALUE) // .put(CodegenConstants.INVOKER_PACKAGE, INVOKER_PACKAGE_VALUE) // .put(PhpClientCodegen.PACKAGE_NAME, PACKAGE_NAME_VALUE) // .put(PhpClientCodegen.SRC_BASE_PATH, SRC_BASE_PATH_VALUE) // .put(CodegenConstants.ARTIFACT_VERSION, ARTIFACT_VERSION_VALUE) // .put(CodegenConstants.HIDE_GENERATION_TIMESTAMP, "true") + + // The following is required by CodeGen + + .put(CodegenConstants.SORT_PARAMS_BY_REQUIRED_FLAG, SORT_PARAMS_VALUE) + .put(CodegenConstants.SORT_MODEL_PROPERTIES_BY_REQUIRED_FLAG, SORT_MODEL_PROPERTIES_VALUE) + .put(CodegenConstants.ENSURE_UNIQUE_PARAMS, ENSURE_UNIQUE_PARAMS_VALUE) .put(CodegenConstants.ALLOW_UNICODE_IDENTIFIERS, ALLOW_UNICODE_IDENTIFIERS_VALUE) .put(CodegenConstants.PREPEND_FORM_OR_BODY_PARAMETERS, PREPEND_FORM_OR_BODY_PARAMETERS_VALUE) - .put(CodegenConstants.LEGACY_DISCRIMINATOR_BEHAVIOR, "true") - .put(CodegenConstants.DISALLOW_ADDITIONAL_PROPERTIES_IF_NOT_PRESENT, "true") + .put(CodegenConstants.LEGACY_DISCRIMINATOR_BEHAVIOR, LEGACY_DISCRIMINATOR_BEHAVIOR_VALUE) + .put(CodegenConstants.DISALLOW_ADDITIONAL_PROPERTIES_IF_NOT_PRESENT, NO_ADDITIONAL_PROPERTIES_VALUE) .put(CodegenConstants.ENUM_UNKNOWN_DEFAULT_CASE, ENUM_UNKNOWN_DEFAULT_CASE_VALUE) .build(); diff --git a/samples/client/petstore/gdscript/.openapi-generator/FILES b/samples/client/petstore/gdscript/.openapi-generator/FILES index b7c810143726..c67d19c94502 100644 --- a/samples/client/petstore/gdscript/.openapi-generator/FILES +++ b/samples/client/petstore/gdscript/.openapi-generator/FILES @@ -1,12 +1,12 @@ README.md -apis/PetApi.gd -apis/StoreApi.gd -apis/UserApi.gd -core/ApiBee.gd -core/ApiError.gd -models/ApiResponse.gd -models/Category.gd -models/Order.gd -models/Pet.gd -models/Tag.gd -models/User.gd +apis/DemoPetApi.gd +apis/DemoStoreApi.gd +apis/DemoUserApi.gd +core/DemoApiBee.gd +core/DemoApiError.gd +models/DemoApiResponse.gd +models/DemoCategory.gd +models/DemoOrder.gd +models/DemoPet.gd +models/DemoTag.gd +models/DemoUser.gd diff --git a/samples/client/petstore/gdscript/apis/PetApi.gd b/samples/client/petstore/gdscript/apis/DemoPetApi.gd similarity index 98% rename from samples/client/petstore/gdscript/apis/PetApi.gd rename to samples/client/petstore/gdscript/apis/DemoPetApi.gd index 77f2490225f6..9070f74622db 100644 --- a/samples/client/petstore/gdscript/apis/PetApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoPetApi.gd @@ -2,16 +2,17 @@ # For more information on how to customize templates, see: # https://openapi-generator.tech # The OpenAPI Generator Community, © Public Domain, 2022 -# API PetApi -extends ApiBee -class_name PetApi +# API DemoPetApi + +extends DemoApiBee +class_name DemoPetApi # Operation addPet → POST /pet # Add a new pet to the store func add_pet( - # pet: Pet + # demoPet: DemoPet # Pet object that needs to be added to the store - pet: Pet, + demoPet: DemoPet, on_success: Callable = Callable(), # func(result: Pet) on_failure: Callable = Callable(), # func(error: ApiError) ): @@ -31,7 +32,7 @@ func add_pet( var bzz_query := Dictionary() var bzz_body - bzz_body = pet + bzz_body = demoPet # Will be used at some point for denormalization # baseType = "Pet" @@ -255,9 +256,9 @@ func get_pet_by_id( # Operation updatePet → PUT /pet # Update an existing pet func update_pet( - # pet: Pet + # demoPet: DemoPet # Pet object that needs to be added to the store - pet: Pet, + demoPet: DemoPet, on_success: Callable = Callable(), # func(result: Pet) on_failure: Callable = Callable(), # func(error: ApiError) ): @@ -277,7 +278,7 @@ func update_pet( var bzz_query := Dictionary() var bzz_body - bzz_body = pet + bzz_body = demoPet # Will be used at some point for denormalization # baseType = "Pet" diff --git a/samples/client/petstore/gdscript/apis/StoreApi.gd b/samples/client/petstore/gdscript/apis/DemoStoreApi.gd similarity index 97% rename from samples/client/petstore/gdscript/apis/StoreApi.gd rename to samples/client/petstore/gdscript/apis/DemoStoreApi.gd index 699e1da60ac0..3ff1031f6772 100644 --- a/samples/client/petstore/gdscript/apis/StoreApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoStoreApi.gd @@ -2,9 +2,10 @@ # For more information on how to customize templates, see: # https://openapi-generator.tech # The OpenAPI Generator Community, © Public Domain, 2022 -# API StoreApi -extends ApiBee -class_name StoreApi +# API DemoStoreApi + +extends DemoApiBee +class_name DemoStoreApi # Operation deleteOrder → DELETE /store/order/{orderId} # Delete purchase order by ID @@ -149,9 +150,9 @@ func get_order_by_id( # Operation placeOrder → POST /store/order # Place an order for a pet func place_order( - # order: Order + # demoOrder: DemoOrder # order placed for purchasing the pet - order: Order, + demoOrder: DemoOrder, on_success: Callable = Callable(), # func(result: Order) on_failure: Callable = Callable(), # func(error: ApiError) ): @@ -171,7 +172,7 @@ func place_order( var bzz_query := Dictionary() var bzz_body - bzz_body = order + bzz_body = demoOrder # Will be used at some point for denormalization # baseType = "Order" diff --git a/samples/client/petstore/gdscript/apis/UserApi.gd b/samples/client/petstore/gdscript/apis/DemoUserApi.gd similarity index 98% rename from samples/client/petstore/gdscript/apis/UserApi.gd rename to samples/client/petstore/gdscript/apis/DemoUserApi.gd index b7e936abd167..6d2a04ecaf08 100644 --- a/samples/client/petstore/gdscript/apis/UserApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoUserApi.gd @@ -2,18 +2,19 @@ # For more information on how to customize templates, see: # https://openapi-generator.tech # The OpenAPI Generator Community, © Public Domain, 2022 -# API UserApi -extends ApiBee -class_name UserApi +# API DemoUserApi + +extends DemoApiBee +class_name DemoUserApi # Operation createUser → POST /user # Create user # # This can only be done by the logged in user. func create_user( - # user: User + # demoUser: DemoUser # Created user object - user: User, + demoUser: DemoUser, on_success: Callable = Callable(), # func(result) on_failure: Callable = Callable(), # func(error: ApiError) ): @@ -33,7 +34,7 @@ func create_user( var bzz_query := Dictionary() var bzz_body - bzz_body = user + bzz_body = demoUser bee_request( @@ -324,9 +325,9 @@ func update_user( # username: String Eg: username_example # name that need to be deleted username: String, - # user: User + # demoUser: DemoUser # Updated user object - user: User, + demoUser: DemoUser, on_success: Callable = Callable(), # func(result) on_failure: Callable = Callable(), # func(error: ApiError) ): @@ -346,7 +347,7 @@ func update_user( var bzz_query := Dictionary() var bzz_body - bzz_body = user + bzz_body = demoUser bee_request( diff --git a/samples/client/petstore/gdscript/core/ApiBee.gd b/samples/client/petstore/gdscript/core/DemoApiBee .gd similarity index 95% rename from samples/client/petstore/gdscript/core/ApiBee.gd rename to samples/client/petstore/gdscript/core/DemoApiBee .gd index da4ab32e5cd1..b75045d17bd7 100644 --- a/samples/client/petstore/gdscript/core/ApiBee.gd +++ b/samples/client/petstore/gdscript/core/DemoApiBee .gd @@ -1,7 +1,7 @@ extends RefCounted # We class_name it for now (KISS), but eventually I'd like to remove this. # Not trivial, though, because that means preloads and absolute paths. -class_name ApiBee +class_name DemoApiBee # Base class for all generated API endpoints. @@ -73,7 +73,7 @@ func bee_next_loop_iteration(): func bee_connect_client_if_needed( on_success: Callable, # func() - on_failure: Callable, # func(error: ApiError) + on_failure: Callable, # func(error: DemoApiError) #finally: Callable, ): if ( @@ -94,7 +94,7 @@ func bee_connect_client_if_needed( self.__bee_ssl_enabled, self.__bee_verify_host ) if connecting != OK: - var error := ApiError.new() + var error := DemoApiError.new() error.internal_code = connecting error.identifier = "apibee.connect_to_host.failure" error.message = "%s: failed to connect to `%s' port %d with error %d" % [ @@ -116,7 +116,7 @@ func bee_connect_client_if_needed( await bee_next_loop_iteration() if self.bee_client.get_status() != HTTPClient.STATUS_CONNECTED: - var error := ApiError.new() + var error := DemoApiError.new() error.internal_code = connecting error.identifier = "apibee.connect_to_host.wrong_status" error.message = "%s: failed to connect to `%s' port %d, with client status %d" % [ @@ -135,7 +135,7 @@ func bee_request( query: Dictionary, body, # Variant that will be serialized on_success: Callable, # func(response: Variant, responseCode: int, responseHeaders: Dictionary) - on_failure: Callable, # func(error: ApiError) + on_failure: Callable, # func(error: DemoApiError) ): bee_request_text( @@ -149,7 +149,7 @@ func bee_request( var parser := JSON.new() var parsing := parser.parse(responseText) if OK != parsing: - var error := ApiError.new() + var error := DemoApiError.new() error.internal_code = parsing error.identifier = "apibee.deserialize.cannot_parse_json" error.message = "%s: failed to parse JSON at line %d.\n%s" % [ @@ -160,7 +160,7 @@ func bee_request( deserializedResponse = parser.data denormalizedResponse = deserializedResponse # FIXME else: - var error := ApiError.new() + var error := DemoApiError.new() error.internal_code = ERR_INVALID_DATA error.identifier = "apibee.deserialize.mime_type_unsupported" error.message = "%s: mime type `%s' is not supported (yet)" % [ @@ -184,7 +184,7 @@ func bee_request_text( query: Dictionary, body, # Variant that will be serialized on_success: Callable, # func(responseText: String, responseCode: int, responseHeaders: Dictionary) - on_failure: Callable, # func(error: ApiError) + on_failure: Callable, # func(error: DemoApiError) ): bee_connect_client_if_needed( func(): @@ -203,7 +203,7 @@ func bee_do_request_text( query: Dictionary, body, # Variant that will be serialized on_success: Callable, # func(responseText: String, responseCode: int, responseHeaders: Dictionary) - on_failure: Callable, # func(error: ApiError) + on_failure: Callable, # func(error: DemoApiError) ): # TODO: How can we help users define more / override these? @@ -224,7 +224,7 @@ func bee_do_request_text( if body.has_method('bee_collect_missing_properties'): var missing_properties : Array = body.bee_collect_missing_properties() if missing_properties: - var error := ApiError.new() + var error := DemoApiError.new() error.identifier = "apibee.request.body.missing_properties" error.message = "%s: `%s' is missing required properties %s." % [ self.bee_name, body.bee_class_name, missing_properties @@ -242,7 +242,7 @@ func bee_do_request_text( var requesting := self.bee_client.request(method, path_queried, headers, body_serialized) if requesting != OK: - var error := ApiError.new() + var error := DemoApiError.new() error.internal_code = requesting error.identifier = "apibee.request.failure" error.message = "%s: failed to request to path `%s'." % [ @@ -261,7 +261,7 @@ func bee_do_request_text( # if OS.has_feature("web") or async: if not self.bee_client.has_response(): - var error := ApiError.new() + var error := DemoApiError.new() error.identifier = "apibee.request.no_response" error.message = "%s: request to `%s' yielded no response whatsoever." % [ self.bee_name, path @@ -312,7 +312,7 @@ func bee_do_request_text( response_text = response_bytes.get_string_from_ascii() if response_code >= 500: - var error := ApiError.new() + var error := DemoApiError.new() error.internal_code = ERR_PRINTER_ON_FIRE error.identifier = "apibee.response.5xx" error.message = "%s: request to `%s' made the server hiccup with a %d." % [ @@ -324,7 +324,7 @@ func bee_do_request_text( on_failure.call(error) return elif response_code >= 400: - var error := ApiError.new() + var error := DemoApiError.new() error.identifier = "apibee.response.4xx" error.message = "%s: request to `%s' was denied with a %d." % [ self.bee_name, path, response_code @@ -335,7 +335,7 @@ func bee_do_request_text( on_failure.call(error) return elif response_code >= 300: - var error := ApiError.new() + var error := DemoApiError.new() error.identifier = "apibee.response.3xx" error.message = "%s: request to `%s' was redirected with a %d. We do not support redirects in that client yet." % [ self.bee_name, path, response_code diff --git a/samples/client/petstore/gdscript/core/ApiError.gd b/samples/client/petstore/gdscript/core/DemoApiError .gd similarity index 95% rename from samples/client/petstore/gdscript/core/ApiError.gd rename to samples/client/petstore/gdscript/core/DemoApiError .gd index f20540891b4e..db0e538920db 100644 --- a/samples/client/petstore/gdscript/core/ApiError.gd +++ b/samples/client/petstore/gdscript/core/DemoApiError .gd @@ -1,5 +1,5 @@ extends Resource -class_name ApiError +class_name DemoApiError # Helps finding the error in the code, among other things. # Could be a UUID, or even a translation key, so long as it's unique. diff --git a/samples/client/petstore/gdscript/demo/main.gd b/samples/client/petstore/gdscript/demo/main.gd index 359a6dc3ff65..fd426536a220 100644 --- a/samples/client/petstore/gdscript/demo/main.gd +++ b/samples/client/petstore/gdscript/demo/main.gd @@ -63,11 +63,11 @@ func run_all_tests(on_done := Callable()): func run_test_01(): Logger.inform("Running test 01…") - var rick := User.new() + var rick := DemoUser.new() rick.username = "Rick" rick.password = "ytrom&" - var user_api := UserApi.new() + var user_api := DemoUserApi.new() user_api.bee_port = 8081 user_api.create_user( rick, @@ -91,7 +91,7 @@ var api_key: String func authenticate(username: String, password: String, on_done: Callable): - var user_api := UserApi.new() + var user_api := DemoUserApi.new() user_api.bee_port = 8081 user_api.login_user( username, password, @@ -110,12 +110,12 @@ func authenticate(username: String, password: String, on_done: Callable): func add_monkey(): - var monkey := Pet.new() + var monkey := DemoPet.new() monkey.name = "Gregoire" monkey.photoUrls = ['urlA', 'urlB'] #monkey.tags = ['tree', 'fur'] - var pet_api := PetApi.new() + var pet_api := DemoPetApi.new() pet_api.bee_port = 8081 pet_api.add_pet( monkey, diff --git a/samples/client/petstore/gdscript/models/ApiResponse.gd b/samples/client/petstore/gdscript/models/DemoApiResponse.gd similarity index 93% rename from samples/client/petstore/gdscript/models/ApiResponse.gd rename to samples/client/petstore/gdscript/models/DemoApiResponse.gd index 412a4e3837d3..131646473a1a 100644 --- a/samples/client/petstore/gdscript/models/ApiResponse.gd +++ b/samples/client/petstore/gdscript/models/DemoApiResponse.gd @@ -3,17 +3,16 @@ # https://openapi-generator.tech # The OpenAPI Generator Community, © Public Domain, 2022 -# ApiResponse Model +# DemoApiResponse Model # Describes the result of uploading an image resource # namespace: models -# invoker: extends RefCounted -class_name ApiResponse +class_name DemoApiResponse # It's convenient to know the class name, for error messages. # https://github.com/godotengine/godot/issues/21789 -var bee_class_name := "ApiResponse" +var bee_class_name := "DemoApiResponse" # Type: int @@ -41,7 +40,6 @@ var message: String: var __message__was__set := false - func bee_collect_missing_properties() -> Array: var bzz_missing_properties := Array() return bzz_missing_properties diff --git a/samples/client/petstore/gdscript/models/Category.gd b/samples/client/petstore/gdscript/models/DemoCategory.gd similarity index 92% rename from samples/client/petstore/gdscript/models/Category.gd rename to samples/client/petstore/gdscript/models/DemoCategory.gd index 923c390d6ff9..7d64591b9712 100644 --- a/samples/client/petstore/gdscript/models/Category.gd +++ b/samples/client/petstore/gdscript/models/DemoCategory.gd @@ -3,17 +3,16 @@ # https://openapi-generator.tech # The OpenAPI Generator Community, © Public Domain, 2022 -# Category Model +# DemoCategory Model # A category for a pet # namespace: models -# invoker: extends RefCounted -class_name Category +class_name DemoCategory # It's convenient to know the class name, for error messages. # https://github.com/godotengine/godot/issues/21789 -var bee_class_name := "Category" +var bee_class_name := "DemoCategory" # Type: float @@ -33,7 +32,6 @@ var name: String: var __name__was__set := false - func bee_collect_missing_properties() -> Array: var bzz_missing_properties := Array() return bzz_missing_properties diff --git a/samples/client/petstore/gdscript/models/Order.gd b/samples/client/petstore/gdscript/models/DemoOrder.gd similarity index 95% rename from samples/client/petstore/gdscript/models/Order.gd rename to samples/client/petstore/gdscript/models/DemoOrder.gd index a538c89ff316..3f02af23ce54 100644 --- a/samples/client/petstore/gdscript/models/Order.gd +++ b/samples/client/petstore/gdscript/models/DemoOrder.gd @@ -3,17 +3,16 @@ # https://openapi-generator.tech # The OpenAPI Generator Community, © Public Domain, 2022 -# Order Model +# DemoOrder Model # An order for a pets from the pet store # namespace: models -# invoker: extends RefCounted -class_name Order +class_name DemoOrder # It's convenient to know the class name, for error messages. # https://github.com/godotengine/godot/issues/21789 -var bee_class_name := "Order" +var bee_class_name := "DemoOrder" # Type: float @@ -51,6 +50,7 @@ var __shipDate__was__set := false # Order Status # Type: String # Required: False +# Allowed values: var status: String: set(value): __status__was__set = true @@ -66,7 +66,6 @@ var complete: bool = false: var __complete__was__set := false - func bee_collect_missing_properties() -> Array: var bzz_missing_properties := Array() return bzz_missing_properties diff --git a/samples/client/petstore/gdscript/models/Pet.gd b/samples/client/petstore/gdscript/models/DemoPet.gd similarity index 94% rename from samples/client/petstore/gdscript/models/Pet.gd rename to samples/client/petstore/gdscript/models/DemoPet.gd index 5cb44bdf26c2..5705fbcd7a4c 100644 --- a/samples/client/petstore/gdscript/models/Pet.gd +++ b/samples/client/petstore/gdscript/models/DemoPet.gd @@ -3,17 +3,16 @@ # https://openapi-generator.tech # The OpenAPI Generator Community, © Public Domain, 2022 -# Pet Model +# DemoPet Model # A pet for sale in the pet store # namespace: models -# invoker: extends RefCounted -class_name Pet +class_name DemoPet # It's convenient to know the class name, for error messages. # https://github.com/godotengine/godot/issues/21789 -var bee_class_name := "Pet" +var bee_class_name := "DemoPet" # Type: float @@ -24,9 +23,9 @@ var id: float: id = value var __id__was__set := false -# Type: Category +# Type: DemoCategory # Required: False -var category: Category: +var category: DemoCategory: set(value): __category__was__set = true category = value @@ -61,6 +60,7 @@ var __tags__was__set := false # pet status in the store # Type: String # Required: False +# Allowed values: var status: String: set(value): __status__was__set = true @@ -68,7 +68,6 @@ var status: String: var __status__was__set := false - func bee_collect_missing_properties() -> Array: var bzz_missing_properties := Array() if not self.__name__was__set: diff --git a/samples/client/petstore/gdscript/models/Tag.gd b/samples/client/petstore/gdscript/models/DemoTag.gd similarity index 94% rename from samples/client/petstore/gdscript/models/Tag.gd rename to samples/client/petstore/gdscript/models/DemoTag.gd index baacef49b936..cc125ba339ed 100644 --- a/samples/client/petstore/gdscript/models/Tag.gd +++ b/samples/client/petstore/gdscript/models/DemoTag.gd @@ -3,17 +3,16 @@ # https://openapi-generator.tech # The OpenAPI Generator Community, © Public Domain, 2022 -# Tag Model +# DemoTag Model # A tag for a pet # namespace: models -# invoker: extends RefCounted -class_name Tag +class_name DemoTag # It's convenient to know the class name, for error messages. # https://github.com/godotengine/godot/issues/21789 -var bee_class_name := "Tag" +var bee_class_name := "DemoTag" # Type: float @@ -33,7 +32,6 @@ var name: String: var __name__was__set := false - func bee_collect_missing_properties() -> Array: var bzz_missing_properties := Array() return bzz_missing_properties diff --git a/samples/client/petstore/gdscript/models/User.gd b/samples/client/petstore/gdscript/models/DemoUser.gd similarity index 97% rename from samples/client/petstore/gdscript/models/User.gd rename to samples/client/petstore/gdscript/models/DemoUser.gd index 30e72e135f9f..1ff27aac622c 100644 --- a/samples/client/petstore/gdscript/models/User.gd +++ b/samples/client/petstore/gdscript/models/DemoUser.gd @@ -3,17 +3,16 @@ # https://openapi-generator.tech # The OpenAPI Generator Community, © Public Domain, 2022 -# User Model +# DemoUser Model # A User who is purchasing from the pet store # namespace: models -# invoker: extends RefCounted -class_name User +class_name DemoUser # It's convenient to know the class name, for error messages. # https://github.com/godotengine/godot/issues/21789 -var bee_class_name := "User" +var bee_class_name := "DemoUser" # Type: float @@ -82,7 +81,6 @@ var userStatus: int: var __userStatus__was__set := false - func bee_collect_missing_properties() -> Array: var bzz_missing_properties := Array() return bzz_missing_properties diff --git a/samples/client/petstore/gdscript/project.godot b/samples/client/petstore/gdscript/project.godot index 927cdf8e8c08..904dffdfc2d2 100644 --- a/samples/client/petstore/gdscript/project.godot +++ b/samples/client/petstore/gdscript/project.godot @@ -10,72 +10,72 @@ config_version=5 _global_script_classes=[{ "base": "RefCounted", -"class": &"ApiBee", +"class": &"DemoApiBee", "language": &"GDScript", -"path": "res://core/ApiBee.gd" +"path": "res://core/DemoApiBee.gd" }, { "base": "Resource", -"class": &"ApiError", +"class": &"DemoApiError", "language": &"GDScript", -"path": "res://core/ApiError.gd" +"path": "res://core/DemoApiError.gd" }, { "base": "RefCounted", -"class": &"ApiResponse", +"class": &"DemoApiResponse", "language": &"GDScript", -"path": "res://models/ApiResponse.gd" +"path": "res://models/DemoApiResponse.gd" }, { "base": "RefCounted", -"class": &"Category", +"class": &"DemoCategory", "language": &"GDScript", -"path": "res://models/Category.gd" +"path": "res://models/DemoCategory.gd" }, { "base": "RefCounted", -"class": &"Order", +"class": &"DemoOrder", "language": &"GDScript", -"path": "res://models/Order.gd" +"path": "res://models/DemoOrder.gd" }, { "base": "RefCounted", -"class": &"Pet", +"class": &"DemoPet", "language": &"GDScript", -"path": "res://models/Pet.gd" +"path": "res://models/DemoPet.gd" }, { -"base": "ApiBee", -"class": &"PetApi", +"base": "DemoApiBee", +"class": &"DemoPetApi", "language": &"GDScript", -"path": "res://apis/PetApi.gd" +"path": "res://apis/DemoPetApi.gd" }, { -"base": "ApiBee", -"class": &"StoreApi", +"base": "DemoApiBee", +"class": &"DemoStoreApi", "language": &"GDScript", -"path": "res://apis/StoreApi.gd" +"path": "res://apis/DemoStoreApi.gd" }, { "base": "RefCounted", -"class": &"Tag", +"class": &"DemoTag", "language": &"GDScript", -"path": "res://models/Tag.gd" +"path": "res://models/DemoTag.gd" }, { "base": "RefCounted", -"class": &"User", +"class": &"DemoUser", "language": &"GDScript", -"path": "res://models/User.gd" +"path": "res://models/DemoUser.gd" }, { -"base": "ApiBee", -"class": &"UserApi", +"base": "DemoApiBee", +"class": &"DemoUserApi", "language": &"GDScript", -"path": "res://apis/UserApi.gd" +"path": "res://apis/DemoUserApi.gd" }] _global_script_class_icons={ -"ApiBee": "", -"ApiError": "", -"ApiResponse": "", -"Category": "", -"Order": "", -"Pet": "", -"PetApi": "", -"StoreApi": "", -"Tag": "", -"User": "", -"UserApi": "" +"DemoApiBee": "", +"DemoApiError": "", +"DemoApiResponse": "", +"DemoCategory": "", +"DemoOrder": "", +"DemoPet": "", +"DemoPetApi": "", +"DemoStoreApi": "", +"DemoTag": "", +"DemoUser": "", +"DemoUserApi": "" } [application] From 32dfb4b88d933c752d7a886e054f5fd6753c575b Mon Sep 17 00:00:00 2001 From: Goutte Date: Fri, 21 Oct 2022 04:33:19 +0200 Subject: [PATCH 12/56] feat(gdscript): handle enums, naively --- .../main/resources/gdscript/api.handlebars | 4 +-- .../main/resources/gdscript/model.handlebars | 18 +++++++++++- .../petstore/gdscript/apis/DemoPetApi.gd | 28 +++++++++---------- .../petstore/gdscript/apis/DemoStoreApi.gd | 14 +++++----- .../petstore/gdscript/apis/DemoUserApi.gd | 20 ++++++------- .../core/{DemoApiBee .gd => DemoApiBee.gd} | 0 .../{DemoApiError .gd => DemoApiError.gd} | 0 samples/client/petstore/gdscript/demo/main.gd | 2 ++ .../petstore/gdscript/models/DemoOrder.gd | 7 ++++- .../petstore/gdscript/models/DemoPet.gd | 8 +++++- 10 files changed, 65 insertions(+), 36 deletions(-) rename samples/client/petstore/gdscript/core/{DemoApiBee .gd => DemoApiBee.gd} (100%) rename samples/client/petstore/gdscript/core/{DemoApiError .gd => DemoApiError.gd} (100%) diff --git a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars index fddec8097d64..952fe722b811 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars @@ -51,7 +51,7 @@ func {{operationIdSnakeCase}}( bzz_query["{{baseName}}"] = {{paramName}} {{/each}} - var bzz_body + var bzz_body = null {{#each bodyParams}} bzz_body = {{paramName}} {{/each}} @@ -63,7 +63,7 @@ func {{operationIdSnakeCase}}( # dataType = "{{{dataType}}}" # complexType = "{{{complexType}}}" # isArray = "{{{isArray}}}" - var bzz_return_type := "{{{complexType}}}" + var _bzz_return_type := "{{{complexType}}}" {{/with}} bee_request( diff --git a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars index b2389673a264..ddea16a79f49 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars @@ -32,13 +32,29 @@ var bee_class_name := "{{classname}}" # Example: {{{example}}} {{/if}} {{#if isEnum}} -# Allowed values: +# Allowed values: {{#with allowableValues}}{{#each values}}"{{this}}"{{#unless @last}}, {{/unless}}{{/each}}{{/with}} {{/if}} var {{name}}: {{>partials/data_type}}{{#if defaultValue}} = {{{defaultValue}}}{{/if}}: set(value): +{{#if deprecated}} + push_warning("{{classname}}: property `{{name}}` is deprecated.") +{{/if}} +{{#if isEnum}} + if str(value) != "" and not (str(value) in __{{name}}__allowable__values): + printerr("{{classname}}: tried to set property `{{name}}` to a value that is not allowed." + + " Allowed values: {{#with allowableValues}}{{#each values}}`{{this}}`{{#unless @last}}, {{/unless}}{{/each}}{{/with}}") + return +{{/if}} __{{name}}__was__set = true {{name}} = value +{{! Flag used to only serialize what has been explicitely set. (no nullable types, anyway null might be legit) }} var __{{name}}__was__set := false +{{! Store the allowed values if the property is an enum }} +{{#if isEnum}} +var __{{name}}__allowable__values := [ + {{~#with allowableValues}}{{#each values}}"{{this}}"{{#unless @last}}, {{/unless}}{{/each}}{{~/with~}} +] +{{/if}} {{/each}} diff --git a/samples/client/petstore/gdscript/apis/DemoPetApi.gd b/samples/client/petstore/gdscript/apis/DemoPetApi.gd index 9070f74622db..10a2062e2ece 100644 --- a/samples/client/petstore/gdscript/apis/DemoPetApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoPetApi.gd @@ -31,7 +31,7 @@ func add_pet( # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - var bzz_body + var bzz_body = null bzz_body = demoPet # Will be used at some point for denormalization @@ -40,7 +40,7 @@ func add_pet( # dataType = "Pet" # complexType = "Pet" # isArray = "false" - var bzz_return_type := "Pet" + var _bzz_return_type := "Pet" bee_request( bzz_method, bzz_path, bzz_query, bzz_body, @@ -83,7 +83,7 @@ func delete_pet( # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - var bzz_body + var bzz_body = null bee_request( @@ -127,7 +127,7 @@ func find_pets_by_status( var bzz_query := Dictionary() bzz_query["status"] = status - var bzz_body + var bzz_body = null # Will be used at some point for denormalization # baseType = "array" @@ -135,7 +135,7 @@ func find_pets_by_status( # dataType = "Array" # complexType = "Pet" # isArray = "true" - var bzz_return_type := "Pet" + var _bzz_return_type := "Pet" bee_request( bzz_method, bzz_path, bzz_query, bzz_body, @@ -179,7 +179,7 @@ func find_pets_by_tags( var bzz_query := Dictionary() bzz_query["tags"] = tags - var bzz_body + var bzz_body = null # Will be used at some point for denormalization # baseType = "array" @@ -187,7 +187,7 @@ func find_pets_by_tags( # dataType = "Array" # complexType = "Pet" # isArray = "true" - var bzz_return_type := "Pet" + var _bzz_return_type := "Pet" bee_request( bzz_method, bzz_path, bzz_query, bzz_body, @@ -229,7 +229,7 @@ func get_pet_by_id( # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - var bzz_body + var bzz_body = null # Will be used at some point for denormalization # baseType = "Pet" @@ -237,7 +237,7 @@ func get_pet_by_id( # dataType = "Pet" # complexType = "Pet" # isArray = "false" - var bzz_return_type := "Pet" + var _bzz_return_type := "Pet" bee_request( bzz_method, bzz_path, bzz_query, bzz_body, @@ -277,7 +277,7 @@ func update_pet( # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - var bzz_body + var bzz_body = null bzz_body = demoPet # Will be used at some point for denormalization @@ -286,7 +286,7 @@ func update_pet( # dataType = "Pet" # complexType = "Pet" # isArray = "false" - var bzz_return_type := "Pet" + var _bzz_return_type := "Pet" bee_request( bzz_method, bzz_path, bzz_query, bzz_body, @@ -332,7 +332,7 @@ func update_pet_with_form( # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - var bzz_body + var bzz_body = null bee_request( @@ -379,7 +379,7 @@ func upload_file( # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - var bzz_body + var bzz_body = null # Will be used at some point for denormalization # baseType = "ApiResponse" @@ -387,7 +387,7 @@ func upload_file( # dataType = "ApiResponse" # complexType = "ApiResponse" # isArray = "false" - var bzz_return_type := "ApiResponse" + var _bzz_return_type := "ApiResponse" bee_request( bzz_method, bzz_path, bzz_query, bzz_body, diff --git a/samples/client/petstore/gdscript/apis/DemoStoreApi.gd b/samples/client/petstore/gdscript/apis/DemoStoreApi.gd index 3ff1031f6772..49396fdaf8b4 100644 --- a/samples/client/petstore/gdscript/apis/DemoStoreApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoStoreApi.gd @@ -33,7 +33,7 @@ func delete_order( # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - var bzz_body + var bzz_body = null bee_request( @@ -73,7 +73,7 @@ func get_inventory( # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - var bzz_body + var bzz_body = null # Will be used at some point for denormalization # baseType = "map" @@ -81,7 +81,7 @@ func get_inventory( # dataType = "Dictionary" # complexType = "integer" # isArray = "false" - var bzz_return_type := "integer" + var _bzz_return_type := "integer" bee_request( bzz_method, bzz_path, bzz_query, bzz_body, @@ -123,7 +123,7 @@ func get_order_by_id( # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - var bzz_body + var bzz_body = null # Will be used at some point for denormalization # baseType = "Order" @@ -131,7 +131,7 @@ func get_order_by_id( # dataType = "Order" # complexType = "Order" # isArray = "false" - var bzz_return_type := "Order" + var _bzz_return_type := "Order" bee_request( bzz_method, bzz_path, bzz_query, bzz_body, @@ -171,7 +171,7 @@ func place_order( # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - var bzz_body + var bzz_body = null bzz_body = demoOrder # Will be used at some point for denormalization @@ -180,7 +180,7 @@ func place_order( # dataType = "Order" # complexType = "Order" # isArray = "false" - var bzz_return_type := "Order" + var _bzz_return_type := "Order" bee_request( bzz_method, bzz_path, bzz_query, bzz_body, diff --git a/samples/client/petstore/gdscript/apis/DemoUserApi.gd b/samples/client/petstore/gdscript/apis/DemoUserApi.gd index 6d2a04ecaf08..dd5f9b2f9220 100644 --- a/samples/client/petstore/gdscript/apis/DemoUserApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoUserApi.gd @@ -33,7 +33,7 @@ func create_user( # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - var bzz_body + var bzz_body = null bzz_body = demoUser @@ -75,7 +75,7 @@ func create_users_with_array_input( # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - var bzz_body + var bzz_body = null bzz_body = user @@ -117,7 +117,7 @@ func create_users_with_list_input( # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - var bzz_body + var bzz_body = null bzz_body = user @@ -161,7 +161,7 @@ func delete_user( # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - var bzz_body + var bzz_body = null bee_request( @@ -202,7 +202,7 @@ func get_user_by_name( # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - var bzz_body + var bzz_body = null # Will be used at some point for denormalization # baseType = "User" @@ -210,7 +210,7 @@ func get_user_by_name( # dataType = "User" # complexType = "User" # isArray = "false" - var bzz_return_type := "User" + var _bzz_return_type := "User" bee_request( bzz_method, bzz_path, bzz_query, bzz_body, @@ -255,7 +255,7 @@ func login_user( bzz_query["username"] = username bzz_query["password"] = password - var bzz_body + var bzz_body = null # Will be used at some point for denormalization # baseType = "string" @@ -263,7 +263,7 @@ func login_user( # dataType = "String" # complexType = "string" # isArray = "false" - var bzz_return_type := "string" + var _bzz_return_type := "string" bee_request( bzz_method, bzz_path, bzz_query, bzz_body, @@ -300,7 +300,7 @@ func logout_user( # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - var bzz_body + var bzz_body = null bee_request( @@ -346,7 +346,7 @@ func update_user( # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - var bzz_body + var bzz_body = null bzz_body = demoUser diff --git a/samples/client/petstore/gdscript/core/DemoApiBee .gd b/samples/client/petstore/gdscript/core/DemoApiBee.gd similarity index 100% rename from samples/client/petstore/gdscript/core/DemoApiBee .gd rename to samples/client/petstore/gdscript/core/DemoApiBee.gd diff --git a/samples/client/petstore/gdscript/core/DemoApiError .gd b/samples/client/petstore/gdscript/core/DemoApiError.gd similarity index 100% rename from samples/client/petstore/gdscript/core/DemoApiError .gd rename to samples/client/petstore/gdscript/core/DemoApiError.gd diff --git a/samples/client/petstore/gdscript/demo/main.gd b/samples/client/petstore/gdscript/demo/main.gd index fd426536a220..c115e3a45e19 100644 --- a/samples/client/petstore/gdscript/demo/main.gd +++ b/samples/client/petstore/gdscript/demo/main.gd @@ -113,6 +113,8 @@ func add_monkey(): var monkey := DemoPet.new() monkey.name = "Gregoire" monkey.photoUrls = ['urlA', 'urlB'] + monkey.status = "available" + monkey.status = "shenaniganing" #monkey.tags = ['tree', 'fur'] var pet_api := DemoPetApi.new() diff --git a/samples/client/petstore/gdscript/models/DemoOrder.gd b/samples/client/petstore/gdscript/models/DemoOrder.gd index 3f02af23ce54..a619911db30b 100644 --- a/samples/client/petstore/gdscript/models/DemoOrder.gd +++ b/samples/client/petstore/gdscript/models/DemoOrder.gd @@ -50,12 +50,17 @@ var __shipDate__was__set := false # Order Status # Type: String # Required: False -# Allowed values: +# Allowed values: "placed", "approved", "delivered" var status: String: set(value): + if str(value) != "" and not (str(value) in __status__allowable__values): + printerr("DemoOrder: tried to set property `status` to a value that is not allowed." + + " Allowed values: `placed`, `approved`, `delivered`") + return __status__was__set = true status = value var __status__was__set := false +var __status__allowable__values := ["placed", "approved", "delivered"] # Type: bool # Required: False diff --git a/samples/client/petstore/gdscript/models/DemoPet.gd b/samples/client/petstore/gdscript/models/DemoPet.gd index 5705fbcd7a4c..3730c30dd823 100644 --- a/samples/client/petstore/gdscript/models/DemoPet.gd +++ b/samples/client/petstore/gdscript/models/DemoPet.gd @@ -60,12 +60,18 @@ var __tags__was__set := false # pet status in the store # Type: String # Required: False -# Allowed values: +# Allowed values: "available", "pending", "sold" var status: String: set(value): + push_warning("DemoPet: property `status` is deprecated.") + if str(value) != "" and not (str(value) in __status__allowable__values): + printerr("DemoPet: tried to set property `status` to a value that is not allowed." + + " Allowed values: `available`, `pending`, `sold`") + return __status__was__set = true status = value var __status__was__set := false +var __status__allowable__values := ["available", "pending", "sold"] func bee_collect_missing_properties() -> Array: From 90c2962121777e7463d05dfd0933527473feaa06 Mon Sep 17 00:00:00 2001 From: Goutte Date: Fri, 21 Oct 2022 21:19:07 +0200 Subject: [PATCH 13/56] feat(gdscript): support basic API endpoint param constraints - minLength - maxLength - minItems - maxItems - minimum - maximum - pattern (no flags) --- .../main/resources/gdscript/api.handlebars | 101 ++++++++++++++++++ .../main/resources/gdscript/model.handlebars | 3 +- .../petstore/gdscript/apis/DemoPetApi.gd | 23 ++++ .../petstore/gdscript/apis/DemoStoreApi.gd | 16 +++ .../petstore/gdscript/apis/DemoUserApi.gd | 26 +++++ .../petstore/gdscript/models/DemoPet.gd | 3 +- 6 files changed, 170 insertions(+), 2 deletions(-) diff --git a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars index 952fe722b811..252d0be4d48e 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars @@ -38,6 +38,96 @@ func {{operationIdSnakeCase}}( # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + {{#each allParams}} + {{!-- + # Verify required param `{{paramName}}` is set + # → done by the func signature, perhaps we could check against null or empty array anyway? + + {{#if isString}}# STRING {{paramName}}{{/if}} + {{#if isNumeric}}# NUMBER {{paramName}}{{/if}} + --}} + {{#if hasValidation}} + # Validate param `{{paramName}}` constraints + {{#if maxLength}} + {{#if isString}} + if ({{paramName}} is String) and {{paramName}}.length() > {{maxLength}}: + var error := {{>partials/api_error_class_name}}.new() + #error.internal_code = ERR_INVALID_PARAMETER + error.identifier = "{{operationIdSnakeCase}}.param.validation.max_length" + error.message = "Invalid length for `{{paramName}}`, must be smaller than or equal to {{maxLength}}." + on_failure.call(error) + return + {{/if}} + {{/if}} + {{#if minLength}} + {{#if isString}} + if ({{paramName}} is String) and {{paramName}}.length() < {{minLength}}: + var error := {{>partials/api_error_class_name}}.new() + error.identifier = "{{operationIdSnakeCase}}.param.validation.min_length" + error.message = "Invalid length for `{{paramName}}`, must be greater than or equal to {{minLength}}." + on_failure.call(error) + return + {{/if}} + {{/if}} + {{#if maximum}} + {{! isNumeric / isNumber yields false yet isLong yields true }} + {{! not sure if bug 'cause of handlebars or not ; let's skip }} + {{!#if isNumeric}} + if {{paramName}} >{{#if exclusiveMaximum}}={{/if}} {{maximum}}: + var error := {{>partials/api_error_class_name}}.new() + error.identifier = "{{operationIdSnakeCase}}.param.validation.maximum" + error.message = "Invalid value for `{{paramName}}`, must be smaller than{{#unless exclusiveMaximum}} or equal to{{/unless}} {{maximum}}." + on_failure.call(error) + return + {{!/if}} + {{/if}} + {{#if minimum}} + {{!#if isNumeric}} + if {{paramName}} <{{#if exclusiveMinimum}}={{/if}} {{minimum}}: + var error := {{>partials/api_error_class_name}}.new() + error.identifier = "{{operationIdSnakeCase}}.param.validation.minimum" + error.message = "Invalid value for `{{paramName}}`, must be greater than{{#unless exclusiveMinimum}} or equal to{{/unless}} {{minimum}}." + on_failure.call(error) + return + {{!/if}} + {{/if}} + {{#if maxItems}} + {{#if isArray}} + if ({{paramName}} is Array) and {{paramName}}.size() > {{maxItems}}: + var error := {{>partials/api_error_class_name}}.new() + error.identifier = "{{operationIdSnakeCase}}.param.validation.max_items" + error.message = "Invalid array size for `{{paramName}}`, must hold at most {{maxItems}} elements." + on_failure.call(error) + return + {{/if}} + {{/if}} + {{#if minItems}} + {{#if isArray}} + if ({{paramName}} is Array) and {{paramName}}.size() < {{minItems}}: + var error := {{>partials/api_error_class_name}}.new() + error.identifier = "{{operationIdSnakeCase}}.param.validation.min_items" + error.message = "Invalid array size for `{{paramName}}`, must hold at least {{minItems}} elements." + on_failure.call(error) + return + {{/if}} + {{/if}} + {{#if pattern}} + {{!#if isString}}{{! We are lenient and casting the param to string before trying to match }} + var bzz_{{paramName}}_regex := RegEx.new() + {{! We have to trim encapsulating slashes, and we don't support flags }} + {{! A solution would be to use another RegEx to extract that data from the pattern }} + bzz_{{paramName}}_regex.compile("{{{pattern}}}".trim_prefix('/').trim_suffix('/')) + if not bzz_{{paramName}}_regex.search(str({{paramName}})): + var error := {{>partials/api_error_class_name}}.new() + error.identifier = "{{operationIdSnakeCase}}.param.validation.pattern" + error.message = "Invalid value for `{{paramName}}`, must conform to the pattern `{{{pattern}}}`." + on_failure.call(error) + return + {{!/if}} + {{/if}} + {{/if}} + + {{/each}} # Compute the URL path to the API resource var bzz_path := "{{{contextPath}}}{{{path}}}"{{#each pathParams}}.replace("{" + "{{baseName}}" + "}", bee_urlize_path_param({{{paramName}}})){{/each}} @@ -50,11 +140,22 @@ func {{operationIdSnakeCase}}( {{#each queryParams}} bzz_query["{{baseName}}"] = {{paramName}} {{/each}} + {{#each formParams}} + #bzz_query["{{baseName}}"] = {{paramName}} + {{/each}} var bzz_body = null + {{#if bodyParams}} {{#each bodyParams}} bzz_body = {{paramName}} {{/each}} + {{/if}} + {{#if formParams}} + bzz_body = Dictionary() + {{#each formParams}} + bzz_body["{{paramName}}"] = {{paramName}} + {{/each}} + {{/if}} {{#with returnProperty}} # Will be used at some point for denormalization diff --git a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars index ddea16a79f49..627884fe7ffb 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars @@ -37,7 +37,8 @@ var bee_class_name := "{{classname}}" var {{name}}: {{>partials/data_type}}{{#if defaultValue}} = {{{defaultValue}}}{{/if}}: set(value): {{#if deprecated}} - push_warning("{{classname}}: property `{{name}}` is deprecated.") + if str(value) != "": + push_warning("{{classname}}: property `{{name}}` is deprecated.") {{/if}} {{#if isEnum}} if str(value) != "" and not (str(value) in __{{name}}__allowable__values): diff --git a/samples/client/petstore/gdscript/apis/DemoPetApi.gd b/samples/client/petstore/gdscript/apis/DemoPetApi.gd index 10a2062e2ece..c10e4ac03222 100644 --- a/samples/client/petstore/gdscript/apis/DemoPetApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoPetApi.gd @@ -21,6 +21,7 @@ func add_pet( # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + # Compute the URL path to the API resource var bzz_path := "/v2/pet" @@ -73,6 +74,8 @@ func delete_pet( # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource var bzz_path := "/v2/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) @@ -116,6 +119,7 @@ func find_pets_by_status( # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + # Compute the URL path to the API resource var bzz_path := "/v2/pet/findByStatus" @@ -168,6 +172,7 @@ func find_pets_by_tags( # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + # Compute the URL path to the API resource var bzz_path := "/v2/pet/findByTags" @@ -219,6 +224,7 @@ func get_pet_by_id( # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + # Compute the URL path to the API resource var bzz_path := "/v2/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) @@ -267,6 +273,7 @@ func update_pet( # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + # Compute the URL path to the API resource var bzz_path := "/v2/pet" @@ -322,6 +329,9 @@ func update_pet_with_form( # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + + # Compute the URL path to the API resource var bzz_path := "/v2/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) @@ -331,8 +341,13 @@ func update_pet_with_form( # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() + #bzz_query["name"] = name + #bzz_query["status"] = status var bzz_body = null + bzz_body = Dictionary() + bzz_body["name"] = name + bzz_body["status"] = status bee_request( @@ -369,6 +384,9 @@ func upload_file( # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + + # Compute the URL path to the API resource var bzz_path := "/v2/pet/{petId}/uploadImage".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) @@ -378,8 +396,13 @@ func upload_file( # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() + #bzz_query["additionalMetadata"] = additionalMetadata + #bzz_query["file"] = file var bzz_body = null + bzz_body = Dictionary() + bzz_body["additionalMetadata"] = additionalMetadata + bzz_body["file"] = file # Will be used at some point for denormalization # baseType = "ApiResponse" diff --git a/samples/client/petstore/gdscript/apis/DemoStoreApi.gd b/samples/client/petstore/gdscript/apis/DemoStoreApi.gd index 49396fdaf8b4..e31ab31eefb8 100644 --- a/samples/client/petstore/gdscript/apis/DemoStoreApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoStoreApi.gd @@ -23,6 +23,7 @@ func delete_order( # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + # Compute the URL path to the API resource var bzz_path := "/v2/store/order/{orderId}".replace("{" + "orderId" + "}", bee_urlize_path_param(orderId)) @@ -113,6 +114,20 @@ func get_order_by_id( # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + # Validate param `orderId` constraints + if orderId > 5: + var error := DemoApiError.new() + error.identifier = "get_order_by_id.param.validation.maximum" + error.message = "Invalid value for `orderId`, must be smaller than or equal to 5." + on_failure.call(error) + return + if orderId < 1: + var error := DemoApiError.new() + error.identifier = "get_order_by_id.param.validation.minimum" + error.message = "Invalid value for `orderId`, must be greater than or equal to 1." + on_failure.call(error) + return + # Compute the URL path to the API resource var bzz_path := "/v2/store/order/{orderId}".replace("{" + "orderId" + "}", bee_urlize_path_param(orderId)) @@ -161,6 +176,7 @@ func place_order( # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + # Compute the URL path to the API resource var bzz_path := "/v2/store/order" diff --git a/samples/client/petstore/gdscript/apis/DemoUserApi.gd b/samples/client/petstore/gdscript/apis/DemoUserApi.gd index dd5f9b2f9220..ce1acfa35f22 100644 --- a/samples/client/petstore/gdscript/apis/DemoUserApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoUserApi.gd @@ -23,6 +23,7 @@ func create_user( # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + # Compute the URL path to the API resource var bzz_path := "/v2/user" @@ -65,6 +66,7 @@ func create_users_with_array_input( # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + # Compute the URL path to the API resource var bzz_path := "/v2/user/createWithArray" @@ -107,6 +109,7 @@ func create_users_with_list_input( # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + # Compute the URL path to the API resource var bzz_path := "/v2/user/createWithList" @@ -151,6 +154,7 @@ func delete_user( # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + # Compute the URL path to the API resource var bzz_path := "/v2/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) @@ -192,6 +196,7 @@ func get_user_by_name( # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + # Compute the URL path to the API resource var bzz_path := "/v2/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) @@ -243,6 +248,25 @@ func login_user( # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + # Validate param `username` constraints + var bzz_username_regex := RegEx.new() + bzz_username_regex.compile("/^[a-zA-Z0-9]+[a-zA-Z0-9\\.\\-_]*[a-zA-Z0-9]+$/".trim_prefix('/').trim_suffix('/')) + if not bzz_username_regex.search(str(username)): + var error := DemoApiError.new() + error.identifier = "login_user.param.validation.pattern" + error.message = "Invalid value for `username`, must conform to the pattern `/^[a-zA-Z0-9]+[a-zA-Z0-9\\.\\-_]*[a-zA-Z0-9]+$/`." + on_failure.call(error) + return + + # Validate param `password` constraints + if (password is String) and password.length() > 7: + var error := DemoApiError.new() + #error.internal_code = ERR_INVALID_PARAMETER + error.identifier = "login_user.param.validation.max_length" + error.message = "Invalid length for `password`, must be smaller than or equal to 7." + on_failure.call(error) + return + # Compute the URL path to the API resource var bzz_path := "/v2/user/login" @@ -336,6 +360,8 @@ func update_user( # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Compute the URL path to the API resource var bzz_path := "/v2/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) diff --git a/samples/client/petstore/gdscript/models/DemoPet.gd b/samples/client/petstore/gdscript/models/DemoPet.gd index 3730c30dd823..c6a39d87fa02 100644 --- a/samples/client/petstore/gdscript/models/DemoPet.gd +++ b/samples/client/petstore/gdscript/models/DemoPet.gd @@ -63,7 +63,8 @@ var __tags__was__set := false # Allowed values: "available", "pending", "sold" var status: String: set(value): - push_warning("DemoPet: property `status` is deprecated.") + if str(value) != "": + push_warning("DemoPet: property `status` is deprecated.") if str(value) != "" and not (str(value) in __status__allowable__values): printerr("DemoPet: tried to set property `status` to a value that is not allowed." + " Allowed values: `available`, `pending`, `sold`") From 13ea8a980a688ed828de4abff5218e909b454a6f Mon Sep 17 00:00:00 2001 From: Goutte Date: Sat, 22 Oct 2022 00:31:12 +0200 Subject: [PATCH 14/56] feat(gdscript): handle header params and header customization We also support serializing to application/x-www-form-urlencoded now. Next up: DateTimes ! --- .../main/resources/gdscript/ApiBee.handlebars | 94 +++++++-- .../main/resources/gdscript/api.handlebars | 46 ++++- .../petstore/gdscript/apis/DemoPetApi.gd | 183 +++++++++++++++--- .../petstore/gdscript/apis/DemoStoreApi.gd | 77 ++++++-- .../petstore/gdscript/apis/DemoUserApi.gd | 162 +++++++++++++--- .../petstore/gdscript/core/DemoApiBee.gd | 93 +++++++-- samples/client/petstore/gdscript/demo/main.gd | 43 +++- 7 files changed, 565 insertions(+), 133 deletions(-) diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars index ca53c2a79f94..1575c5c957b0 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars @@ -17,6 +17,26 @@ const HTTP_DEFAULT_PORT := 80 const HTTPS_DEFAULT_PORT := 443 const POLLING_INTERVAL_MS := 500 # milliseconds +const BEE_CONTENT_TYPE_TEXT := "text/plain" +const BEE_CONTENT_TYPE_JSON := "application/json" +const BEE_CONTENT_TYPE_FORM := "application/x-www-form-urlencoded" +const BEE_CONTENT_TYPE_JSONLD := "application/json+ld" # unsupported (for now) +const BEE_CONTENT_TYPE_XML := "application/xml" # unsupported (for now) + +# From this client's point of view. +# Adding a content type here won't magically make the client support it, but you may reorder. +# These are sorted by decreasing preference. (first → preferred) +const BEE_PRODUCIBLE_CONTENT_TYPES := [ + BEE_CONTENT_TYPE_JSON, + BEE_CONTENT_TYPE_FORM, +] + +# From this client's point of view. +# Adding a content type here won't magically make the client support it, but you may reorder. +# These are sorted by decreasing preference. (first → preferred) +const BEE_CONSUMABLE_CONTENT_TYPES := [ + BEE_CONTENT_TYPE_JSON, +] # We'll probably only use this for logging var bee_name := "ApiBee" @@ -48,10 +68,30 @@ var bee_host := DEFAULT_HOST: # Port through which the connection will be established. -# Note: changing the host may change the port as well. +# Note: changing the host may change the port as well if the scheme was provided, see above. var bee_port := HTTP_DEFAULT_PORT +# Headers used as base for all requests made by this instance. +# Those are the lowest priority headers, and are merged with custom headers provided in the bee_request() method call +# to compute the final, actually sent headers. +# Note: the factory, if used, will set up here a shared dictionary across all instances. +var bee_headers_base := { + # Stigmergy: everyone does what is left to do (like ants do) + "User-Agent": "Stigmergiac/1.0 (Godot)", + # For my mental health's sake, only JSON is supported for now + "Accept": "application/json", + "Content-Type": "application/json", + # FIXME: Remove demo cheat code + "api_key": "special-key", +} + + +# High-priority headers, they will always override other headers coming from the base above or the method call. +# Note: the factory, if used, will set up here a shared dictionary across all instances. +var bee_headers_override := {} + + # @private var __bee_ssl_enabled := false var __bee_verify_host := true # only if ssl enabled @@ -68,6 +108,7 @@ func bee_disable_ssl(): func bee_next_loop_iteration(): + # I can't find `idle_frame` in 4-beta3, but we probably want idle_frame here return Engine.get_main_loop().process_frame @@ -132,6 +173,7 @@ func bee_connect_client_if_needed( func bee_request( method: int, # one of HTTPClient.METHOD_XXXXX path: String, + headers: Dictionary, query: Dictionary, body, # Variant that will be serialized on_success: Callable, # func(response: Variant, responseCode: int, responseHeaders: Dictionary) @@ -139,7 +181,7 @@ func bee_request( ): bee_request_text( - method, path, query, body, + method, path, headers, query, body, func(responseText, responseCode, responseHeaders): var mime: String = responseHeaders['Mime'] var deserializedResponse: Dictionary @@ -181,6 +223,7 @@ func bee_request( func bee_request_text( method: int, # one of HTTPClient.METHOD_XXXXX path: String, + headers: Dictionary, query: Dictionary, body, # Variant that will be serialized on_success: Callable, # func(responseText: String, responseCode: int, responseHeaders: Dictionary) @@ -188,7 +231,7 @@ func bee_request_text( ): bee_connect_client_if_needed( func(): - bee_do_request_text(method, path, query, body, on_success, on_failure) + bee_do_request_text(method, path, headers, query, body, on_success, on_failure) , func(error): on_failure.call(error) @@ -200,25 +243,17 @@ func bee_request_text( func bee_do_request_text( method: int, # one of HTTPClient.METHOD_XXXXX path: String, + headers: Dictionary, query: Dictionary, body, # Variant that will be serialized on_success: Callable, # func(responseText: String, responseCode: int, responseHeaders: Dictionary) on_failure: Callable, # func(error: {{>partials/api_error_class_name}}) ): - # TODO: How can we help users define more / override these? - # 1. template overrides - # 2. CLI args - # 3. YAML Config file - # 4. class property/method (needed anyway for auth) - var headers = [ - "User-Agent: Stigmergiac/1.0 (Godot)", - "Accept: application/json", - "Content-Type: application/json", - "api_key: special-key", - ] - - # TODO: Handle other serialization schemes (json+ld, xml…) + headers = headers.duplicate(true) + headers.merge(self.bee_headers_base) + headers.merge(self.bee_headers_override, true) + var body_normalized = body if body is Object: if body.has_method('bee_collect_missing_properties'): @@ -233,14 +268,28 @@ func bee_do_request_text( return if body.has_method('bee_normalize'): body_normalized = body.bee_normalize() - var body_serialized = JSON.stringify(body_normalized) + + var body_serialized := "" + var content_type := self.bee_get_content_type(headers) + if content_type == BEE_CONTENT_TYPE_JSON: + body_serialized = JSON.stringify(body_normalized) + elif content_type == BEE_CONTENT_TYPE_FORM: + body_serialized = self.bee_client.query_string_from_dict(body_normalized) + else: + # TODO: Handle other serialization schemes (json+ld, xml…) + push_warning("Unsupported content-type `%s`." % content_type) var path_queried := path var query_string := self.bee_client.query_string_from_dict(query) if query_string: path_queried = "%s?%s" % [path, query_string] - var requesting := self.bee_client.request(method, path_queried, headers, body_serialized) + {{! Godot HTTP Client expects an array of strings, not a dictionary }} + var headers_for_godot := Array() # of String + for key in headers: + headers_for_godot.append("%s: %s" % [key, headers[key]]) + + var requesting := self.bee_client.request(method, path_queried, headers_for_godot, body_serialized) if requesting != OK: var error := {{>partials/api_error_class_name}}.new() error.internal_code = requesting @@ -292,8 +341,7 @@ func bee_do_request_text( else: # Yummy data has arrived response_bytes = response_bytes + chunk - print("REQUEST") - print("%s %s" % [method, path_queried]) + print("REQUEST %s %s" % [method, path_queried]) print("Headers: %s" % [str(headers)]) prints(body_serialized) @@ -378,6 +426,12 @@ func bee_escape_path_param(value: String) -> String: return value +func bee_get_content_type(headers: Dictionary) -> String: + if headers.has("Content-Type"): + return headers["Content-Type"] + return BEE_PRODUCIBLE_CONTENT_TYPES[0] + + func bee_format_error_response(response: String) -> String: # TODO: handle other (de)serialization schemes var parser := JSON.new() diff --git a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars index 252d0be4d48e..62fd8df9c288 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars @@ -116,6 +116,7 @@ func {{operationIdSnakeCase}}( var bzz_{{paramName}}_regex := RegEx.new() {{! We have to trim encapsulating slashes, and we don't support flags }} {{! A solution would be to use another RegEx to extract that data from the pattern }} + {{! Perhaps not, since the encapsulating slashes are seemingly added by the engine… }} bzz_{{paramName}}_regex.compile("{{{pattern}}}".trim_prefix('/').trim_suffix('/')) if not bzz_{{paramName}}_regex.search(str({{paramName}})): var error := {{>partials/api_error_class_name}}.new() @@ -128,11 +129,48 @@ func {{operationIdSnakeCase}}( {{/if}} {{/each}} + + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := self.bee_convert_http_method("{{httpMethod}}") + # Compute the URL path to the API resource var bzz_path := "{{{contextPath}}}{{{path}}}"{{#each pathParams}}.replace("{" + "{{baseName}}" + "}", bee_urlize_path_param({{{paramName}}})){{/each}} - # Convert the String HTTP method to a Constant Godot understands - var bzz_method := bee_convert_http_method("{{httpMethod}}") +{{!-- + # Allowed media types, from the server's point of view + var bzz_media_types = { + 'produces': [{{#each produces}}'{{{mediaType}}}'{{#unless @last}}, {{/unless}}{{/each}}], + 'consumes': [{{#each consumes}}'{{{mediaType}}}'{{#unless @last}}, {{/unless}}{{/each}}], + } +--}} + # Collect the headers + var bzz_headers := Dictionary() + {{#each headerParams}} + bzz_headers["{{baseName}}"] = {{paramName}} + {{/each}} + {{#if consumes}} + var bzz_server_consumed_mimes := [{{#each consumes}}'{{{mediaType}}}'{{#unless @last}}, {{/unless}}{{/each}}] + var bzz_found_target_mime := false + for bzz_mime in BEE_PRODUCIBLE_CONTENT_TYPES: + if bzz_mime in bzz_server_consumed_mimes: + bzz_headers["Content-Type"] = bzz_mime + bzz_found_target_mime = true + break + if not bzz_found_target_mime: + # This is a bit strict, perhaps we could just warn and send JSON anyway? + var error := {{>partials/api_error_class_name}}.new() + error.identifier = "{{operationIdSnakeCase}}.headers.content_type" + error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." + on_failure.call(error) + return + {{/if}} + {{#if produces}} + var bzz_server_produced_mimes := [{{#each produces}}'{{{mediaType}}}'{{#unless @last}}, {{/unless}}{{/each}}] + for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: + if bzz_mime in bzz_server_produced_mimes: + bzz_headers["Accept"] = bzz_mime + break + {{/if}} # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -167,8 +205,8 @@ func {{operationIdSnakeCase}}( var _bzz_return_type := "{{{complexType}}}" {{/with}} - bee_request( - bzz_method, bzz_path, bzz_query, bzz_body, + self.bee_request( + bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) diff --git a/samples/client/petstore/gdscript/apis/DemoPetApi.gd b/samples/client/petstore/gdscript/apis/DemoPetApi.gd index c10e4ac03222..2660445d38f0 100644 --- a/samples/client/petstore/gdscript/apis/DemoPetApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoPetApi.gd @@ -22,11 +22,34 @@ func add_pet( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := self.bee_convert_http_method("POST") + # Compute the URL path to the API resource var bzz_path := "/v2/pet" - # Convert the String HTTP method to a Constant Godot understands - var bzz_method := bee_convert_http_method("POST") + # Collect the headers + var bzz_headers := Dictionary() + var bzz_server_consumed_mimes := ['application/json', 'application/xml'] + var bzz_found_target_mime := false + for bzz_mime in BEE_PRODUCIBLE_CONTENT_TYPES: + if bzz_mime in bzz_server_consumed_mimes: + bzz_headers["Content-Type"] = bzz_mime + bzz_found_target_mime = true + break + if not bzz_found_target_mime: + # This is a bit strict, perhaps we could just warn and send JSON anyway? + var error := DemoApiError.new() + error.identifier = "add_pet.headers.content_type" + error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." + on_failure.call(error) + return + var bzz_server_produced_mimes := ['application/xml', 'application/json'] + for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: + if bzz_mime in bzz_server_produced_mimes: + bzz_headers["Accept"] = bzz_mime + break # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -43,8 +66,8 @@ func add_pet( # isArray = "false" var _bzz_return_type := "Pet" - bee_request( - bzz_method, bzz_path, bzz_query, bzz_body, + self.bee_request( + bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -76,11 +99,16 @@ func delete_pet( + + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := self.bee_convert_http_method("DELETE") + # Compute the URL path to the API resource var bzz_path := "/v2/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) - # Convert the String HTTP method to a Constant Godot understands - var bzz_method := bee_convert_http_method("DELETE") + # Collect the headers + var bzz_headers := Dictionary() + bzz_headers["api_key"] = apiKey # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -89,8 +117,8 @@ func delete_pet( var bzz_body = null - bee_request( - bzz_method, bzz_path, bzz_query, bzz_body, + self.bee_request( + bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -120,11 +148,20 @@ func find_pets_by_status( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := self.bee_convert_http_method("GET") + # Compute the URL path to the API resource var bzz_path := "/v2/pet/findByStatus" - # Convert the String HTTP method to a Constant Godot understands - var bzz_method := bee_convert_http_method("GET") + # Collect the headers + var bzz_headers := Dictionary() + var bzz_server_produced_mimes := ['application/xml', 'application/json'] + for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: + if bzz_mime in bzz_server_produced_mimes: + bzz_headers["Accept"] = bzz_mime + break # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -141,8 +178,8 @@ func find_pets_by_status( # isArray = "true" var _bzz_return_type := "Pet" - bee_request( - bzz_method, bzz_path, bzz_query, bzz_body, + self.bee_request( + bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -173,11 +210,20 @@ func find_pets_by_tags( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := self.bee_convert_http_method("GET") + # Compute the URL path to the API resource var bzz_path := "/v2/pet/findByTags" - # Convert the String HTTP method to a Constant Godot understands - var bzz_method := bee_convert_http_method("GET") + # Collect the headers + var bzz_headers := Dictionary() + var bzz_server_produced_mimes := ['application/xml', 'application/json'] + for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: + if bzz_mime in bzz_server_produced_mimes: + bzz_headers["Accept"] = bzz_mime + break # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -194,8 +240,8 @@ func find_pets_by_tags( # isArray = "true" var _bzz_return_type := "Pet" - bee_request( - bzz_method, bzz_path, bzz_query, bzz_body, + self.bee_request( + bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -225,11 +271,20 @@ func get_pet_by_id( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := self.bee_convert_http_method("GET") + # Compute the URL path to the API resource var bzz_path := "/v2/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) - # Convert the String HTTP method to a Constant Godot understands - var bzz_method := bee_convert_http_method("GET") + # Collect the headers + var bzz_headers := Dictionary() + var bzz_server_produced_mimes := ['application/xml', 'application/json'] + for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: + if bzz_mime in bzz_server_produced_mimes: + bzz_headers["Accept"] = bzz_mime + break # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -245,8 +300,8 @@ func get_pet_by_id( # isArray = "false" var _bzz_return_type := "Pet" - bee_request( - bzz_method, bzz_path, bzz_query, bzz_body, + self.bee_request( + bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -274,11 +329,34 @@ func update_pet( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := self.bee_convert_http_method("PUT") + # Compute the URL path to the API resource var bzz_path := "/v2/pet" - # Convert the String HTTP method to a Constant Godot understands - var bzz_method := bee_convert_http_method("PUT") + # Collect the headers + var bzz_headers := Dictionary() + var bzz_server_consumed_mimes := ['application/json', 'application/xml'] + var bzz_found_target_mime := false + for bzz_mime in BEE_PRODUCIBLE_CONTENT_TYPES: + if bzz_mime in bzz_server_consumed_mimes: + bzz_headers["Content-Type"] = bzz_mime + bzz_found_target_mime = true + break + if not bzz_found_target_mime: + # This is a bit strict, perhaps we could just warn and send JSON anyway? + var error := DemoApiError.new() + error.identifier = "update_pet.headers.content_type" + error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." + on_failure.call(error) + return + var bzz_server_produced_mimes := ['application/xml', 'application/json'] + for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: + if bzz_mime in bzz_server_produced_mimes: + bzz_headers["Accept"] = bzz_mime + break # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -295,8 +373,8 @@ func update_pet( # isArray = "false" var _bzz_return_type := "Pet" - bee_request( - bzz_method, bzz_path, bzz_query, bzz_body, + self.bee_request( + bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -332,11 +410,29 @@ func update_pet_with_form( + + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := self.bee_convert_http_method("POST") + # Compute the URL path to the API resource var bzz_path := "/v2/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) - # Convert the String HTTP method to a Constant Godot understands - var bzz_method := bee_convert_http_method("POST") + # Collect the headers + var bzz_headers := Dictionary() + var bzz_server_consumed_mimes := ['application/x-www-form-urlencoded'] + var bzz_found_target_mime := false + for bzz_mime in BEE_PRODUCIBLE_CONTENT_TYPES: + if bzz_mime in bzz_server_consumed_mimes: + bzz_headers["Content-Type"] = bzz_mime + bzz_found_target_mime = true + break + if not bzz_found_target_mime: + # This is a bit strict, perhaps we could just warn and send JSON anyway? + var error := DemoApiError.new() + error.identifier = "update_pet_with_form.headers.content_type" + error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." + on_failure.call(error) + return # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -350,8 +446,8 @@ func update_pet_with_form( bzz_body["status"] = status - bee_request( - bzz_method, bzz_path, bzz_query, bzz_body, + self.bee_request( + bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -387,11 +483,34 @@ func upload_file( + + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := self.bee_convert_http_method("POST") + # Compute the URL path to the API resource var bzz_path := "/v2/pet/{petId}/uploadImage".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) - # Convert the String HTTP method to a Constant Godot understands - var bzz_method := bee_convert_http_method("POST") + # Collect the headers + var bzz_headers := Dictionary() + var bzz_server_consumed_mimes := ['multipart/form-data'] + var bzz_found_target_mime := false + for bzz_mime in BEE_PRODUCIBLE_CONTENT_TYPES: + if bzz_mime in bzz_server_consumed_mimes: + bzz_headers["Content-Type"] = bzz_mime + bzz_found_target_mime = true + break + if not bzz_found_target_mime: + # This is a bit strict, perhaps we could just warn and send JSON anyway? + var error := DemoApiError.new() + error.identifier = "upload_file.headers.content_type" + error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." + on_failure.call(error) + return + var bzz_server_produced_mimes := ['application/json'] + for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: + if bzz_mime in bzz_server_produced_mimes: + bzz_headers["Accept"] = bzz_mime + break # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -412,8 +531,8 @@ func upload_file( # isArray = "false" var _bzz_return_type := "ApiResponse" - bee_request( - bzz_method, bzz_path, bzz_query, bzz_body, + self.bee_request( + bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) diff --git a/samples/client/petstore/gdscript/apis/DemoStoreApi.gd b/samples/client/petstore/gdscript/apis/DemoStoreApi.gd index e31ab31eefb8..e33a0621733d 100644 --- a/samples/client/petstore/gdscript/apis/DemoStoreApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoStoreApi.gd @@ -24,11 +24,15 @@ func delete_order( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := self.bee_convert_http_method("DELETE") + # Compute the URL path to the API resource var bzz_path := "/v2/store/order/{orderId}".replace("{" + "orderId" + "}", bee_urlize_path_param(orderId)) - # Convert the String HTTP method to a Constant Godot understands - var bzz_method := bee_convert_http_method("DELETE") + # Collect the headers + var bzz_headers := Dictionary() # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -37,8 +41,8 @@ func delete_order( var bzz_body = null - bee_request( - bzz_method, bzz_path, bzz_query, bzz_body, + self.bee_request( + bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -64,11 +68,20 @@ func get_inventory( # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := self.bee_convert_http_method("GET") + # Compute the URL path to the API resource var bzz_path := "/v2/store/inventory" - # Convert the String HTTP method to a Constant Godot understands - var bzz_method := bee_convert_http_method("GET") + # Collect the headers + var bzz_headers := Dictionary() + var bzz_server_produced_mimes := ['application/json'] + for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: + if bzz_mime in bzz_server_produced_mimes: + bzz_headers["Accept"] = bzz_mime + break # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -84,8 +97,8 @@ func get_inventory( # isArray = "false" var _bzz_return_type := "integer" - bee_request( - bzz_method, bzz_path, bzz_query, bzz_body, + self.bee_request( + bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -128,11 +141,20 @@ func get_order_by_id( on_failure.call(error) return + + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := self.bee_convert_http_method("GET") + # Compute the URL path to the API resource var bzz_path := "/v2/store/order/{orderId}".replace("{" + "orderId" + "}", bee_urlize_path_param(orderId)) - # Convert the String HTTP method to a Constant Godot understands - var bzz_method := bee_convert_http_method("GET") + # Collect the headers + var bzz_headers := Dictionary() + var bzz_server_produced_mimes := ['application/xml', 'application/json'] + for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: + if bzz_mime in bzz_server_produced_mimes: + bzz_headers["Accept"] = bzz_mime + break # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -148,8 +170,8 @@ func get_order_by_id( # isArray = "false" var _bzz_return_type := "Order" - bee_request( - bzz_method, bzz_path, bzz_query, bzz_body, + self.bee_request( + bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -177,11 +199,34 @@ func place_order( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := self.bee_convert_http_method("POST") + # Compute the URL path to the API resource var bzz_path := "/v2/store/order" - # Convert the String HTTP method to a Constant Godot understands - var bzz_method := bee_convert_http_method("POST") + # Collect the headers + var bzz_headers := Dictionary() + var bzz_server_consumed_mimes := ['application/json'] + var bzz_found_target_mime := false + for bzz_mime in BEE_PRODUCIBLE_CONTENT_TYPES: + if bzz_mime in bzz_server_consumed_mimes: + bzz_headers["Content-Type"] = bzz_mime + bzz_found_target_mime = true + break + if not bzz_found_target_mime: + # This is a bit strict, perhaps we could just warn and send JSON anyway? + var error := DemoApiError.new() + error.identifier = "place_order.headers.content_type" + error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." + on_failure.call(error) + return + var bzz_server_produced_mimes := ['application/xml', 'application/json'] + for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: + if bzz_mime in bzz_server_produced_mimes: + bzz_headers["Accept"] = bzz_mime + break # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -198,8 +243,8 @@ func place_order( # isArray = "false" var _bzz_return_type := "Order" - bee_request( - bzz_method, bzz_path, bzz_query, bzz_body, + self.bee_request( + bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) diff --git a/samples/client/petstore/gdscript/apis/DemoUserApi.gd b/samples/client/petstore/gdscript/apis/DemoUserApi.gd index ce1acfa35f22..c1369607fad3 100644 --- a/samples/client/petstore/gdscript/apis/DemoUserApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoUserApi.gd @@ -24,11 +24,29 @@ func create_user( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := self.bee_convert_http_method("POST") + # Compute the URL path to the API resource var bzz_path := "/v2/user" - # Convert the String HTTP method to a Constant Godot understands - var bzz_method := bee_convert_http_method("POST") + # Collect the headers + var bzz_headers := Dictionary() + var bzz_server_consumed_mimes := ['application/json'] + var bzz_found_target_mime := false + for bzz_mime in BEE_PRODUCIBLE_CONTENT_TYPES: + if bzz_mime in bzz_server_consumed_mimes: + bzz_headers["Content-Type"] = bzz_mime + bzz_found_target_mime = true + break + if not bzz_found_target_mime: + # This is a bit strict, perhaps we could just warn and send JSON anyway? + var error := DemoApiError.new() + error.identifier = "create_user.headers.content_type" + error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." + on_failure.call(error) + return # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -38,8 +56,8 @@ func create_user( bzz_body = demoUser - bee_request( - bzz_method, bzz_path, bzz_query, bzz_body, + self.bee_request( + bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -67,11 +85,29 @@ func create_users_with_array_input( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := self.bee_convert_http_method("POST") + # Compute the URL path to the API resource var bzz_path := "/v2/user/createWithArray" - # Convert the String HTTP method to a Constant Godot understands - var bzz_method := bee_convert_http_method("POST") + # Collect the headers + var bzz_headers := Dictionary() + var bzz_server_consumed_mimes := ['application/json'] + var bzz_found_target_mime := false + for bzz_mime in BEE_PRODUCIBLE_CONTENT_TYPES: + if bzz_mime in bzz_server_consumed_mimes: + bzz_headers["Content-Type"] = bzz_mime + bzz_found_target_mime = true + break + if not bzz_found_target_mime: + # This is a bit strict, perhaps we could just warn and send JSON anyway? + var error := DemoApiError.new() + error.identifier = "create_users_with_array_input.headers.content_type" + error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." + on_failure.call(error) + return # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -81,8 +117,8 @@ func create_users_with_array_input( bzz_body = user - bee_request( - bzz_method, bzz_path, bzz_query, bzz_body, + self.bee_request( + bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -110,11 +146,29 @@ func create_users_with_list_input( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := self.bee_convert_http_method("POST") + # Compute the URL path to the API resource var bzz_path := "/v2/user/createWithList" - # Convert the String HTTP method to a Constant Godot understands - var bzz_method := bee_convert_http_method("POST") + # Collect the headers + var bzz_headers := Dictionary() + var bzz_server_consumed_mimes := ['application/json'] + var bzz_found_target_mime := false + for bzz_mime in BEE_PRODUCIBLE_CONTENT_TYPES: + if bzz_mime in bzz_server_consumed_mimes: + bzz_headers["Content-Type"] = bzz_mime + bzz_found_target_mime = true + break + if not bzz_found_target_mime: + # This is a bit strict, perhaps we could just warn and send JSON anyway? + var error := DemoApiError.new() + error.identifier = "create_users_with_list_input.headers.content_type" + error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." + on_failure.call(error) + return # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -124,8 +178,8 @@ func create_users_with_list_input( bzz_body = user - bee_request( - bzz_method, bzz_path, bzz_query, bzz_body, + self.bee_request( + bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -155,11 +209,15 @@ func delete_user( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := self.bee_convert_http_method("DELETE") + # Compute the URL path to the API resource var bzz_path := "/v2/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) - # Convert the String HTTP method to a Constant Godot understands - var bzz_method := bee_convert_http_method("DELETE") + # Collect the headers + var bzz_headers := Dictionary() # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -168,8 +226,8 @@ func delete_user( var bzz_body = null - bee_request( - bzz_method, bzz_path, bzz_query, bzz_body, + self.bee_request( + bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -197,11 +255,20 @@ func get_user_by_name( # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := self.bee_convert_http_method("GET") + # Compute the URL path to the API resource var bzz_path := "/v2/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) - # Convert the String HTTP method to a Constant Godot understands - var bzz_method := bee_convert_http_method("GET") + # Collect the headers + var bzz_headers := Dictionary() + var bzz_server_produced_mimes := ['application/xml', 'application/json'] + for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: + if bzz_mime in bzz_server_produced_mimes: + bzz_headers["Accept"] = bzz_mime + break # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -217,8 +284,8 @@ func get_user_by_name( # isArray = "false" var _bzz_return_type := "User" - bee_request( - bzz_method, bzz_path, bzz_query, bzz_body, + self.bee_request( + bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -267,11 +334,20 @@ func login_user( on_failure.call(error) return + + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := self.bee_convert_http_method("GET") + # Compute the URL path to the API resource var bzz_path := "/v2/user/login" - # Convert the String HTTP method to a Constant Godot understands - var bzz_method := bee_convert_http_method("GET") + # Collect the headers + var bzz_headers := Dictionary() + var bzz_server_produced_mimes := ['application/xml', 'application/json'] + for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: + if bzz_mime in bzz_server_produced_mimes: + bzz_headers["Accept"] = bzz_mime + break # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -289,8 +365,8 @@ func login_user( # isArray = "false" var _bzz_return_type := "string" - bee_request( - bzz_method, bzz_path, bzz_query, bzz_body, + self.bee_request( + bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -314,11 +390,15 @@ func logout_user( # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := self.bee_convert_http_method("GET") + # Compute the URL path to the API resource var bzz_path := "/v2/user/logout" - # Convert the String HTTP method to a Constant Godot understands - var bzz_method := bee_convert_http_method("GET") + # Collect the headers + var bzz_headers := Dictionary() # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -327,8 +407,8 @@ func logout_user( var bzz_body = null - bee_request( - bzz_method, bzz_path, bzz_query, bzz_body, + self.bee_request( + bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) @@ -362,11 +442,29 @@ func update_user( + + # Convert the String HTTP method to a Constant Godot understands + var bzz_method := self.bee_convert_http_method("PUT") + # Compute the URL path to the API resource var bzz_path := "/v2/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) - # Convert the String HTTP method to a Constant Godot understands - var bzz_method := bee_convert_http_method("PUT") + # Collect the headers + var bzz_headers := Dictionary() + var bzz_server_consumed_mimes := ['application/json'] + var bzz_found_target_mime := false + for bzz_mime in BEE_PRODUCIBLE_CONTENT_TYPES: + if bzz_mime in bzz_server_consumed_mimes: + bzz_headers["Content-Type"] = bzz_mime + bzz_found_target_mime = true + break + if not bzz_found_target_mime: + # This is a bit strict, perhaps we could just warn and send JSON anyway? + var error := DemoApiError.new() + error.identifier = "update_user.headers.content_type" + error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." + on_failure.call(error) + return # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays @@ -376,8 +474,8 @@ func update_user( bzz_body = demoUser - bee_request( - bzz_method, bzz_path, bzz_query, bzz_body, + self.bee_request( + bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): #print('SUCCESS!') #print(bzz_result) diff --git a/samples/client/petstore/gdscript/core/DemoApiBee.gd b/samples/client/petstore/gdscript/core/DemoApiBee.gd index b75045d17bd7..fafe437e2e85 100644 --- a/samples/client/petstore/gdscript/core/DemoApiBee.gd +++ b/samples/client/petstore/gdscript/core/DemoApiBee.gd @@ -17,6 +17,26 @@ const HTTP_DEFAULT_PORT := 80 const HTTPS_DEFAULT_PORT := 443 const POLLING_INTERVAL_MS := 500 # milliseconds +const BEE_CONTENT_TYPE_TEXT := "text/plain" +const BEE_CONTENT_TYPE_JSON := "application/json" +const BEE_CONTENT_TYPE_FORM := "application/x-www-form-urlencoded" +const BEE_CONTENT_TYPE_JSONLD := "application/json+ld" # unsupported (for now) +const BEE_CONTENT_TYPE_XML := "application/xml" # unsupported (for now) + +# From this client's point of view. +# Adding a content type here won't magically make the client support it, but you may reorder. +# These are sorted by decreasing preference. (first → preferred) +const BEE_PRODUCIBLE_CONTENT_TYPES := [ + BEE_CONTENT_TYPE_JSON, + BEE_CONTENT_TYPE_FORM, +] + +# From this client's point of view. +# Adding a content type here won't magically make the client support it, but you may reorder. +# These are sorted by decreasing preference. (first → preferred) +const BEE_CONSUMABLE_CONTENT_TYPES := [ + BEE_CONTENT_TYPE_JSON, +] # We'll probably only use this for logging var bee_name := "ApiBee" @@ -48,10 +68,30 @@ var bee_host := DEFAULT_HOST: # Port through which the connection will be established. -# Note: changing the host may change the port as well. +# Note: changing the host may change the port as well if the scheme was provided, see above. var bee_port := HTTP_DEFAULT_PORT +# Headers used as base for all requests made by this instance. +# Those are the lowest priority headers, and are merged with custom headers provided in the bee_request() method call +# to compute the final, actually sent headers. +# Note: the factory, if used, will set up here a shared dictionary across all instances. +var bee_headers_base := { + # Stigmergy: everyone does what is left to do (like ants do) + "User-Agent": "Stigmergiac/1.0 (Godot)", + # For my mental health's sake, only JSON is supported for now + "Accept": "application/json", + "Content-Type": "application/json", + # FIXME: Remove demo cheat code + "api_key": "special-key", +} + + +# High-priority headers, they will always override other headers coming from the base above or the method call. +# Note: the factory, if used, will set up here a shared dictionary across all instances. +var bee_headers_override := {} + + # @private var __bee_ssl_enabled := false var __bee_verify_host := true # only if ssl enabled @@ -68,6 +108,7 @@ func bee_disable_ssl(): func bee_next_loop_iteration(): + # I can't find `idle_frame` in 4-beta3, but we probably want idle_frame here return Engine.get_main_loop().process_frame @@ -132,6 +173,7 @@ func bee_connect_client_if_needed( func bee_request( method: int, # one of HTTPClient.METHOD_XXXXX path: String, + headers: Dictionary, query: Dictionary, body, # Variant that will be serialized on_success: Callable, # func(response: Variant, responseCode: int, responseHeaders: Dictionary) @@ -139,7 +181,7 @@ func bee_request( ): bee_request_text( - method, path, query, body, + method, path, headers, query, body, func(responseText, responseCode, responseHeaders): var mime: String = responseHeaders['Mime'] var deserializedResponse: Dictionary @@ -181,6 +223,7 @@ func bee_request( func bee_request_text( method: int, # one of HTTPClient.METHOD_XXXXX path: String, + headers: Dictionary, query: Dictionary, body, # Variant that will be serialized on_success: Callable, # func(responseText: String, responseCode: int, responseHeaders: Dictionary) @@ -188,7 +231,7 @@ func bee_request_text( ): bee_connect_client_if_needed( func(): - bee_do_request_text(method, path, query, body, on_success, on_failure) + bee_do_request_text(method, path, headers, query, body, on_success, on_failure) , func(error): on_failure.call(error) @@ -200,25 +243,17 @@ func bee_request_text( func bee_do_request_text( method: int, # one of HTTPClient.METHOD_XXXXX path: String, + headers: Dictionary, query: Dictionary, body, # Variant that will be serialized on_success: Callable, # func(responseText: String, responseCode: int, responseHeaders: Dictionary) on_failure: Callable, # func(error: DemoApiError) ): - # TODO: How can we help users define more / override these? - # 1. template overrides - # 2. CLI args - # 3. YAML Config file - # 4. class property/method (needed anyway for auth) - var headers = [ - "User-Agent: Stigmergiac/1.0 (Godot)", - "Accept: application/json", - "Content-Type: application/json", - "api_key: special-key", - ] - - # TODO: Handle other serialization schemes (json+ld, xml…) + headers = headers.duplicate(true) + headers.merge(self.bee_headers_base) + headers.merge(self.bee_headers_override, true) + var body_normalized = body if body is Object: if body.has_method('bee_collect_missing_properties'): @@ -233,14 +268,27 @@ func bee_do_request_text( return if body.has_method('bee_normalize'): body_normalized = body.bee_normalize() - var body_serialized = JSON.stringify(body_normalized) + + var body_serialized := "" + var content_type := self.bee_get_content_type(headers) + if content_type == BEE_CONTENT_TYPE_JSON: + body_serialized = JSON.stringify(body_normalized) + elif content_type == BEE_CONTENT_TYPE_FORM: + body_serialized = self.bee_client.query_string_from_dict(body_normalized) + else: + # TODO: Handle other serialization schemes (json+ld, xml…) + push_warning("Unsupported content-type `%s`." % content_type) var path_queried := path var query_string := self.bee_client.query_string_from_dict(query) if query_string: path_queried = "%s?%s" % [path, query_string] - var requesting := self.bee_client.request(method, path_queried, headers, body_serialized) + var headers_for_godot := Array() # of String + for key in headers: + headers_for_godot.append("%s: %s" % [key, headers[key]]) + + var requesting := self.bee_client.request(method, path_queried, headers_for_godot, body_serialized) if requesting != OK: var error := DemoApiError.new() error.internal_code = requesting @@ -292,8 +340,7 @@ func bee_do_request_text( else: # Yummy data has arrived response_bytes = response_bytes + chunk - print("REQUEST") - print("%s %s" % [method, path_queried]) + print("REQUEST %s %s" % [method, path_queried]) print("Headers: %s" % [str(headers)]) prints(body_serialized) @@ -378,6 +425,12 @@ func bee_escape_path_param(value: String) -> String: return value +func bee_get_content_type(headers: Dictionary) -> String: + if headers.has("Content-Type"): + return headers["Content-Type"] + return BEE_PRODUCIBLE_CONTENT_TYPES[0] + + func bee_format_error_response(response: String) -> String: # TODO: handle other (de)serialization schemes var parser := JSON.new() diff --git a/samples/client/petstore/gdscript/demo/main.gd b/samples/client/petstore/gdscript/demo/main.gd index c115e3a45e19..23f718d2fa43 100644 --- a/samples/client/petstore/gdscript/demo/main.gd +++ b/samples/client/petstore/gdscript/demo/main.gd @@ -77,7 +77,14 @@ func run_test_01(): authenticate( rick.username, rick.password, func(): - add_monkey() + add_monkey( + func(monkey): + update_monkey( + monkey, "Summer", + func(result): + emit_signal("test_ended") + ) + ) ) , func(error): @@ -87,9 +94,6 @@ func run_test_01(): ) -var api_key: String - - func authenticate(username: String, password: String, on_done: Callable): var user_api := DemoUserApi.new() user_api.bee_port = 8081 @@ -97,7 +101,6 @@ func authenticate(username: String, password: String, on_done: Callable): username, password, func(result): prints("Login Response:", result) - #api_key = result on_done.call() , func(error): @@ -108,7 +111,7 @@ func authenticate(username: String, password: String, on_done: Callable): ) -func add_monkey(): +func add_monkey(on_done: Callable): var monkey := DemoPet.new() monkey.name = "Gregoire" @@ -123,8 +126,33 @@ func add_monkey(): monkey, func(result): print("Added monkey.") + on_done.call(result) + #emit_signal("test_ended") + , + #func(error: ApiError): # ← straight up crash, try again later + func(error): + # OH GOSH THIS CRASHES AS WELL (works with RefCounted) + # (but error does have type ApiError) +# if not (error is ApiError): +# fail("Error in on_failure callback has the wrong type.") + printerr("ERROR!") + fail(str(error)) emit_signal("test_ended") , + ) + + +func update_monkey(monkey, new_name, on_done: Callable): + + var pet_api := DemoPetApi.new() + pet_api.bee_port = 8081 + pet_api.update_pet_with_form( + monkey.id, new_name, "available", + func(result): + print("Updated monkey.") + print(result) + on_done.call(result) + , #func(error: ApiError): # ← straight up crash, try again later func(error): # OH GOSH THIS CRASHES AS WELL (works with RefCounted) @@ -136,7 +164,4 @@ func add_monkey(): emit_signal("test_ended") , ) - - - From 44582120bd818389c1a65767437fee838884c19d Mon Sep 17 00:00:00 2001 From: Goutte Date: Sat, 22 Oct 2022 01:35:39 +0200 Subject: [PATCH 15/56] feat(gdscript): handle Date and DateTime like Strings There's no timezone support in Godot for DateTimes. --- .../languages/GdscriptClientCodegen.java | 22 ++++++++-------- .../main/resources/gdscript/api.handlebars | 10 +++++--- .../main/resources/gdscript/model.handlebars | 11 ++++++-- .../petstore/gdscript/apis/DemoPetApi.gd | 25 +------------------ .../petstore/gdscript/apis/DemoStoreApi.gd | 12 --------- .../petstore/gdscript/apis/DemoUserApi.gd | 24 ------------------ .../gdscript/models/DemoApiResponse.gd | 11 +++----- .../petstore/gdscript/models/DemoCategory.gd | 9 ++----- .../petstore/gdscript/models/DemoOrder.gd | 22 +++++++--------- .../petstore/gdscript/models/DemoPet.gd | 17 +++++-------- .../petstore/gdscript/models/DemoTag.gd | 9 ++----- .../petstore/gdscript/models/DemoUser.gd | 21 ++++++---------- 12 files changed, 58 insertions(+), 135 deletions(-) diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java index fc5b9f97cba2..aace1649e0e5 100644 --- a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java +++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java @@ -94,25 +94,25 @@ public GdscriptClientCodegen() { typeMapping.put("integer", "int"); typeMapping.put("map", "Dictionary"); typeMapping.put("set", "Array"); - typeMapping.put("date", "string"); - // FIXME: handle DateTime somehow (with Time singleton) - typeMapping.put("DateTime", "Dictionary"); + // No timezone support in Godot so I'm skipping Datetimes for now + typeMapping.put("date", "String"); + typeMapping.put("datetime", "String"); //typeMapping.put("binary", "any"); - typeMapping.put("file", "File"); + typeMapping.put("file", "String"); // untested- typeMapping.put("ByteArray", "Array"); typeMapping.put("UUID", "String"); //typeMapping.put("Error", "Error"); //typeMapping.put("AnyType", "Variant"); - // TODO: add meaningful parameters - cliOptions.add(new CliOption(PROJECT_NAME, "The name of the project !!")); - cliOptions.add(new CliOption(CORE_NAME_PREFIX, "PascalCase prefix added to all generated classes")); + //cliOptions.add(new CliOption(PROJECT_NAME, "The name of the project !!")); + cliOptions.add(new CliOption(CORE_NAME_PREFIX, "PascalCase prefix added to all core classes")); + cliOptions.add(new CliOption(CORE_NAME_SUFFIX, "PascalCase suffix added to all core classes")); // This constructor is ran twice, because … reasons. - LOGGER.warn("THIS GENERATOR IS UNSAFE AND MALICIOUS OAS3 YAML FILES MAY HURT YOU."); - LOGGER.warn("PLEASE READ CAREFULLY THE OAS3 FILE YOU ARE USING BEFORE YOU TRUST IT."); - LOGGER.info("(this generation itself should be safe, but not the generated code)"); + LOGGER.warn("---- THIS GENERATOR IS UNSAFE AND MALICIOUS OAS FILES MAY HURT YOU ----"); + LOGGER.warn("PLEASE READ *CAREFULLY* THE OAS FILE YOU ARE USING BEFORE YOU TRUST IT."); + LOGGER.info("This generation itself should be safe but maybe not the generated code."); } @@ -206,7 +206,7 @@ public String toExampleValue(Schema schema) { return ""; } - // → Same + // → Same code smell, I'm probably handling this wrong. @Override public String toDefaultValue(Schema schema) { if (schema.getDefault() != null) { diff --git a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars index 62fd8df9c288..1bbd5fc6e6d2 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars @@ -33,10 +33,14 @@ func {{operationIdSnakeCase}}( on_success: Callable = Callable(), # func(result{{#if returnType}}: {{returnType}}{{/if}}) on_failure: Callable = Callable(), # func(error: ApiError) ): - # CollectionFormat: {{#if collectionFormat}}YES{{/if}}{{#unless collectionFormat}}NO{{/unless}} - - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames +{{!-- + # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames. # Warn: Make sure all local variable names here are also listed in our Java CodeGen. +--}} + # CollectionFormat: {{#if collectionFormat}}YES{{/if}}{{#unless collectionFormat}}NO{{/unless}} +{{#if isDeprecated}} + push_warning("Usage of `{{operationIdSnakeCase}}()` is deprecated.") +{{/if}} {{#each allParams}} {{!-- diff --git a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars index 627884fe7ffb..c7704038c217 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars @@ -27,10 +27,17 @@ var bee_class_name := "{{classname}}" # {{{description}}} {{/if}} # Type: {{>partials/data_type}} +{{#if isDate}} +# (but it's actually a Date ; no generated conversion because of lack of support for timezones in Godot) +{{/if}} +{{#if isDateTime}} +# (but it's actually a DateTime ; no generated conversion because of lack of support for timezones in Godot) +{{/if}} # Required: {{#unless required}}False{{/unless}}{{#if required}}True{{/if}} {{#if example}} # Example: {{{example}}} {{/if}} +# isArray: {{isArray}} {{#if isEnum}} # Allowed values: {{#with allowableValues}}{{#each values}}"{{this}}"{{#unless @last}}, {{/unless}}{{/each}}{{/with}} {{/if}} @@ -78,13 +85,13 @@ func bee_normalize() -> Dictionary: {{/each}} return bzz_dictionary - +{{!-- UNUSED func bee_normalize_fully() -> Dictionary: return { {{#each vars}} "{{name}}": self.{{name}}, {{/each}} } - +--}} {{/with}} {{/each}} \ No newline at end of file diff --git a/samples/client/petstore/gdscript/apis/DemoPetApi.gd b/samples/client/petstore/gdscript/apis/DemoPetApi.gd index 2660445d38f0..0328e5fa9a67 100644 --- a/samples/client/petstore/gdscript/apis/DemoPetApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoPetApi.gd @@ -18,9 +18,6 @@ func add_pet( ): # CollectionFormat: NO - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - # Convert the String HTTP method to a Constant Godot understands @@ -94,9 +91,6 @@ func delete_pet( ): # CollectionFormat: NO - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - @@ -144,9 +138,6 @@ func find_pets_by_status( ): # CollectionFormat: NO - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - # Convert the String HTTP method to a Constant Godot understands @@ -205,9 +196,7 @@ func find_pets_by_tags( on_failure: Callable = Callable(), # func(error: ApiError) ): # CollectionFormat: NO - - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. + push_warning("Usage of `find_pets_by_tags()` is deprecated.") @@ -267,9 +256,6 @@ func get_pet_by_id( ): # CollectionFormat: NO - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - # Convert the String HTTP method to a Constant Godot understands @@ -325,9 +311,6 @@ func update_pet( ): # CollectionFormat: NO - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - # Convert the String HTTP method to a Constant Godot understands @@ -404,9 +387,6 @@ func update_pet_with_form( ): # CollectionFormat: NO - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - @@ -477,9 +457,6 @@ func upload_file( ): # CollectionFormat: NO - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - diff --git a/samples/client/petstore/gdscript/apis/DemoStoreApi.gd b/samples/client/petstore/gdscript/apis/DemoStoreApi.gd index e33a0621733d..a36c001afbd4 100644 --- a/samples/client/petstore/gdscript/apis/DemoStoreApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoStoreApi.gd @@ -20,9 +20,6 @@ func delete_order( ): # CollectionFormat: NO - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - # Convert the String HTTP method to a Constant Godot understands @@ -65,9 +62,6 @@ func get_inventory( ): # CollectionFormat: NO - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - # Convert the String HTTP method to a Constant Godot understands var bzz_method := self.bee_convert_http_method("GET") @@ -124,9 +118,6 @@ func get_order_by_id( ): # CollectionFormat: NO - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - # Validate param `orderId` constraints if orderId > 5: var error := DemoApiError.new() @@ -195,9 +186,6 @@ func place_order( ): # CollectionFormat: NO - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - # Convert the String HTTP method to a Constant Godot understands diff --git a/samples/client/petstore/gdscript/apis/DemoUserApi.gd b/samples/client/petstore/gdscript/apis/DemoUserApi.gd index c1369607fad3..e9e19dc1df56 100644 --- a/samples/client/petstore/gdscript/apis/DemoUserApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoUserApi.gd @@ -20,9 +20,6 @@ func create_user( ): # CollectionFormat: NO - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - # Convert the String HTTP method to a Constant Godot understands @@ -81,9 +78,6 @@ func create_users_with_array_input( ): # CollectionFormat: NO - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - # Convert the String HTTP method to a Constant Godot understands @@ -142,9 +136,6 @@ func create_users_with_list_input( ): # CollectionFormat: NO - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - # Convert the String HTTP method to a Constant Godot understands @@ -205,9 +196,6 @@ func delete_user( ): # CollectionFormat: NO - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - # Convert the String HTTP method to a Constant Godot understands @@ -251,9 +239,6 @@ func get_user_by_name( ): # CollectionFormat: NO - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - # Convert the String HTTP method to a Constant Godot understands @@ -312,9 +297,6 @@ func login_user( ): # CollectionFormat: NO - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - # Validate param `username` constraints var bzz_username_regex := RegEx.new() bzz_username_regex.compile("/^[a-zA-Z0-9]+[a-zA-Z0-9\\.\\-_]*[a-zA-Z0-9]+$/".trim_prefix('/').trim_suffix('/')) @@ -387,9 +369,6 @@ func logout_user( ): # CollectionFormat: NO - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - # Convert the String HTTP method to a Constant Godot understands var bzz_method := self.bee_convert_http_method("GET") @@ -437,9 +416,6 @@ func update_user( ): # CollectionFormat: NO - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - diff --git a/samples/client/petstore/gdscript/models/DemoApiResponse.gd b/samples/client/petstore/gdscript/models/DemoApiResponse.gd index 131646473a1a..5cdcffc4ad92 100644 --- a/samples/client/petstore/gdscript/models/DemoApiResponse.gd +++ b/samples/client/petstore/gdscript/models/DemoApiResponse.gd @@ -17,6 +17,7 @@ var bee_class_name := "DemoApiResponse" # Type: int # Required: False +# isArray: false var code: int: set(value): __code__was__set = true @@ -25,6 +26,7 @@ var __code__was__set := false # Type: String # Required: False +# isArray: false var type: String: set(value): __type__was__set = true @@ -33,6 +35,7 @@ var __type__was__set := false # Type: String # Required: False +# isArray: false var message: String: set(value): __message__was__set = true @@ -55,11 +58,3 @@ func bee_normalize() -> Dictionary: bzz_dictionary["message"] = self.message return bzz_dictionary - -func bee_normalize_fully() -> Dictionary: - return { - "code": self.code, - "type": self.type, - "message": self.message, - } - diff --git a/samples/client/petstore/gdscript/models/DemoCategory.gd b/samples/client/petstore/gdscript/models/DemoCategory.gd index 7d64591b9712..e2b8e3172787 100644 --- a/samples/client/petstore/gdscript/models/DemoCategory.gd +++ b/samples/client/petstore/gdscript/models/DemoCategory.gd @@ -17,6 +17,7 @@ var bee_class_name := "DemoCategory" # Type: float # Required: False +# isArray: false var id: float: set(value): __id__was__set = true @@ -25,6 +26,7 @@ var __id__was__set := false # Type: String # Required: False +# isArray: false var name: String: set(value): __name__was__set = true @@ -45,10 +47,3 @@ func bee_normalize() -> Dictionary: bzz_dictionary["name"] = self.name return bzz_dictionary - -func bee_normalize_fully() -> Dictionary: - return { - "id": self.id, - "name": self.name, - } - diff --git a/samples/client/petstore/gdscript/models/DemoOrder.gd b/samples/client/petstore/gdscript/models/DemoOrder.gd index a619911db30b..d92fae76bc8a 100644 --- a/samples/client/petstore/gdscript/models/DemoOrder.gd +++ b/samples/client/petstore/gdscript/models/DemoOrder.gd @@ -17,6 +17,7 @@ var bee_class_name := "DemoOrder" # Type: float # Required: False +# isArray: false var id: float: set(value): __id__was__set = true @@ -25,6 +26,7 @@ var __id__was__set := false # Type: float # Required: False +# isArray: false var petId: float: set(value): __petId__was__set = true @@ -33,15 +35,18 @@ var __petId__was__set := false # Type: int # Required: False +# isArray: false var quantity: int: set(value): __quantity__was__set = true quantity = value var __quantity__was__set := false -# Type: Dictionary +# Type: DateTime +# (but it's actually a DateTime ; no generated conversion because of lack of support for timezones in Godot) # Required: False -var shipDate: Dictionary: +# isArray: false +var shipDate: DateTime: set(value): __shipDate__was__set = true shipDate = value @@ -50,6 +55,7 @@ var __shipDate__was__set := false # Order Status # Type: String # Required: False +# isArray: false # Allowed values: "placed", "approved", "delivered" var status: String: set(value): @@ -64,6 +70,7 @@ var __status__allowable__values := ["placed", "approved", "delivered"] # Type: bool # Required: False +# isArray: false var complete: bool = false: set(value): __complete__was__set = true @@ -92,14 +99,3 @@ func bee_normalize() -> Dictionary: bzz_dictionary["complete"] = self.complete return bzz_dictionary - -func bee_normalize_fully() -> Dictionary: - return { - "id": self.id, - "petId": self.petId, - "quantity": self.quantity, - "shipDate": self.shipDate, - "status": self.status, - "complete": self.complete, - } - diff --git a/samples/client/petstore/gdscript/models/DemoPet.gd b/samples/client/petstore/gdscript/models/DemoPet.gd index c6a39d87fa02..b1b744638526 100644 --- a/samples/client/petstore/gdscript/models/DemoPet.gd +++ b/samples/client/petstore/gdscript/models/DemoPet.gd @@ -17,6 +17,7 @@ var bee_class_name := "DemoPet" # Type: float # Required: False +# isArray: false var id: float: set(value): __id__was__set = true @@ -25,6 +26,7 @@ var __id__was__set := false # Type: DemoCategory # Required: False +# isArray: false var category: DemoCategory: set(value): __category__was__set = true @@ -34,6 +36,7 @@ var __category__was__set := false # Type: String # Required: True # Example: doggie +# isArray: false var name: String: set(value): __name__was__set = true @@ -42,6 +45,7 @@ var __name__was__set := false # Type: Array # Required: True +# isArray: true var photoUrls: Array: set(value): __photoUrls__was__set = true @@ -50,6 +54,7 @@ var __photoUrls__was__set := false # Type: Array # Required: False +# isArray: true var tags: Array: set(value): __tags__was__set = true @@ -60,6 +65,7 @@ var __tags__was__set := false # pet status in the store # Type: String # Required: False +# isArray: false # Allowed values: "available", "pending", "sold" var status: String: set(value): @@ -100,14 +106,3 @@ func bee_normalize() -> Dictionary: bzz_dictionary["status"] = self.status return bzz_dictionary - -func bee_normalize_fully() -> Dictionary: - return { - "id": self.id, - "category": self.category, - "name": self.name, - "photoUrls": self.photoUrls, - "tags": self.tags, - "status": self.status, - } - diff --git a/samples/client/petstore/gdscript/models/DemoTag.gd b/samples/client/petstore/gdscript/models/DemoTag.gd index cc125ba339ed..e4df0c59af38 100644 --- a/samples/client/petstore/gdscript/models/DemoTag.gd +++ b/samples/client/petstore/gdscript/models/DemoTag.gd @@ -17,6 +17,7 @@ var bee_class_name := "DemoTag" # Type: float # Required: False +# isArray: false var id: float: set(value): __id__was__set = true @@ -25,6 +26,7 @@ var __id__was__set := false # Type: String # Required: False +# isArray: false var name: String: set(value): __name__was__set = true @@ -45,10 +47,3 @@ func bee_normalize() -> Dictionary: bzz_dictionary["name"] = self.name return bzz_dictionary - -func bee_normalize_fully() -> Dictionary: - return { - "id": self.id, - "name": self.name, - } - diff --git a/samples/client/petstore/gdscript/models/DemoUser.gd b/samples/client/petstore/gdscript/models/DemoUser.gd index 1ff27aac622c..b5eda7fc7511 100644 --- a/samples/client/petstore/gdscript/models/DemoUser.gd +++ b/samples/client/petstore/gdscript/models/DemoUser.gd @@ -17,6 +17,7 @@ var bee_class_name := "DemoUser" # Type: float # Required: False +# isArray: false var id: float: set(value): __id__was__set = true @@ -25,6 +26,7 @@ var __id__was__set := false # Type: String # Required: False +# isArray: false var username: String: set(value): __username__was__set = true @@ -33,6 +35,7 @@ var __username__was__set := false # Type: String # Required: False +# isArray: false var firstName: String: set(value): __firstName__was__set = true @@ -41,6 +44,7 @@ var __firstName__was__set := false # Type: String # Required: False +# isArray: false var lastName: String: set(value): __lastName__was__set = true @@ -49,6 +53,7 @@ var __lastName__was__set := false # Type: String # Required: False +# isArray: false var email: String: set(value): __email__was__set = true @@ -57,6 +62,7 @@ var __email__was__set := false # Type: String # Required: False +# isArray: false var password: String: set(value): __password__was__set = true @@ -65,6 +71,7 @@ var __password__was__set := false # Type: String # Required: False +# isArray: false var phone: String: set(value): __phone__was__set = true @@ -74,6 +81,7 @@ var __phone__was__set := false # User Status # Type: int # Required: False +# isArray: false var userStatus: int: set(value): __userStatus__was__set = true @@ -106,16 +114,3 @@ func bee_normalize() -> Dictionary: bzz_dictionary["userStatus"] = self.userStatus return bzz_dictionary - -func bee_normalize_fully() -> Dictionary: - return { - "id": self.id, - "username": self.username, - "firstName": self.firstName, - "lastName": self.lastName, - "email": self.email, - "password": self.password, - "phone": self.phone, - "userStatus": self.userStatus, - } - From 9cb6c52bbe9be1780e482c930f53d3bece2f07cd Mon Sep 17 00:00:00 2001 From: Goutte Date: Sat, 22 Oct 2022 03:47:06 +0200 Subject: [PATCH 16/56] feat(gdscript): support plain text responses --- .../main/resources/gdscript/ApiBee.handlebars | 12 +++++++--- .../petstore/gdscript/apis/DemoPetApi.gd | 2 +- .../petstore/gdscript/core/DemoApiBee.gd | 12 +++++++--- samples/client/petstore/gdscript/demo/main.gd | 24 +++++++++++++++++-- 4 files changed, 41 insertions(+), 9 deletions(-) diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars index 1575c5c957b0..cf59a9d0af18 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars @@ -18,6 +18,7 @@ const HTTPS_DEFAULT_PORT := 443 const POLLING_INTERVAL_MS := 500 # milliseconds const BEE_CONTENT_TYPE_TEXT := "text/plain" +const BEE_CONTENT_TYPE_HTML := "text/html" const BEE_CONTENT_TYPE_JSON := "application/json" const BEE_CONTENT_TYPE_FORM := "application/x-www-form-urlencoded" const BEE_CONTENT_TYPE_JSONLD := "application/json+ld" # unsupported (for now) @@ -184,10 +185,14 @@ func bee_request( method, path, headers, query, body, func(responseText, responseCode, responseHeaders): var mime: String = responseHeaders['Mime'] - var deserializedResponse: Dictionary + var deserializedResponse # Variant var denormalizedResponse # Variant - if "application/json" == mime: + if BEE_CONTENT_TYPE_TEXT == mime: + deserializedResponse = responseText + elif BEE_CONTENT_TYPE_HTML == mime: + deserializedResponse = responseText + elif BEE_CONTENT_TYPE_JSON == mime: var parser := JSON.new() var parsing := parser.parse(responseText) if OK != parsing: @@ -200,7 +205,6 @@ func bee_request( on_failure.call(error) return deserializedResponse = parser.data - denormalizedResponse = deserializedResponse # FIXME else: var error := {{>partials/api_error_class_name}}.new() error.internal_code = ERR_INVALID_DATA @@ -211,6 +215,8 @@ func bee_request( on_failure.call(error) return + denormalizedResponse = deserializedResponse # FIXME + on_success.call(denormalizedResponse, responseCode, responseHeaders) , func(error): diff --git a/samples/client/petstore/gdscript/apis/DemoPetApi.gd b/samples/client/petstore/gdscript/apis/DemoPetApi.gd index 0328e5fa9a67..a91a35041354 100644 --- a/samples/client/petstore/gdscript/apis/DemoPetApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoPetApi.gd @@ -449,7 +449,7 @@ func upload_file( # additionalMetadata: String Eg: additionalMetadata_example # Additional data to pass to server additionalMetadata = null, - # file: File Eg: BINARY_DATA_HERE + # file: String Eg: BINARY_DATA_HERE # file to upload file = null, on_success: Callable = Callable(), # func(result: ApiResponse) diff --git a/samples/client/petstore/gdscript/core/DemoApiBee.gd b/samples/client/petstore/gdscript/core/DemoApiBee.gd index fafe437e2e85..90dae7c9b873 100644 --- a/samples/client/petstore/gdscript/core/DemoApiBee.gd +++ b/samples/client/petstore/gdscript/core/DemoApiBee.gd @@ -18,6 +18,7 @@ const HTTPS_DEFAULT_PORT := 443 const POLLING_INTERVAL_MS := 500 # milliseconds const BEE_CONTENT_TYPE_TEXT := "text/plain" +const BEE_CONTENT_TYPE_HTML := "text/html" const BEE_CONTENT_TYPE_JSON := "application/json" const BEE_CONTENT_TYPE_FORM := "application/x-www-form-urlencoded" const BEE_CONTENT_TYPE_JSONLD := "application/json+ld" # unsupported (for now) @@ -184,10 +185,14 @@ func bee_request( method, path, headers, query, body, func(responseText, responseCode, responseHeaders): var mime: String = responseHeaders['Mime'] - var deserializedResponse: Dictionary + var deserializedResponse # Variant var denormalizedResponse # Variant - if "application/json" == mime: + if BEE_CONTENT_TYPE_TEXT == mime: + deserializedResponse = responseText + elif BEE_CONTENT_TYPE_HTML == mime: + deserializedResponse = responseText + elif BEE_CONTENT_TYPE_JSON == mime: var parser := JSON.new() var parsing := parser.parse(responseText) if OK != parsing: @@ -200,7 +205,6 @@ func bee_request( on_failure.call(error) return deserializedResponse = parser.data - denormalizedResponse = deserializedResponse # FIXME else: var error := DemoApiError.new() error.internal_code = ERR_INVALID_DATA @@ -211,6 +215,8 @@ func bee_request( on_failure.call(error) return + denormalizedResponse = deserializedResponse # FIXME + on_success.call(denormalizedResponse, responseCode, responseHeaders) , func(error): diff --git a/samples/client/petstore/gdscript/demo/main.gd b/samples/client/petstore/gdscript/demo/main.gd index 23f718d2fa43..c4e60c1690b2 100644 --- a/samples/client/petstore/gdscript/demo/main.gd +++ b/samples/client/petstore/gdscript/demo/main.gd @@ -49,11 +49,12 @@ func fail(msg: String): func run_all_tests(on_done := Callable()): log_text_edit.text = "" + var started_at := Time.get_ticks_msec() run_test_01() await test_ended -# run_test_02() -# await test_ended + run_test_02() + await test_ended # … var ended_at := Time.get_ticks_msec() Logger.inform("Ran tests for %.2fs" % [0.001 * (ended_at - started_at)]) @@ -165,3 +166,22 @@ func update_monkey(monkey, new_name, on_done: Callable): , ) + +func run_test_02(): + Logger.inform("Running test 02…") + + var pet_api := DemoPetApi.new() + pet_api.bee_port = 8081 + pet_api.find_pets_by_status( + ['available'], + func(result): + prints("Found some pets.") + prints(result) + emit_signal("test_ended") + , + func(error): + printerr("ERROR!") + fail(str(error)) + emit_signal("test_ended") + , + ) From e565add29b93260d535d137ed7b403d3b903cd04 Mon Sep 17 00:00:00 2001 From: Goutte Date: Sat, 22 Oct 2022 07:20:29 +0200 Subject: [PATCH 17/56] feat(gdscript): support collections of models Those are Arrays, not custom collection objects. --- .../main/resources/gdscript/api.handlebars | 21 ++--- .../main/resources/gdscript/model.handlebars | 36 ++++++++ .../gdscript/partials/complex_type.handlebars | 3 + .../gdscript/partials/data_type.handlebars | 1 + .../petstore/gdscript/apis/DemoPetApi.gd | 88 ++----------------- .../petstore/gdscript/apis/DemoStoreApi.gd | 43 +-------- .../petstore/gdscript/apis/DemoUserApi.gd | 55 +----------- .../gdscript/models/DemoApiResponse.gd | 26 ++++++ .../petstore/gdscript/models/DemoCategory.gd | 24 +++++ .../petstore/gdscript/models/DemoOrder.gd | 32 +++++++ .../petstore/gdscript/models/DemoPet.gd | 32 +++++++ .../petstore/gdscript/models/DemoTag.gd | 24 +++++ .../petstore/gdscript/models/DemoUser.gd | 36 ++++++++ 13 files changed, 230 insertions(+), 191 deletions(-) create mode 100644 modules/openapi-generator/src/main/resources/gdscript/partials/complex_type.handlebars diff --git a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars index 1bbd5fc6e6d2..357fee0edbea 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars @@ -199,26 +199,19 @@ func {{operationIdSnakeCase}}( {{/each}} {{/if}} - {{#with returnProperty}} - # Will be used at some point for denormalization - # baseType = "{{{baseType}}}" - # openApiType = "{{{openApiType}}}" - # dataType = "{{{dataType}}}" - # complexType = "{{{complexType}}}" - # isArray = "{{{isArray}}}" - var _bzz_return_type := "{{{complexType}}}" - {{/with}} - self.bee_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) +{{#with returnProperty}} + {{#if isArray}} + bzz_result = {{>partials/complex_type}}.bee_denormalize_multiple(bzz_result) + {{else if isModel}} + bzz_result = {{>partials/complex_type}}.bee_denormalize_single(bzz_result) + {{/if}} +{{/with}} on_success.call(bzz_result) , # ざわ‥ func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) on_failure.call(bzz_error) , # ざわ‥ ) diff --git a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars index c7704038c217..544e0c071573 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars @@ -85,6 +85,42 @@ func bee_normalize() -> Dictionary: {{/each}} return bzz_dictionary + +# Won't work for JSON+LD +{{!-- LEAKING if we specify return -> {{classname}} in func def --}} +static func bee_denormalize_single(from_dict: Dictionary): + var me := new() +{{#each vars}} + if from_dict.has("{{name}}"): + {{#if isModel}} + me.{{name}} = {{>partials/complex_type}}.bee_denormalize_single(from_dict["{{name}}"]) + {{else if isArray}} + {{#if mostInnerItems.isModel}} + me.{{name}} = {{>partials/complex_type}}.bee_denormalize_multiple(from_dict["{{name}}"]) + {{else}} + me.{{name}} = from_dict["{{name}}"] + {{/if}} + {{else}} + me.{{name}} = from_dict["{{name}}"] + {{/if}} +{{/each}} + return me + + +# Won't work for JSON+LD +{{!-- LEAKING if we specify return -> {{classname}} in func def --}} +static func bee_denormalize_multiple(from_array: Array): + var mes := Array() + for element in from_array: + if element is Array: + mes.append(bee_denormalize_multiple(element)) + elif element is Dictionary: + # TODO: perhaps check first if it looks like a match or an intermediate container + mes.append(bee_denormalize_single(element)) + else: + mes.append(element) + return mes + {{!-- UNUSED func bee_normalize_fully() -> Dictionary: return { diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/complex_type.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/complex_type.handlebars new file mode 100644 index 000000000000..fe7ba46ce46d --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/complex_type.handlebars @@ -0,0 +1,3 @@ +{{! Hotfix to ensure our complex types include the "namespace" }} +{{! FIXME: Unregistered helper name 'modelNameSuffix', processing template }} +{{modelNamePrefix}}{{complexType}}{{modelNameSuffix}} \ No newline at end of file diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/data_type.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/data_type.handlebars index 7a98a4b87727..5479dbd5a733 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/partials/data_type.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/data_type.handlebars @@ -1,2 +1,3 @@ +{{! Hotfix to ensure our data types include the "namespace" }} {{#if isModel}}{{modelNamePrefix}}{{dataType}}{{modelNameSuffix}}{{/if~}} {{#unless isModel}}{{dataType}}{{/unless}} \ No newline at end of file diff --git a/samples/client/petstore/gdscript/apis/DemoPetApi.gd b/samples/client/petstore/gdscript/apis/DemoPetApi.gd index a91a35041354..87488abf130b 100644 --- a/samples/client/petstore/gdscript/apis/DemoPetApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoPetApi.gd @@ -55,24 +55,13 @@ func add_pet( var bzz_body = null bzz_body = demoPet - # Will be used at some point for denormalization - # baseType = "Pet" - # openApiType = "Pet" - # dataType = "Pet" - # complexType = "Pet" - # isArray = "false" - var _bzz_return_type := "Pet" - self.bee_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) + bzz_result = DemoPet.bee_denormalize_single(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) on_failure.call(bzz_error) , # ざわ‥ ) @@ -110,17 +99,12 @@ func delete_pet( var bzz_body = null - self.bee_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) on_failure.call(bzz_error) , # ざわ‥ ) @@ -161,24 +145,13 @@ func find_pets_by_status( var bzz_body = null - # Will be used at some point for denormalization - # baseType = "array" - # openApiType = "array" - # dataType = "Array" - # complexType = "Pet" - # isArray = "true" - var _bzz_return_type := "Pet" - self.bee_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) + bzz_result = DemoPet.bee_denormalize_multiple(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) on_failure.call(bzz_error) , # ざわ‥ ) @@ -221,24 +194,13 @@ func find_pets_by_tags( var bzz_body = null - # Will be used at some point for denormalization - # baseType = "array" - # openApiType = "array" - # dataType = "Array" - # complexType = "Pet" - # isArray = "true" - var _bzz_return_type := "Pet" - self.bee_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) + bzz_result = DemoPet.bee_denormalize_multiple(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) on_failure.call(bzz_error) , # ざわ‥ ) @@ -278,24 +240,13 @@ func get_pet_by_id( var bzz_body = null - # Will be used at some point for denormalization - # baseType = "Pet" - # openApiType = "Pet" - # dataType = "Pet" - # complexType = "Pet" - # isArray = "false" - var _bzz_return_type := "Pet" - self.bee_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) + bzz_result = DemoPet.bee_denormalize_single(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) on_failure.call(bzz_error) , # ざわ‥ ) @@ -348,24 +299,13 @@ func update_pet( var bzz_body = null bzz_body = demoPet - # Will be used at some point for denormalization - # baseType = "Pet" - # openApiType = "Pet" - # dataType = "Pet" - # complexType = "Pet" - # isArray = "false" - var _bzz_return_type := "Pet" - self.bee_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) + bzz_result = DemoPet.bee_denormalize_single(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) on_failure.call(bzz_error) , # ざわ‥ ) @@ -425,17 +365,12 @@ func update_pet_with_form( bzz_body["name"] = name bzz_body["status"] = status - self.bee_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) on_failure.call(bzz_error) , # ざわ‥ ) @@ -500,24 +435,13 @@ func upload_file( bzz_body["additionalMetadata"] = additionalMetadata bzz_body["file"] = file - # Will be used at some point for denormalization - # baseType = "ApiResponse" - # openApiType = "ApiResponse" - # dataType = "ApiResponse" - # complexType = "ApiResponse" - # isArray = "false" - var _bzz_return_type := "ApiResponse" - self.bee_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) + bzz_result = DemoApiResponse.bee_denormalize_single(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) on_failure.call(bzz_error) , # ざわ‥ ) diff --git a/samples/client/petstore/gdscript/apis/DemoStoreApi.gd b/samples/client/petstore/gdscript/apis/DemoStoreApi.gd index a36c001afbd4..016dfe86a34a 100644 --- a/samples/client/petstore/gdscript/apis/DemoStoreApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoStoreApi.gd @@ -37,17 +37,12 @@ func delete_order( var bzz_body = null - self.bee_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) on_failure.call(bzz_error) , # ざわ‥ ) @@ -83,24 +78,12 @@ func get_inventory( var bzz_body = null - # Will be used at some point for denormalization - # baseType = "map" - # openApiType = "object" - # dataType = "Dictionary" - # complexType = "integer" - # isArray = "false" - var _bzz_return_type := "integer" - self.bee_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) on_failure.call(bzz_error) , # ざわ‥ ) @@ -153,24 +136,13 @@ func get_order_by_id( var bzz_body = null - # Will be used at some point for denormalization - # baseType = "Order" - # openApiType = "Order" - # dataType = "Order" - # complexType = "Order" - # isArray = "false" - var _bzz_return_type := "Order" - self.bee_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) + bzz_result = DemoOrder.bee_denormalize_single(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) on_failure.call(bzz_error) , # ざわ‥ ) @@ -223,24 +195,13 @@ func place_order( var bzz_body = null bzz_body = demoOrder - # Will be used at some point for denormalization - # baseType = "Order" - # openApiType = "Order" - # dataType = "Order" - # complexType = "Order" - # isArray = "false" - var _bzz_return_type := "Order" - self.bee_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) + bzz_result = DemoOrder.bee_denormalize_single(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) on_failure.call(bzz_error) , # ざわ‥ ) diff --git a/samples/client/petstore/gdscript/apis/DemoUserApi.gd b/samples/client/petstore/gdscript/apis/DemoUserApi.gd index e9e19dc1df56..b31bd3343b5f 100644 --- a/samples/client/petstore/gdscript/apis/DemoUserApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoUserApi.gd @@ -52,17 +52,12 @@ func create_user( var bzz_body = null bzz_body = demoUser - self.bee_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) on_failure.call(bzz_error) , # ざわ‥ ) @@ -110,17 +105,12 @@ func create_users_with_array_input( var bzz_body = null bzz_body = user - self.bee_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) on_failure.call(bzz_error) , # ざわ‥ ) @@ -168,17 +158,12 @@ func create_users_with_list_input( var bzz_body = null bzz_body = user - self.bee_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) on_failure.call(bzz_error) , # ざわ‥ ) @@ -213,17 +198,12 @@ func delete_user( var bzz_body = null - self.bee_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) on_failure.call(bzz_error) , # ざわ‥ ) @@ -261,24 +241,13 @@ func get_user_by_name( var bzz_body = null - # Will be used at some point for denormalization - # baseType = "User" - # openApiType = "User" - # dataType = "User" - # complexType = "User" - # isArray = "false" - var _bzz_return_type := "User" - self.bee_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) + bzz_result = DemoUser.bee_denormalize_single(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) on_failure.call(bzz_error) , # ざわ‥ ) @@ -339,24 +308,12 @@ func login_user( var bzz_body = null - # Will be used at some point for denormalization - # baseType = "string" - # openApiType = "string" - # dataType = "String" - # complexType = "string" - # isArray = "false" - var _bzz_return_type := "string" - self.bee_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) on_failure.call(bzz_error) , # ざわ‥ ) @@ -385,17 +342,12 @@ func logout_user( var bzz_body = null - self.bee_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) on_failure.call(bzz_error) , # ざわ‥ ) @@ -449,17 +401,12 @@ func update_user( var bzz_body = null bzz_body = demoUser - self.bee_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - #print('SUCCESS!') - #print(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): - #printerr("FAILURE!") - #print(bzz_error) on_failure.call(bzz_error) , # ざわ‥ ) diff --git a/samples/client/petstore/gdscript/models/DemoApiResponse.gd b/samples/client/petstore/gdscript/models/DemoApiResponse.gd index 5cdcffc4ad92..a93a1011c9ac 100644 --- a/samples/client/petstore/gdscript/models/DemoApiResponse.gd +++ b/samples/client/petstore/gdscript/models/DemoApiResponse.gd @@ -58,3 +58,29 @@ func bee_normalize() -> Dictionary: bzz_dictionary["message"] = self.message return bzz_dictionary + +# Won't work for JSON+LD +static func bee_denormalize_single(from_dict: Dictionary): + var me := new() + if from_dict.has("code"): + me.code = from_dict["code"] + if from_dict.has("type"): + me.type = from_dict["type"] + if from_dict.has("message"): + me.message = from_dict["message"] + return me + + +# Won't work for JSON+LD +static func bee_denormalize_multiple(from_array: Array): + var mes := Array() + for element in from_array: + if element is Array: + mes.append(bee_denormalize_multiple(element)) + elif element is Dictionary: + # TODO: perhaps check first if it looks like a match or an intermediate container + mes.append(bee_denormalize_single(element)) + else: + mes.append(element) + return mes + diff --git a/samples/client/petstore/gdscript/models/DemoCategory.gd b/samples/client/petstore/gdscript/models/DemoCategory.gd index e2b8e3172787..c8513412d8e7 100644 --- a/samples/client/petstore/gdscript/models/DemoCategory.gd +++ b/samples/client/petstore/gdscript/models/DemoCategory.gd @@ -47,3 +47,27 @@ func bee_normalize() -> Dictionary: bzz_dictionary["name"] = self.name return bzz_dictionary + +# Won't work for JSON+LD +static func bee_denormalize_single(from_dict: Dictionary): + var me := new() + if from_dict.has("id"): + me.id = from_dict["id"] + if from_dict.has("name"): + me.name = from_dict["name"] + return me + + +# Won't work for JSON+LD +static func bee_denormalize_multiple(from_array: Array): + var mes := Array() + for element in from_array: + if element is Array: + mes.append(bee_denormalize_multiple(element)) + elif element is Dictionary: + # TODO: perhaps check first if it looks like a match or an intermediate container + mes.append(bee_denormalize_single(element)) + else: + mes.append(element) + return mes + diff --git a/samples/client/petstore/gdscript/models/DemoOrder.gd b/samples/client/petstore/gdscript/models/DemoOrder.gd index d92fae76bc8a..62c61f4739fd 100644 --- a/samples/client/petstore/gdscript/models/DemoOrder.gd +++ b/samples/client/petstore/gdscript/models/DemoOrder.gd @@ -99,3 +99,35 @@ func bee_normalize() -> Dictionary: bzz_dictionary["complete"] = self.complete return bzz_dictionary + +# Won't work for JSON+LD +static func bee_denormalize_single(from_dict: Dictionary): + var me := new() + if from_dict.has("id"): + me.id = from_dict["id"] + if from_dict.has("petId"): + me.petId = from_dict["petId"] + if from_dict.has("quantity"): + me.quantity = from_dict["quantity"] + if from_dict.has("shipDate"): + me.shipDate = from_dict["shipDate"] + if from_dict.has("status"): + me.status = from_dict["status"] + if from_dict.has("complete"): + me.complete = from_dict["complete"] + return me + + +# Won't work for JSON+LD +static func bee_denormalize_multiple(from_array: Array): + var mes := Array() + for element in from_array: + if element is Array: + mes.append(bee_denormalize_multiple(element)) + elif element is Dictionary: + # TODO: perhaps check first if it looks like a match or an intermediate container + mes.append(bee_denormalize_single(element)) + else: + mes.append(element) + return mes + diff --git a/samples/client/petstore/gdscript/models/DemoPet.gd b/samples/client/petstore/gdscript/models/DemoPet.gd index b1b744638526..35bf0b88b1b4 100644 --- a/samples/client/petstore/gdscript/models/DemoPet.gd +++ b/samples/client/petstore/gdscript/models/DemoPet.gd @@ -106,3 +106,35 @@ func bee_normalize() -> Dictionary: bzz_dictionary["status"] = self.status return bzz_dictionary + +# Won't work for JSON+LD +static func bee_denormalize_single(from_dict: Dictionary): + var me := new() + if from_dict.has("id"): + me.id = from_dict["id"] + if from_dict.has("category"): + me.category = DemoCategory.bee_denormalize_single(from_dict["category"]) + if from_dict.has("name"): + me.name = from_dict["name"] + if from_dict.has("photoUrls"): + me.photoUrls = from_dict["photoUrls"] + if from_dict.has("tags"): + me.tags = DemoTag.bee_denormalize_multiple(from_dict["tags"]) + if from_dict.has("status"): + me.status = from_dict["status"] + return me + + +# Won't work for JSON+LD +static func bee_denormalize_multiple(from_array: Array): + var mes := Array() + for element in from_array: + if element is Array: + mes.append(bee_denormalize_multiple(element)) + elif element is Dictionary: + # TODO: perhaps check first if it looks like a match or an intermediate container + mes.append(bee_denormalize_single(element)) + else: + mes.append(element) + return mes + diff --git a/samples/client/petstore/gdscript/models/DemoTag.gd b/samples/client/petstore/gdscript/models/DemoTag.gd index e4df0c59af38..e0a32f715b27 100644 --- a/samples/client/petstore/gdscript/models/DemoTag.gd +++ b/samples/client/petstore/gdscript/models/DemoTag.gd @@ -47,3 +47,27 @@ func bee_normalize() -> Dictionary: bzz_dictionary["name"] = self.name return bzz_dictionary + +# Won't work for JSON+LD +static func bee_denormalize_single(from_dict: Dictionary): + var me := new() + if from_dict.has("id"): + me.id = from_dict["id"] + if from_dict.has("name"): + me.name = from_dict["name"] + return me + + +# Won't work for JSON+LD +static func bee_denormalize_multiple(from_array: Array): + var mes := Array() + for element in from_array: + if element is Array: + mes.append(bee_denormalize_multiple(element)) + elif element is Dictionary: + # TODO: perhaps check first if it looks like a match or an intermediate container + mes.append(bee_denormalize_single(element)) + else: + mes.append(element) + return mes + diff --git a/samples/client/petstore/gdscript/models/DemoUser.gd b/samples/client/petstore/gdscript/models/DemoUser.gd index b5eda7fc7511..c46125504813 100644 --- a/samples/client/petstore/gdscript/models/DemoUser.gd +++ b/samples/client/petstore/gdscript/models/DemoUser.gd @@ -114,3 +114,39 @@ func bee_normalize() -> Dictionary: bzz_dictionary["userStatus"] = self.userStatus return bzz_dictionary + +# Won't work for JSON+LD +static func bee_denormalize_single(from_dict: Dictionary): + var me := new() + if from_dict.has("id"): + me.id = from_dict["id"] + if from_dict.has("username"): + me.username = from_dict["username"] + if from_dict.has("firstName"): + me.firstName = from_dict["firstName"] + if from_dict.has("lastName"): + me.lastName = from_dict["lastName"] + if from_dict.has("email"): + me.email = from_dict["email"] + if from_dict.has("password"): + me.password = from_dict["password"] + if from_dict.has("phone"): + me.phone = from_dict["phone"] + if from_dict.has("userStatus"): + me.userStatus = from_dict["userStatus"] + return me + + +# Won't work for JSON+LD +static func bee_denormalize_multiple(from_array: Array): + var mes := Array() + for element in from_array: + if element is Array: + mes.append(bee_denormalize_multiple(element)) + elif element is Dictionary: + # TODO: perhaps check first if it looks like a match or an intermediate container + mes.append(bee_denormalize_single(element)) + else: + mes.append(element) + return mes + From afb451a3e4d41d1f25455e53d291e38c45972d2b Mon Sep 17 00:00:00 2001 From: Goutte Date: Sat, 22 Oct 2022 11:43:59 +0200 Subject: [PATCH 18/56] feat(gdscript): configure default host from OAS --- .../main/resources/gdscript/ApiBee.handlebars | 37 +++---- .../main/resources/gdscript/README.handlebars | 70 ++++++++++++- .../main/resources/gdscript/api.handlebars | 39 +++----- .../resources/gdscript/partials/README.md | 3 + samples/client/petstore/gdscript/README.md | 65 ++++++++++++- .../petstore/gdscript/apis/DemoPetApi.gd | 97 +++++++------------ .../petstore/gdscript/apis/DemoStoreApi.gd | 30 +++--- .../petstore/gdscript/apis/DemoUserApi.gd | 71 ++++++-------- .../petstore/gdscript/core/DemoApiBee.gd | 36 +++---- samples/client/petstore/gdscript/demo/main.gd | 5 +- 10 files changed, 265 insertions(+), 188 deletions(-) diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars index cf59a9d0af18..9d260b5549d7 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars @@ -3,7 +3,6 @@ extends RefCounted # Not trivial, though, because that means preloads and absolute paths. class_name {{>partials/api_base_class_name}} - # Base class for all generated API endpoints. # # Every property/method defined here may collide with userland, @@ -11,11 +10,14 @@ class_name {{>partials/api_base_class_name}} # We want to keep the amount of renaming to a minimum, though. # Therefore, we use the bee_ prefix, even if awkward. +# These are constants. +# To set different values at runtime, use the bee_xxxx properties below. +{{!-- const BEE_DEFAULT_HOST := "{{#if servers}}{{servers.0.url}}{{else}}localhost{{/if}}"--}} +const BEE_DEFAULT_HOST := "{{#if host}}{{host}}{{else}}localhost{{/if}}" +const BEE_DEFAULT_PORT_HTTP := 80 +const BEE_DEFAULT_PORT_HTTPS := 443 +const BEE_DEFAULT_POLLING_INTERVAL_MS := 500 # milliseconds -const DEFAULT_HOST := "localhost" -const HTTP_DEFAULT_PORT := 80 -const HTTPS_DEFAULT_PORT := 443 -const POLLING_INTERVAL_MS := 500 # milliseconds const BEE_CONTENT_TYPE_TEXT := "text/plain" const BEE_CONTENT_TYPE_HTML := "text/html" @@ -57,7 +59,7 @@ var bee_client: HTTPClient: # The host to connect to, with or without the scheme. # Eg: "gitea.com", "https://gitea.com" # We configure TLS accordingly to the provided scheme, if any. -var bee_host := DEFAULT_HOST: +var bee_host := BEE_DEFAULT_HOST: set(value): if value.begins_with("https://"): bee_enable_ssl() @@ -70,7 +72,7 @@ var bee_host := DEFAULT_HOST: # Port through which the connection will be established. # Note: changing the host may change the port as well if the scheme was provided, see above. -var bee_port := HTTP_DEFAULT_PORT +var bee_port := BEE_DEFAULT_PORT_HTTP # Headers used as base for all requests made by this instance. @@ -92,6 +94,8 @@ var bee_headers_base := { # Note: the factory, if used, will set up here a shared dictionary across all instances. var bee_headers_override := {} +# Duration of sleep between poll() calls +var bee_polling_interval_ms := BEE_DEFAULT_POLLING_INTERVAL_MS # milliseconds # @private var __bee_ssl_enabled := false @@ -100,12 +104,12 @@ var __bee_verify_host := true # only if ssl enabled func bee_enable_ssl(): self.__bee_ssl_enabled = true - self.bee_port = HTTPS_DEFAULT_PORT + self.bee_port = BEE_DEFAULT_PORT_HTTPS func bee_disable_ssl(): self.__bee_ssl_enabled = false - self.bee_port = HTTP_DEFAULT_PORT + self.bee_port = BEE_DEFAULT_PORT_HTTP func bee_next_loop_iteration(): @@ -153,8 +157,8 @@ func bee_connect_client_if_needed( ): self.bee_client.poll() print("Connecting...") - if POLLING_INTERVAL_MS: - OS.delay_msec(POLLING_INTERVAL_MS) + if self.bee_polling_interval_ms: + OS.delay_msec(self.bee_polling_interval_ms) await bee_next_loop_iteration() if self.bee_client.get_status() != HTTPClient.STATUS_CONNECTED: @@ -310,8 +314,8 @@ func bee_do_request_text( # Keep polling for as long as the request is being processed. self.bee_client.poll() print("Requesting...") - if POLLING_INTERVAL_MS: # yeah yeah, needs work - OS.delay_msec(POLLING_INTERVAL_MS) + if self.bee_polling_interval_ms: + OS.delay_msec(self.bee_polling_interval_ms) await bee_next_loop_iteration() # if OS.has_feature("web") or async: @@ -340,10 +344,9 @@ func bee_do_request_text( self.bee_client.poll() var chunk = self.bee_client.read_response_body_chunk() if chunk.size() == 0: # Got nothing, wait for buffers to fill a bit. - if not false: - OS.delay_usec(POLLING_INTERVAL_MS) - else: - await bee_next_loop_iteration() + if self.bee_polling_interval_ms: + OS.delay_usec(self.bee_polling_interval_ms) + await bee_next_loop_iteration() else: # Yummy data has arrived response_bytes = response_bytes + chunk diff --git a/modules/openapi-generator/src/main/resources/gdscript/README.handlebars b/modules/openapi-generator/src/main/resources/gdscript/README.handlebars index b1ce51b6c189..d67d9158100a 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/README.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/README.handlebars @@ -1,4 +1,4 @@ -# {{{projectName}}} +# {{{openAPI.info.title}}} GDScript Client {{#if appDescriptionWithNewLines}} {{{appDescriptionWithNewLines}}} @@ -6,8 +6,13 @@ This Godot 4 addon is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: +{{#if servers}} +− Servers: +{{#each servers}} + - [{{#if this.description}}{{this.description}}{{else}}{{this.url}}{{/if}}]({{this.url}}) +{{/each}} +{{/if}} - API version: {{appVersion}} -- Package version: {{packageVersion}} {{#unless hideGenerationTimestamp}} - Build date: {{generatedDate}} {{/unless}} @@ -35,3 +40,64 @@ You can now use it anywhere in your code: var ``` + +## Documentation for API Endpoints + +All URIs are relative to *{{basePath}}* + +Class | Method | HTTP request | Description +------------ | ------------- | ------------- | ------------- +{{#with apiInfo}} +{{#each apis}} +{{#with operations}} +{{#each operation}}*{{classname}}* | [**{{operationIdSnakeCase}}**]({{apiDocPath}}{{classname}}.md#{{operationIdSnakeCase}}) | **{{httpMethod}}** {{path}} | {{#if summary}}{{summary}}{{/if}} +{{/each}} +{{/with}} +{{/each}} +{{/with}} + + +## Documentation For Models + +{{#each models}} +{{#with model}} +- [{{{classname}}}]({{modelDocPath}}{{{classname}}}.md) +{{/with}} +{{/each}} + + +## Documentation For Authorization + +{{#unless authMethods}} + All endpoints do not require authorization. +{{/unless}} +{{#each authMethods}} +{{#if @last}} Authentication schemes defined for the API:{{/if}} +## {{{name}}} + +{{#if isApiKey}} +- **Type**: API key +- **API key parameter name**: {{{keyParamName}}} +- **Location**: {{#if isKeyInQuery}}URL query string{{/if}}{{#if isKeyInHeader}}HTTP header{{/if}} +{{/if}} +{{#if isBasic}} +{{#if isBasicBasic}} +- **Type**: HTTP basic authentication +{{/if}} +{{#if isBasicBearer}} +- **Type**: Bearer authentication{{#if bearerFormat}} ({{{bearerFormat}}}){{/if}} +{{/if}} +{{#if isHttpSignature}} +- **Type**: HTTP signature authentication +{{/if}} +{{/if}} +{{#if isOAuth}} +- **Type**: OAuth +- **Flow**: {{{flow}}} +- **Authorization URL**: {{{authorizationUrl}}} +- **Scopes**: {{#unless scopes}}N/A{{/unless}} +{{#each scopes}} - **{{{scope}}}**: {{{description}}} +{{/each}} +{{/if}} + +{{/each}} \ No newline at end of file diff --git a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars index 357fee0edbea..b8733f57e75a 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars @@ -43,13 +43,11 @@ func {{operationIdSnakeCase}}( {{/if}} {{#each allParams}} - {{!-- +{{!-- # Verify required param `{{paramName}}` is set - # → done by the func signature, perhaps we could check against null or empty array anyway? - - {{#if isString}}# STRING {{paramName}}{{/if}} - {{#if isNumeric}}# NUMBER {{paramName}}{{/if}} - --}} + # → done by the (non-nullable) type in func signature, + # perhaps we could check against null or empty array anyway? +--}} {{#if hasValidation}} # Validate param `{{paramName}}` constraints {{#if maxLength}} @@ -130,38 +128,30 @@ func {{operationIdSnakeCase}}( return {{!/if}} {{/if}} - {{/if}} + {{/if}} {{/each}} - # Convert the String HTTP method to a Constant Godot understands var bzz_method := self.bee_convert_http_method("{{httpMethod}}") # Compute the URL path to the API resource var bzz_path := "{{{contextPath}}}{{{path}}}"{{#each pathParams}}.replace("{" + "{{baseName}}" + "}", bee_urlize_path_param({{{paramName}}})){{/each}} -{{!-- - # Allowed media types, from the server's point of view - var bzz_media_types = { - 'produces': [{{#each produces}}'{{{mediaType}}}'{{#unless @last}}, {{/unless}}{{/each}}], - 'consumes': [{{#each consumes}}'{{{mediaType}}}'{{#unless @last}}, {{/unless}}{{/each}}], - } ---}} # Collect the headers var bzz_headers := Dictionary() {{#each headerParams}} bzz_headers["{{baseName}}"] = {{paramName}} {{/each}} {{#if consumes}} - var bzz_server_consumed_mimes := [{{#each consumes}}'{{{mediaType}}}'{{#unless @last}}, {{/unless}}{{/each}}] - var bzz_found_target_mime := false + var bzz_mimes_consumable_by_server := [{{#each consumes}}'{{{mediaType}}}'{{#unless @last}}, {{/unless}}{{/each}}] + var bzz_found_producible_mime := false for bzz_mime in BEE_PRODUCIBLE_CONTENT_TYPES: - if bzz_mime in bzz_server_consumed_mimes: + if bzz_mime in bzz_mimes_consumable_by_server: bzz_headers["Content-Type"] = bzz_mime - bzz_found_target_mime = true + bzz_found_producible_mime = true break - if not bzz_found_target_mime: - # This is a bit strict, perhaps we could just warn and send JSON anyway? + if not bzz_found_producible_mime: + # This is a bit strict, perhaps we could just push a warning and send JSON anyway? var error := {{>partials/api_error_class_name}}.new() error.identifier = "{{operationIdSnakeCase}}.headers.content_type" error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." @@ -169,9 +159,9 @@ func {{operationIdSnakeCase}}( return {{/if}} {{#if produces}} - var bzz_server_produced_mimes := [{{#each produces}}'{{{mediaType}}}'{{#unless @last}}, {{/unless}}{{/each}}] + var bzz_mimes_produced_by_server := [{{#each produces}}'{{{mediaType}}}'{{#unless @last}}, {{/unless}}{{/each}}] for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: - if bzz_mime in bzz_server_produced_mimes: + if bzz_mime in bzz_mimes_produced_by_server: bzz_headers["Accept"] = bzz_mime break {{/if}} @@ -182,9 +172,6 @@ func {{operationIdSnakeCase}}( {{#each queryParams}} bzz_query["{{baseName}}"] = {{paramName}} {{/each}} - {{#each formParams}} - #bzz_query["{{baseName}}"] = {{paramName}} - {{/each}} var bzz_body = null {{#if bodyParams}} diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/README.md b/modules/openapi-generator/src/main/resources/gdscript/partials/README.md index 357f1f179173..b3e65a0ecff0 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/partials/README.md +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/README.md @@ -4,4 +4,7 @@ or use once but provide anyway in order to make template customization easier. For example, if you only want to change the base class of API classes, you may override `api_statement_extends.handlebars` in this directory. +Note that these are probably not registered as actual partials to Handlebars, +so they are _pseuds-partials_ and won't allow recursion. + > _May the fork be with you, always._ diff --git a/samples/client/petstore/gdscript/README.md b/samples/client/petstore/gdscript/README.md index 82396e7b2ca1..01580d36245f 100644 --- a/samples/client/petstore/gdscript/README.md +++ b/samples/client/petstore/gdscript/README.md @@ -1,11 +1,12 @@ -# +# OpenAPI Petstore GDScript Client -This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters. + This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters. This Godot 4 addon is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: +− Servers: + - [http://petstore.swagger.io/v2](http://petstore.swagger.io/v2) - API version: 1.0.0 -- Package version: - Build package: org.openapitools.codegen.languages.GdscriptClientCodegen @@ -27,3 +28,61 @@ You can now use it anywhere in your code: var ``` + +## Documentation for API Endpoints + +All URIs are relative to *http://petstore.swagger.io/v2* + +Class | Method | HTTP request | Description +------------ | ------------- | ------------- | ------------- +*DemoPetApi* | [**add_pet**](DemoPetApi.md#add_pet) | **POST** /pet | Add a new pet to the store +*DemoPetApi* | [**delete_pet**](DemoPetApi.md#delete_pet) | **DELETE** /pet/{petId} | Deletes a pet +*DemoPetApi* | [**find_pets_by_status**](DemoPetApi.md#find_pets_by_status) | **GET** /pet/findByStatus | Finds Pets by status +*DemoPetApi* | [**find_pets_by_tags**](DemoPetApi.md#find_pets_by_tags) | **GET** /pet/findByTags | Finds Pets by tags +*DemoPetApi* | [**get_pet_by_id**](DemoPetApi.md#get_pet_by_id) | **GET** /pet/{petId} | Find pet by ID +*DemoPetApi* | [**update_pet**](DemoPetApi.md#update_pet) | **PUT** /pet | Update an existing pet +*DemoPetApi* | [**update_pet_with_form**](DemoPetApi.md#update_pet_with_form) | **POST** /pet/{petId} | Updates a pet in the store with form data +*DemoPetApi* | [**upload_file**](DemoPetApi.md#upload_file) | **POST** /pet/{petId}/uploadImage | uploads an image +*DemoStoreApi* | [**delete_order**](DemoStoreApi.md#delete_order) | **DELETE** /store/order/{orderId} | Delete purchase order by ID +*DemoStoreApi* | [**get_inventory**](DemoStoreApi.md#get_inventory) | **GET** /store/inventory | Returns pet inventories by status +*DemoStoreApi* | [**get_order_by_id**](DemoStoreApi.md#get_order_by_id) | **GET** /store/order/{orderId} | Find purchase order by ID +*DemoStoreApi* | [**place_order**](DemoStoreApi.md#place_order) | **POST** /store/order | Place an order for a pet +*DemoUserApi* | [**create_user**](DemoUserApi.md#create_user) | **POST** /user | Create user +*DemoUserApi* | [**create_users_with_array_input**](DemoUserApi.md#create_users_with_array_input) | **POST** /user/createWithArray | Creates list of users with given input array +*DemoUserApi* | [**create_users_with_list_input**](DemoUserApi.md#create_users_with_list_input) | **POST** /user/createWithList | Creates list of users with given input array +*DemoUserApi* | [**delete_user**](DemoUserApi.md#delete_user) | **DELETE** /user/{username} | Delete user +*DemoUserApi* | [**get_user_by_name**](DemoUserApi.md#get_user_by_name) | **GET** /user/{username} | Get user by user name +*DemoUserApi* | [**login_user**](DemoUserApi.md#login_user) | **GET** /user/login | Logs user into the system +*DemoUserApi* | [**logout_user**](DemoUserApi.md#logout_user) | **GET** /user/logout | Logs out current logged in user session +*DemoUserApi* | [**update_user**](DemoUserApi.md#update_user) | **PUT** /user/{username} | Updated user + + +## Documentation For Models + +- [DemoApiResponse](DemoApiResponse.md) +- [DemoCategory](DemoCategory.md) +- [DemoOrder](DemoOrder.md) +- [DemoPet](DemoPet.md) +- [DemoTag](DemoTag.md) +- [DemoUser](DemoUser.md) + + +## Documentation For Authorization + + +## api_key + +- **Type**: API key +- **API key parameter name**: api_key +- **Location**: HTTP header + + Authentication schemes defined for the API: +## petstore_auth + +- **Type**: OAuth +- **Flow**: implicit +- **Authorization URL**: http://petstore.swagger.io/api/oauth/dialog +- **Scopes**: + - **write:pets**: modify pets in your account + - **read:pets**: read your pets + diff --git a/samples/client/petstore/gdscript/apis/DemoPetApi.gd b/samples/client/petstore/gdscript/apis/DemoPetApi.gd index 87488abf130b..c54aa7d1a7ff 100644 --- a/samples/client/petstore/gdscript/apis/DemoPetApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoPetApi.gd @@ -18,8 +18,6 @@ func add_pet( ): # CollectionFormat: NO - - # Convert the String HTTP method to a Constant Godot understands var bzz_method := self.bee_convert_http_method("POST") @@ -28,23 +26,23 @@ func add_pet( # Collect the headers var bzz_headers := Dictionary() - var bzz_server_consumed_mimes := ['application/json', 'application/xml'] - var bzz_found_target_mime := false + var bzz_mimes_consumable_by_server := ['application/json', 'application/xml'] + var bzz_found_producible_mime := false for bzz_mime in BEE_PRODUCIBLE_CONTENT_TYPES: - if bzz_mime in bzz_server_consumed_mimes: + if bzz_mime in bzz_mimes_consumable_by_server: bzz_headers["Content-Type"] = bzz_mime - bzz_found_target_mime = true + bzz_found_producible_mime = true break - if not bzz_found_target_mime: - # This is a bit strict, perhaps we could just warn and send JSON anyway? + if not bzz_found_producible_mime: + # This is a bit strict, perhaps we could just push a warning and send JSON anyway? var error := DemoApiError.new() error.identifier = "add_pet.headers.content_type" error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." on_failure.call(error) return - var bzz_server_produced_mimes := ['application/xml', 'application/json'] + var bzz_mimes_produced_by_server := ['application/xml', 'application/json'] for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: - if bzz_mime in bzz_server_produced_mimes: + if bzz_mime in bzz_mimes_produced_by_server: bzz_headers["Accept"] = bzz_mime break @@ -80,9 +78,6 @@ func delete_pet( ): # CollectionFormat: NO - - - # Convert the String HTTP method to a Constant Godot understands var bzz_method := self.bee_convert_http_method("DELETE") @@ -122,8 +117,6 @@ func find_pets_by_status( ): # CollectionFormat: NO - - # Convert the String HTTP method to a Constant Godot understands var bzz_method := self.bee_convert_http_method("GET") @@ -132,9 +125,9 @@ func find_pets_by_status( # Collect the headers var bzz_headers := Dictionary() - var bzz_server_produced_mimes := ['application/xml', 'application/json'] + var bzz_mimes_produced_by_server := ['application/xml', 'application/json'] for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: - if bzz_mime in bzz_server_produced_mimes: + if bzz_mime in bzz_mimes_produced_by_server: bzz_headers["Accept"] = bzz_mime break @@ -171,8 +164,6 @@ func find_pets_by_tags( # CollectionFormat: NO push_warning("Usage of `find_pets_by_tags()` is deprecated.") - - # Convert the String HTTP method to a Constant Godot understands var bzz_method := self.bee_convert_http_method("GET") @@ -181,9 +172,9 @@ func find_pets_by_tags( # Collect the headers var bzz_headers := Dictionary() - var bzz_server_produced_mimes := ['application/xml', 'application/json'] + var bzz_mimes_produced_by_server := ['application/xml', 'application/json'] for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: - if bzz_mime in bzz_server_produced_mimes: + if bzz_mime in bzz_mimes_produced_by_server: bzz_headers["Accept"] = bzz_mime break @@ -218,8 +209,6 @@ func get_pet_by_id( ): # CollectionFormat: NO - - # Convert the String HTTP method to a Constant Godot understands var bzz_method := self.bee_convert_http_method("GET") @@ -228,9 +217,9 @@ func get_pet_by_id( # Collect the headers var bzz_headers := Dictionary() - var bzz_server_produced_mimes := ['application/xml', 'application/json'] + var bzz_mimes_produced_by_server := ['application/xml', 'application/json'] for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: - if bzz_mime in bzz_server_produced_mimes: + if bzz_mime in bzz_mimes_produced_by_server: bzz_headers["Accept"] = bzz_mime break @@ -262,8 +251,6 @@ func update_pet( ): # CollectionFormat: NO - - # Convert the String HTTP method to a Constant Godot understands var bzz_method := self.bee_convert_http_method("PUT") @@ -272,23 +259,23 @@ func update_pet( # Collect the headers var bzz_headers := Dictionary() - var bzz_server_consumed_mimes := ['application/json', 'application/xml'] - var bzz_found_target_mime := false + var bzz_mimes_consumable_by_server := ['application/json', 'application/xml'] + var bzz_found_producible_mime := false for bzz_mime in BEE_PRODUCIBLE_CONTENT_TYPES: - if bzz_mime in bzz_server_consumed_mimes: + if bzz_mime in bzz_mimes_consumable_by_server: bzz_headers["Content-Type"] = bzz_mime - bzz_found_target_mime = true + bzz_found_producible_mime = true break - if not bzz_found_target_mime: - # This is a bit strict, perhaps we could just warn and send JSON anyway? + if not bzz_found_producible_mime: + # This is a bit strict, perhaps we could just push a warning and send JSON anyway? var error := DemoApiError.new() error.identifier = "update_pet.headers.content_type" error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." on_failure.call(error) return - var bzz_server_produced_mimes := ['application/xml', 'application/json'] + var bzz_mimes_produced_by_server := ['application/xml', 'application/json'] for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: - if bzz_mime in bzz_server_produced_mimes: + if bzz_mime in bzz_mimes_produced_by_server: bzz_headers["Accept"] = bzz_mime break @@ -327,10 +314,6 @@ func update_pet_with_form( ): # CollectionFormat: NO - - - - # Convert the String HTTP method to a Constant Godot understands var bzz_method := self.bee_convert_http_method("POST") @@ -339,15 +322,15 @@ func update_pet_with_form( # Collect the headers var bzz_headers := Dictionary() - var bzz_server_consumed_mimes := ['application/x-www-form-urlencoded'] - var bzz_found_target_mime := false + var bzz_mimes_consumable_by_server := ['application/x-www-form-urlencoded'] + var bzz_found_producible_mime := false for bzz_mime in BEE_PRODUCIBLE_CONTENT_TYPES: - if bzz_mime in bzz_server_consumed_mimes: + if bzz_mime in bzz_mimes_consumable_by_server: bzz_headers["Content-Type"] = bzz_mime - bzz_found_target_mime = true + bzz_found_producible_mime = true break - if not bzz_found_target_mime: - # This is a bit strict, perhaps we could just warn and send JSON anyway? + if not bzz_found_producible_mime: + # This is a bit strict, perhaps we could just push a warning and send JSON anyway? var error := DemoApiError.new() error.identifier = "update_pet_with_form.headers.content_type" error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." @@ -357,8 +340,6 @@ func update_pet_with_form( # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - #bzz_query["name"] = name - #bzz_query["status"] = status var bzz_body = null bzz_body = Dictionary() @@ -392,10 +373,6 @@ func upload_file( ): # CollectionFormat: NO - - - - # Convert the String HTTP method to a Constant Godot understands var bzz_method := self.bee_convert_http_method("POST") @@ -404,31 +381,29 @@ func upload_file( # Collect the headers var bzz_headers := Dictionary() - var bzz_server_consumed_mimes := ['multipart/form-data'] - var bzz_found_target_mime := false + var bzz_mimes_consumable_by_server := ['multipart/form-data'] + var bzz_found_producible_mime := false for bzz_mime in BEE_PRODUCIBLE_CONTENT_TYPES: - if bzz_mime in bzz_server_consumed_mimes: + if bzz_mime in bzz_mimes_consumable_by_server: bzz_headers["Content-Type"] = bzz_mime - bzz_found_target_mime = true + bzz_found_producible_mime = true break - if not bzz_found_target_mime: - # This is a bit strict, perhaps we could just warn and send JSON anyway? + if not bzz_found_producible_mime: + # This is a bit strict, perhaps we could just push a warning and send JSON anyway? var error := DemoApiError.new() error.identifier = "upload_file.headers.content_type" error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." on_failure.call(error) return - var bzz_server_produced_mimes := ['application/json'] + var bzz_mimes_produced_by_server := ['application/json'] for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: - if bzz_mime in bzz_server_produced_mimes: + if bzz_mime in bzz_mimes_produced_by_server: bzz_headers["Accept"] = bzz_mime break # Collect the query parameters # Note: we do not support multiple values for a single param (for now), nor arrays var bzz_query := Dictionary() - #bzz_query["additionalMetadata"] = additionalMetadata - #bzz_query["file"] = file var bzz_body = null bzz_body = Dictionary() diff --git a/samples/client/petstore/gdscript/apis/DemoStoreApi.gd b/samples/client/petstore/gdscript/apis/DemoStoreApi.gd index 016dfe86a34a..2ba352a4d479 100644 --- a/samples/client/petstore/gdscript/apis/DemoStoreApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoStoreApi.gd @@ -20,8 +20,6 @@ func delete_order( ): # CollectionFormat: NO - - # Convert the String HTTP method to a Constant Godot understands var bzz_method := self.bee_convert_http_method("DELETE") @@ -57,7 +55,6 @@ func get_inventory( ): # CollectionFormat: NO - # Convert the String HTTP method to a Constant Godot understands var bzz_method := self.bee_convert_http_method("GET") @@ -66,9 +63,9 @@ func get_inventory( # Collect the headers var bzz_headers := Dictionary() - var bzz_server_produced_mimes := ['application/json'] + var bzz_mimes_produced_by_server := ['application/json'] for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: - if bzz_mime in bzz_server_produced_mimes: + if bzz_mime in bzz_mimes_produced_by_server: bzz_headers["Accept"] = bzz_mime break @@ -115,7 +112,6 @@ func get_order_by_id( on_failure.call(error) return - # Convert the String HTTP method to a Constant Godot understands var bzz_method := self.bee_convert_http_method("GET") @@ -124,9 +120,9 @@ func get_order_by_id( # Collect the headers var bzz_headers := Dictionary() - var bzz_server_produced_mimes := ['application/xml', 'application/json'] + var bzz_mimes_produced_by_server := ['application/xml', 'application/json'] for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: - if bzz_mime in bzz_server_produced_mimes: + if bzz_mime in bzz_mimes_produced_by_server: bzz_headers["Accept"] = bzz_mime break @@ -158,8 +154,6 @@ func place_order( ): # CollectionFormat: NO - - # Convert the String HTTP method to a Constant Godot understands var bzz_method := self.bee_convert_http_method("POST") @@ -168,23 +162,23 @@ func place_order( # Collect the headers var bzz_headers := Dictionary() - var bzz_server_consumed_mimes := ['application/json'] - var bzz_found_target_mime := false + var bzz_mimes_consumable_by_server := ['application/json'] + var bzz_found_producible_mime := false for bzz_mime in BEE_PRODUCIBLE_CONTENT_TYPES: - if bzz_mime in bzz_server_consumed_mimes: + if bzz_mime in bzz_mimes_consumable_by_server: bzz_headers["Content-Type"] = bzz_mime - bzz_found_target_mime = true + bzz_found_producible_mime = true break - if not bzz_found_target_mime: - # This is a bit strict, perhaps we could just warn and send JSON anyway? + if not bzz_found_producible_mime: + # This is a bit strict, perhaps we could just push a warning and send JSON anyway? var error := DemoApiError.new() error.identifier = "place_order.headers.content_type" error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." on_failure.call(error) return - var bzz_server_produced_mimes := ['application/xml', 'application/json'] + var bzz_mimes_produced_by_server := ['application/xml', 'application/json'] for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: - if bzz_mime in bzz_server_produced_mimes: + if bzz_mime in bzz_mimes_produced_by_server: bzz_headers["Accept"] = bzz_mime break diff --git a/samples/client/petstore/gdscript/apis/DemoUserApi.gd b/samples/client/petstore/gdscript/apis/DemoUserApi.gd index b31bd3343b5f..93e66589676e 100644 --- a/samples/client/petstore/gdscript/apis/DemoUserApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoUserApi.gd @@ -20,8 +20,6 @@ func create_user( ): # CollectionFormat: NO - - # Convert the String HTTP method to a Constant Godot understands var bzz_method := self.bee_convert_http_method("POST") @@ -30,15 +28,15 @@ func create_user( # Collect the headers var bzz_headers := Dictionary() - var bzz_server_consumed_mimes := ['application/json'] - var bzz_found_target_mime := false + var bzz_mimes_consumable_by_server := ['application/json'] + var bzz_found_producible_mime := false for bzz_mime in BEE_PRODUCIBLE_CONTENT_TYPES: - if bzz_mime in bzz_server_consumed_mimes: + if bzz_mime in bzz_mimes_consumable_by_server: bzz_headers["Content-Type"] = bzz_mime - bzz_found_target_mime = true + bzz_found_producible_mime = true break - if not bzz_found_target_mime: - # This is a bit strict, perhaps we could just warn and send JSON anyway? + if not bzz_found_producible_mime: + # This is a bit strict, perhaps we could just push a warning and send JSON anyway? var error := DemoApiError.new() error.identifier = "create_user.headers.content_type" error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." @@ -73,8 +71,6 @@ func create_users_with_array_input( ): # CollectionFormat: NO - - # Convert the String HTTP method to a Constant Godot understands var bzz_method := self.bee_convert_http_method("POST") @@ -83,15 +79,15 @@ func create_users_with_array_input( # Collect the headers var bzz_headers := Dictionary() - var bzz_server_consumed_mimes := ['application/json'] - var bzz_found_target_mime := false + var bzz_mimes_consumable_by_server := ['application/json'] + var bzz_found_producible_mime := false for bzz_mime in BEE_PRODUCIBLE_CONTENT_TYPES: - if bzz_mime in bzz_server_consumed_mimes: + if bzz_mime in bzz_mimes_consumable_by_server: bzz_headers["Content-Type"] = bzz_mime - bzz_found_target_mime = true + bzz_found_producible_mime = true break - if not bzz_found_target_mime: - # This is a bit strict, perhaps we could just warn and send JSON anyway? + if not bzz_found_producible_mime: + # This is a bit strict, perhaps we could just push a warning and send JSON anyway? var error := DemoApiError.new() error.identifier = "create_users_with_array_input.headers.content_type" error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." @@ -126,8 +122,6 @@ func create_users_with_list_input( ): # CollectionFormat: NO - - # Convert the String HTTP method to a Constant Godot understands var bzz_method := self.bee_convert_http_method("POST") @@ -136,15 +130,15 @@ func create_users_with_list_input( # Collect the headers var bzz_headers := Dictionary() - var bzz_server_consumed_mimes := ['application/json'] - var bzz_found_target_mime := false + var bzz_mimes_consumable_by_server := ['application/json'] + var bzz_found_producible_mime := false for bzz_mime in BEE_PRODUCIBLE_CONTENT_TYPES: - if bzz_mime in bzz_server_consumed_mimes: + if bzz_mime in bzz_mimes_consumable_by_server: bzz_headers["Content-Type"] = bzz_mime - bzz_found_target_mime = true + bzz_found_producible_mime = true break - if not bzz_found_target_mime: - # This is a bit strict, perhaps we could just warn and send JSON anyway? + if not bzz_found_producible_mime: + # This is a bit strict, perhaps we could just push a warning and send JSON anyway? var error := DemoApiError.new() error.identifier = "create_users_with_list_input.headers.content_type" error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." @@ -181,8 +175,6 @@ func delete_user( ): # CollectionFormat: NO - - # Convert the String HTTP method to a Constant Godot understands var bzz_method := self.bee_convert_http_method("DELETE") @@ -219,8 +211,6 @@ func get_user_by_name( ): # CollectionFormat: NO - - # Convert the String HTTP method to a Constant Godot understands var bzz_method := self.bee_convert_http_method("GET") @@ -229,9 +219,9 @@ func get_user_by_name( # Collect the headers var bzz_headers := Dictionary() - var bzz_server_produced_mimes := ['application/xml', 'application/json'] + var bzz_mimes_produced_by_server := ['application/xml', 'application/json'] for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: - if bzz_mime in bzz_server_produced_mimes: + if bzz_mime in bzz_mimes_produced_by_server: bzz_headers["Accept"] = bzz_mime break @@ -285,7 +275,6 @@ func login_user( on_failure.call(error) return - # Convert the String HTTP method to a Constant Godot understands var bzz_method := self.bee_convert_http_method("GET") @@ -294,9 +283,9 @@ func login_user( # Collect the headers var bzz_headers := Dictionary() - var bzz_server_produced_mimes := ['application/xml', 'application/json'] + var bzz_mimes_produced_by_server := ['application/xml', 'application/json'] for bzz_mime in BEE_CONSUMABLE_CONTENT_TYPES: - if bzz_mime in bzz_server_produced_mimes: + if bzz_mime in bzz_mimes_produced_by_server: bzz_headers["Accept"] = bzz_mime break @@ -326,7 +315,6 @@ func logout_user( ): # CollectionFormat: NO - # Convert the String HTTP method to a Constant Godot understands var bzz_method := self.bee_convert_http_method("GET") @@ -368,9 +356,6 @@ func update_user( ): # CollectionFormat: NO - - - # Convert the String HTTP method to a Constant Godot understands var bzz_method := self.bee_convert_http_method("PUT") @@ -379,15 +364,15 @@ func update_user( # Collect the headers var bzz_headers := Dictionary() - var bzz_server_consumed_mimes := ['application/json'] - var bzz_found_target_mime := false + var bzz_mimes_consumable_by_server := ['application/json'] + var bzz_found_producible_mime := false for bzz_mime in BEE_PRODUCIBLE_CONTENT_TYPES: - if bzz_mime in bzz_server_consumed_mimes: + if bzz_mime in bzz_mimes_consumable_by_server: bzz_headers["Content-Type"] = bzz_mime - bzz_found_target_mime = true + bzz_found_producible_mime = true break - if not bzz_found_target_mime: - # This is a bit strict, perhaps we could just warn and send JSON anyway? + if not bzz_found_producible_mime: + # This is a bit strict, perhaps we could just push a warning and send JSON anyway? var error := DemoApiError.new() error.identifier = "update_user.headers.content_type" error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." diff --git a/samples/client/petstore/gdscript/core/DemoApiBee.gd b/samples/client/petstore/gdscript/core/DemoApiBee.gd index 90dae7c9b873..9d6beb58a475 100644 --- a/samples/client/petstore/gdscript/core/DemoApiBee.gd +++ b/samples/client/petstore/gdscript/core/DemoApiBee.gd @@ -3,7 +3,6 @@ extends RefCounted # Not trivial, though, because that means preloads and absolute paths. class_name DemoApiBee - # Base class for all generated API endpoints. # # Every property/method defined here may collide with userland, @@ -11,11 +10,13 @@ class_name DemoApiBee # We want to keep the amount of renaming to a minimum, though. # Therefore, we use the bee_ prefix, even if awkward. +# These are constants. +# To set different values at runtime, use the bee_xxxx properties below. +const BEE_DEFAULT_HOST := "petstore.swagger.io" +const BEE_DEFAULT_PORT_HTTP := 80 +const BEE_DEFAULT_PORT_HTTPS := 443 +const BEE_DEFAULT_POLLING_INTERVAL_MS := 500 # milliseconds -const DEFAULT_HOST := "localhost" -const HTTP_DEFAULT_PORT := 80 -const HTTPS_DEFAULT_PORT := 443 -const POLLING_INTERVAL_MS := 500 # milliseconds const BEE_CONTENT_TYPE_TEXT := "text/plain" const BEE_CONTENT_TYPE_HTML := "text/html" @@ -57,7 +58,7 @@ var bee_client: HTTPClient: # The host to connect to, with or without the scheme. # Eg: "gitea.com", "https://gitea.com" # We configure TLS accordingly to the provided scheme, if any. -var bee_host := DEFAULT_HOST: +var bee_host := BEE_DEFAULT_HOST: set(value): if value.begins_with("https://"): bee_enable_ssl() @@ -70,7 +71,7 @@ var bee_host := DEFAULT_HOST: # Port through which the connection will be established. # Note: changing the host may change the port as well if the scheme was provided, see above. -var bee_port := HTTP_DEFAULT_PORT +var bee_port := BEE_DEFAULT_PORT_HTTP # Headers used as base for all requests made by this instance. @@ -92,6 +93,8 @@ var bee_headers_base := { # Note: the factory, if used, will set up here a shared dictionary across all instances. var bee_headers_override := {} +# Duration of sleep between poll() calls +var bee_polling_interval_ms := BEE_DEFAULT_POLLING_INTERVAL_MS # milliseconds # @private var __bee_ssl_enabled := false @@ -100,12 +103,12 @@ var __bee_verify_host := true # only if ssl enabled func bee_enable_ssl(): self.__bee_ssl_enabled = true - self.bee_port = HTTPS_DEFAULT_PORT + self.bee_port = BEE_DEFAULT_PORT_HTTPS func bee_disable_ssl(): self.__bee_ssl_enabled = false - self.bee_port = HTTP_DEFAULT_PORT + self.bee_port = BEE_DEFAULT_PORT_HTTP func bee_next_loop_iteration(): @@ -153,8 +156,8 @@ func bee_connect_client_if_needed( ): self.bee_client.poll() print("Connecting...") - if POLLING_INTERVAL_MS: - OS.delay_msec(POLLING_INTERVAL_MS) + if self.bee_polling_interval_ms: + OS.delay_msec(self.bee_polling_interval_ms) await bee_next_loop_iteration() if self.bee_client.get_status() != HTTPClient.STATUS_CONNECTED: @@ -309,8 +312,8 @@ func bee_do_request_text( # Keep polling for as long as the request is being processed. self.bee_client.poll() print("Requesting...") - if POLLING_INTERVAL_MS: # yeah yeah, needs work - OS.delay_msec(POLLING_INTERVAL_MS) + if self.bee_polling_interval_ms: + OS.delay_msec(self.bee_polling_interval_ms) await bee_next_loop_iteration() # if OS.has_feature("web") or async: @@ -339,10 +342,9 @@ func bee_do_request_text( self.bee_client.poll() var chunk = self.bee_client.read_response_body_chunk() if chunk.size() == 0: # Got nothing, wait for buffers to fill a bit. - if not false: - OS.delay_usec(POLLING_INTERVAL_MS) - else: - await bee_next_loop_iteration() + if self.bee_polling_interval_ms: + OS.delay_usec(self.bee_polling_interval_ms) + await bee_next_loop_iteration() else: # Yummy data has arrived response_bytes = response_bytes + chunk diff --git a/samples/client/petstore/gdscript/demo/main.gd b/samples/client/petstore/gdscript/demo/main.gd index c4e60c1690b2..b2a140680d2a 100644 --- a/samples/client/petstore/gdscript/demo/main.gd +++ b/samples/client/petstore/gdscript/demo/main.gd @@ -58,6 +58,10 @@ func run_all_tests(on_done := Callable()): # … var ended_at := Time.get_ticks_msec() Logger.inform("Ran tests for %.2fs" % [0.001 * (ended_at - started_at)]) + if failed: + print("FAILURE") + else: + print("SUCCESS") on_done.call() @@ -105,7 +109,6 @@ func authenticate(username: String, password: String, on_done: Callable): on_done.call() , func(error): - prints("NO SNEAKERS", error) fail(str(error)) emit_signal("test_ended") , From 5ae755d26a12c5a5cd43d58d168e8185f29d036f Mon Sep 17 00:00:00 2001 From: Goutte Date: Sun, 23 Oct 2022 01:17:26 +0200 Subject: [PATCH 19/56] feat(gdscript): some documentation and better config We don't need no factories nor singletons ; config is enough. --- .../languages/GdscriptClientCodegen.java | 23 +- .../main/resources/gdscript/ApiBee.handlebars | 104 ++--- .../resources/gdscript/ApiConfig.handlebars | 80 ++++ .../main/resources/gdscript/api.handlebars | 6 +- .../resources/gdscript/api_doc.handlebars | 64 +++ .../gdscript/api_doc_example.handlebars | 44 ++ .../partials/api_config_class_name.handlebars | 1 + .../gdscript/.openapi-generator/FILES | 4 + samples/client/petstore/gdscript/README.md | 52 +-- .../petstore/gdscript/apis/DemoPetApi.gd | 16 +- .../petstore/gdscript/apis/DemoPetApi.md | 399 ++++++++++++++++++ .../petstore/gdscript/apis/DemoStoreApi.gd | 8 +- .../petstore/gdscript/apis/DemoStoreApi.md | 196 +++++++++ .../petstore/gdscript/apis/DemoUserApi.gd | 16 +- .../petstore/gdscript/apis/DemoUserApi.md | 385 +++++++++++++++++ .../petstore/gdscript/core/DemoApiBee.gd | 103 ++--- .../petstore/gdscript/core/DemoApiConfig.gd | 69 +++ samples/client/petstore/gdscript/demo/main.gd | 25 +- .../client/petstore/gdscript/project.godot | 6 + 19 files changed, 1388 insertions(+), 213 deletions(-) create mode 100644 modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars create mode 100644 modules/openapi-generator/src/main/resources/gdscript/api_doc.handlebars create mode 100644 modules/openapi-generator/src/main/resources/gdscript/api_doc_example.handlebars create mode 100644 modules/openapi-generator/src/main/resources/gdscript/partials/api_config_class_name.handlebars create mode 100644 samples/client/petstore/gdscript/apis/DemoPetApi.md create mode 100644 samples/client/petstore/gdscript/apis/DemoStoreApi.md create mode 100644 samples/client/petstore/gdscript/apis/DemoUserApi.md create mode 100644 samples/client/petstore/gdscript/core/DemoApiConfig.gd diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java index aace1649e0e5..67776feb9008 100644 --- a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java +++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java @@ -33,6 +33,10 @@ public class GdscriptClientCodegen extends DefaultCodegen implements CodegenConf protected String coreNamePrefix = ""; protected String coreNameSuffix = ""; + // We're putting the doc files right next their target code file + protected String apiDocPath = "apis/"; + protected String modelDocPath = "models/"; + public void setCoreNamePrefix(String prefix) { coreNamePrefix = prefix; } @@ -74,7 +78,8 @@ public GdscriptClientCodegen() { modelTemplateFiles.put("model.handlebars", ".gd"); apiTemplateFiles.put("api.handlebars", ".gd"); - // more supported files are defined in processOpts() + apiDocTemplateFiles.put("api_doc.handlebars", ".md"); + // more supported files are defined in processOpts() (for coreNamePrefix) setReservedWordsLowerCase(getReservedWords()); @@ -123,6 +128,10 @@ public String defaultTemplatingEngine() { public void processAdditionalProperties() { + + additionalProperties.put("apiDocPath", apiDocPath); + additionalProperties.put("modelDocPath", modelDocPath); + if (additionalProperties.containsKey(CORE_NAME_PREFIX)) { setCoreNamePrefix((String) additionalProperties.get(CORE_NAME_PREFIX)); } else { @@ -142,6 +151,7 @@ public void processOpts() { processAdditionalProperties(); supportingFiles.add(new SupportingFile("ApiBee.handlebars", "core", toCoreFilename("ApiBee") + ".gd")); supportingFiles.add(new SupportingFile("ApiError.handlebars", "core", toCoreFilename("ApiError") + ".gd")); + supportingFiles.add(new SupportingFile("ApiConfig.handlebars", "core", toCoreFilename("ApiConfig") + ".gd")); supportingFiles.add(new SupportingFile("README.handlebars", "", "README.md")); // Ensure we're using the appropriate template engine, and configure it while we're at it. @@ -187,6 +197,17 @@ public String toCoreFilename(String name) { return camelize(getCoreNamePrefix() + '_' + name + '_' + getCoreNameSuffix()); } + @Override + public String apiDocFileFolder() { + return (outputFolder + File.separator + apiDocPath); + } + + @Override + public String modelDocFileFolder() { + return (outputFolder + File.separator + modelDocPath); + } + + // When example is "null" (with quotes), mustache's {{#example}} triggers // Not sure why this happens on {{#example}} but not {{#description}} diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars index 9d260b5549d7..1641b6e8b20d 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars @@ -1,6 +1,4 @@ extends RefCounted -# We class_name it for now (KISS), but eventually I'd like to remove this. -# Not trivial, though, because that means preloads and absolute paths. class_name {{>partials/api_base_class_name}} # Base class for all generated API endpoints. @@ -10,14 +8,6 @@ class_name {{>partials/api_base_class_name}} # We want to keep the amount of renaming to a minimum, though. # Therefore, we use the bee_ prefix, even if awkward. -# These are constants. -# To set different values at runtime, use the bee_xxxx properties below. -{{!-- const BEE_DEFAULT_HOST := "{{#if servers}}{{servers.0.url}}{{else}}localhost{{/if}}"--}} -const BEE_DEFAULT_HOST := "{{#if host}}{{host}}{{else}}localhost{{/if}}" -const BEE_DEFAULT_PORT_HTTP := 80 -const BEE_DEFAULT_PORT_HTTPS := 443 -const BEE_DEFAULT_POLLING_INTERVAL_MS := 500 # milliseconds - const BEE_CONTENT_TYPE_TEXT := "text/plain" const BEE_CONTENT_TYPE_HTML := "text/html" @@ -41,12 +31,14 @@ const BEE_CONSUMABLE_CONTENT_TYPES := [ BEE_CONTENT_TYPE_JSON, ] -# We'll probably only use this for logging + +# We'll probably only use this for logging. +# Each Api child can define its own, and it should be similar to class_name. var bee_name := "ApiBee" -# Godot's HTTP Client we are using. -# If none was set (by you), we'll make one. +# Godot's HTTP Client this Api instance is using. +# If none was set (by you), we'll lazily make one. var bee_client: HTTPClient: set(value): bee_client = value @@ -56,60 +48,16 @@ var bee_client: HTTPClient: return bee_client -# The host to connect to, with or without the scheme. -# Eg: "gitea.com", "https://gitea.com" -# We configure TLS accordingly to the provided scheme, if any. -var bee_host := BEE_DEFAULT_HOST: +# General configuration that can be shared across Api instances for convenience. +# If no configuration was provided, we'll lazily make one with defaults as best we can. +var bee_config: {{>partials/api_config_class_name}}: set(value): - if value.begins_with("https://"): - bee_enable_ssl() - value = value.substr(8) # "https://".length() == 8 - elif value.begins_with("http://"): - bee_disable_ssl() - value = value.substr(7) # "http://".length() == 7 - bee_host = value - - -# Port through which the connection will be established. -# Note: changing the host may change the port as well if the scheme was provided, see above. -var bee_port := BEE_DEFAULT_PORT_HTTP - - -# Headers used as base for all requests made by this instance. -# Those are the lowest priority headers, and are merged with custom headers provided in the bee_request() method call -# to compute the final, actually sent headers. -# Note: the factory, if used, will set up here a shared dictionary across all instances. -var bee_headers_base := { - # Stigmergy: everyone does what is left to do (like ants do) - "User-Agent": "Stigmergiac/1.0 (Godot)", - # For my mental health's sake, only JSON is supported for now - "Accept": "application/json", - "Content-Type": "application/json", - # FIXME: Remove demo cheat code - "api_key": "special-key", -} - - -# High-priority headers, they will always override other headers coming from the base above or the method call. -# Note: the factory, if used, will set up here a shared dictionary across all instances. -var bee_headers_override := {} - -# Duration of sleep between poll() calls -var bee_polling_interval_ms := BEE_DEFAULT_POLLING_INTERVAL_MS # milliseconds - -# @private -var __bee_ssl_enabled := false -var __bee_verify_host := true # only if ssl enabled - - -func bee_enable_ssl(): - self.__bee_ssl_enabled = true - self.bee_port = BEE_DEFAULT_PORT_HTTPS - - -func bee_disable_ssl(): - self.__bee_ssl_enabled = false - self.bee_port = BEE_DEFAULT_PORT_HTTP + bee_config = value + # TODO: renew client (needs to invalidate on config's property change as well) + get: + if not bee_config: + bee_config = {{>partials/api_config_class_name}}.new() + return bee_config func bee_next_loop_iteration(): @@ -136,15 +84,15 @@ func bee_connect_client_if_needed( on_success.call() var connecting := self.bee_client.connect_to_host( - self.bee_host, self.bee_port, - self.__bee_ssl_enabled, self.__bee_verify_host + self.bee_config.host, self.bee_config.port, + self.bee_config.ssl_enabled, self.bee_config.verify_host ) if connecting != OK: var error := {{>partials/api_error_class_name}}.new() error.internal_code = connecting error.identifier = "apibee.connect_to_host.failure" error.message = "%s: failed to connect to `%s' port %d with error %d" % [ - self.bee_name, self.bee_host, self.bee_port, connecting + self.bee_name, self.bee_config.host, self.bee_config.port, connecting ] on_failure.call(error) return @@ -157,8 +105,8 @@ func bee_connect_client_if_needed( ): self.bee_client.poll() print("Connecting...") - if self.bee_polling_interval_ms: - OS.delay_msec(self.bee_polling_interval_ms) + if self.bee_config.polling_interval_ms: + OS.delay_msec(self.bee_config.polling_interval_ms) await bee_next_loop_iteration() if self.bee_client.get_status() != HTTPClient.STATUS_CONNECTED: @@ -166,7 +114,7 @@ func bee_connect_client_if_needed( error.internal_code = connecting error.identifier = "apibee.connect_to_host.wrong_status" error.message = "%s: failed to connect to `%s' port %d, with client status %d" % [ - self.bee_name, self.bee_host, self.bee_port, self.bee_client.get_status() + self.bee_name, self.bee_config.host, self.bee_config.port, self.bee_client.get_status() ] on_failure.call(error) return @@ -261,8 +209,8 @@ func bee_do_request_text( ): headers = headers.duplicate(true) - headers.merge(self.bee_headers_base) - headers.merge(self.bee_headers_override, true) + headers.merge(self.bee_config.headers_base) + headers.merge(self.bee_config.headers_override, true) var body_normalized = body if body is Object: @@ -314,8 +262,8 @@ func bee_do_request_text( # Keep polling for as long as the request is being processed. self.bee_client.poll() print("Requesting...") - if self.bee_polling_interval_ms: - OS.delay_msec(self.bee_polling_interval_ms) + if self.bee_config.polling_interval_ms: + OS.delay_msec(self.bee_config.polling_interval_ms) await bee_next_loop_iteration() # if OS.has_feature("web") or async: @@ -344,8 +292,8 @@ func bee_do_request_text( self.bee_client.poll() var chunk = self.bee_client.read_response_body_chunk() if chunk.size() == 0: # Got nothing, wait for buffers to fill a bit. - if self.bee_polling_interval_ms: - OS.delay_usec(self.bee_polling_interval_ms) + if self.bee_config.polling_interval_ms: + OS.delay_usec(self.bee_config.polling_interval_ms) await bee_next_loop_iteration() else: # Yummy data has arrived response_bytes = response_bytes + chunk diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars new file mode 100644 index 000000000000..ab622c34ace9 --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars @@ -0,0 +1,80 @@ +extends Resource +class_name {{>partials/api_config_class_name}} + +# Configuration options for Api endpoints. +# +# Its purpose is to help you share configuration customizations across Apis. +# Since it is a Resource, you may use `ResourceSaver.save()` and `load()` +# to save it and load it from file, if you want. +# +# Not sure if this should hold the HTTPClient instance or not. Not for now. + +# These are constant, immutable default values. +# To set different values at runtime, use the public properties below. +const BEE_DEFAULT_HOST := "{{#if host}}{{{host}}}{{else}}localhost{{/if}}" +const BEE_DEFAULT_PORT_HTTP := 80 +const BEE_DEFAULT_PORT_HTTPS := 443 +const BEE_DEFAULT_POLLING_INTERVAL_MS := 500 # milliseconds + +{{!-- +# Godot's HTTP Client we are using. +# If none was set (by you), we'll make one. +var bee_client: HTTPClient: + set(value): + bee_client = value + get: + if not bee_client: + bee_client = HTTPClient.new() + return bee_client +--}} + +# The host to connect to, with or without the protocol scheme. +# Eg: "gitea.com", "https://gitea.com" +# We toggle TLS accordingly to the provided scheme, if any. +var host := BEE_DEFAULT_HOST: + set(value): + if value.begins_with("https://"): + ssl_enabled = true + value = value.substr(8) # "https://".length() == 8 + elif value.begins_with("http://"): + ssl_enabled = false + value = value.substr(7) # "http://".length() == 7 + host = value + + +# Port through which the connection will be established. +# Note: changing the host may change the port as well if the scheme was provided, see above. +var port := BEE_DEFAULT_PORT_HTTP + + +# Headers used as base for all requests made by Api instances using this config. +# Those are the lowest priority headers, and are merged with custom headers provided in the bee_request() method call +# as well as the headers override below, to compute the final, actually sent headers. +var headers_base := { + # Stigmergy: everyone does what is left to do (like ants do) + "User-Agent": "Stigmergiac/1.0 (Godot)", + # For my mental health's sake, only JSON is supported for now + "Accept": "application/json", + "Content-Type": "application/json", + # FIXME: Remove demo cheat code + "api_key": "special-key", +} + + +# High-priority headers, they will always override other headers coming from the base above or the method call. +var headers_override := {} + + +# Duration of sleep between poll() calls. +var polling_interval_ms := BEE_DEFAULT_POLLING_INTERVAL_MS # milliseconds + + +# Should we encrypt packets ? Yes. Let's encrypt ! +var ssl_enabled := false: + set(value): + ssl_enabled = value + port = BEE_DEFAULT_PORT_HTTPS if ssl_enabled else BEE_DEFAULT_PORT_HTTP + + +var verify_host := true # only used if ssl is enabled, disable if trouble + diff --git a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars index b8733f57e75a..8d3dd3e768f3 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars @@ -31,12 +31,12 @@ func {{operationIdSnakeCase}}( {{paramName}}{{#if required}}{{#if dataType}}: {{{dataType}}}{{/if}}{{/if}}{{#unless required}} = {{#defaultValue}}{{{.}}}{{/defaultValue}}{{#unless defaultValue}}null{{/unless}}{{/unless}}, {{/each}} on_success: Callable = Callable(), # func(result{{#if returnType}}: {{returnType}}{{/if}}) - on_failure: Callable = Callable(), # func(error: ApiError) + on_failure: Callable = Callable(), # func(error: {{>partials/api_error_class_name}}) ): -{{!-- + {{!-- # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames. # Warn: Make sure all local variable names here are also listed in our Java CodeGen. ---}} + --}} # CollectionFormat: {{#if collectionFormat}}YES{{/if}}{{#unless collectionFormat}}NO{{/unless}} {{#if isDeprecated}} push_warning("Usage of `{{operationIdSnakeCase}}()` is deprecated.") diff --git a/modules/openapi-generator/src/main/resources/gdscript/api_doc.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api_doc.handlebars new file mode 100644 index 000000000000..4a7f40b5d7b6 --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/api_doc.handlebars @@ -0,0 +1,64 @@ + +# {{{classname}}} { #{{classname}} } +{{#if description}}{{description}}{{/if}} + +All URIs are relative to *{{basePath}}* + +Method | HTTP request | Description +------------- | ------------- | ------------- +{{#with operations}} +{{#each operation}} +[**{{operationIdSnakeCase}}**](#{{operationIdSnakeCase}}) | **{{httpMethod}}** `{{path}}` | {{#if summary}}{{summary}}{{/if}} +{{/each}} +{{/with}} + +{{#with operations}} +{{#each operation}} +# **{{{operationIdSnakeCase}}}** { #{{{operationIdSnakeCase}}} } + + +> `{{operationIdSnakeCase}}({{#each allParams}}{{paramName}}{{#if required}}{{#if dataType}}: {{{dataType}}}{{/if}}{{/if}}{{#unless required}} = {{#if defaultValue}}{{{defaultValue}}}{{/if}}{{#unless defaultValue}}null{{/unless}}{{/unless}},{{/each}} on_success: Callable, on_failure: Callable)` + +{{#if summary}}{{{summary}}}{{/if}} + +{{#if notes}}{{{notes}}}{{/if}} + +### Example + +{{#if hasAuthMethods}} +{{#each authMethods}} +{{#if isBasic}} +{{#if isBasicBasic}} +* Basic Authentication (`{{name}}`) +{{/if}} +{{#if isBasicBearer}} +* Bearer{{#if bearerFormat}} ({{{bearerFormat}}}){{/if}} Authentication (`{{name}}`) +{{/if}} +{{/if}} +{{#if isApiKey}} +* Api Key Authentication (`{{name}}`) +{{/if}} +{{#if isOAuth}} +* OAuth Authentication (`{{name}}`) +{{/if}} +{{/each}} +{{/if}} + +{{> api_doc_example }} + +{{/each}} + +### Authorization + +{{#each authMethods}} +[{{{name}}}](../README.md#{{name}}){{#unless @last}}, {{/unless}} +{{else}} +No authorization required. +{{/each}} + +[[Back to top]](#__pageTop) \ +[[Back to API list]](../README.md#documentation-for-api-endpoints) \ +[[Back to Model list]](../README.md#documentation-for-models) \ +[[Back to README]](../README.md) \ + +{{/with}} diff --git a/modules/openapi-generator/src/main/resources/gdscript/api_doc_example.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api_doc_example.handlebars new file mode 100644 index 000000000000..b3bfd88c1d0c --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/api_doc_example.handlebars @@ -0,0 +1,44 @@ +```gdscript +{{!-- +{{> doc_auth_partial}} +--}} + +var api = {{{classname}}}.new() +api.bee_host = "localhost" # customize host if needed +api.bee_port = 8080 # use the factory to share configs + +# Customize configuration, if needed (TODO) +var config := {{coreNamePrefix}}ApiConfig.new() +config.host = "localhost" +config.port = 8080 +api.config = config + +{{#each bodyParams}} +{{#if dataType}} +{{#if isModel}} +var {{paramName}} = {{dataType}}.new() +# … fill model with data +{{/if}} +{{/if}} +{{/each}} + +api.{{{operationIdSnakeCase}}}( +{{#each allParams}} + # {{paramName}}{{#if dataType}}: {{dataType}}{{/if}}{{#if defaultValue}} = {{{defaultValue}}}{{/if}}{{#if example}} Eg: {{{example}}}{{/if}} + # {{{description}}} +{{!-- `example` is not available here, not sure why --}} + {{paramName}}, +{{/each}} + # On Success + func(result):{{#with returnProperty}} # result is {{>partials/complex_type}}{{/with}} + prints("Success!", result) + pass # do things + , + # On Error + func(error): # error is {{>partials/api_error_class_name}} + printerr(str(error)) + pass # do things + , +) + +``` diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/api_config_class_name.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/api_config_class_name.handlebars new file mode 100644 index 000000000000..3532f4f17337 --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/api_config_class_name.handlebars @@ -0,0 +1 @@ +{{coreNamePrefix}}ApiConfig{{coreNameSuffix}} \ No newline at end of file diff --git a/samples/client/petstore/gdscript/.openapi-generator/FILES b/samples/client/petstore/gdscript/.openapi-generator/FILES index c67d19c94502..d00050b7e846 100644 --- a/samples/client/petstore/gdscript/.openapi-generator/FILES +++ b/samples/client/petstore/gdscript/.openapi-generator/FILES @@ -1,8 +1,12 @@ README.md apis/DemoPetApi.gd +apis/DemoPetApi.md apis/DemoStoreApi.gd +apis/DemoStoreApi.md apis/DemoUserApi.gd +apis/DemoUserApi.md core/DemoApiBee.gd +core/DemoApiConfig.gd core/DemoApiError.gd models/DemoApiResponse.gd models/DemoCategory.gd diff --git a/samples/client/petstore/gdscript/README.md b/samples/client/petstore/gdscript/README.md index 01580d36245f..09bcb9c5be14 100644 --- a/samples/client/petstore/gdscript/README.md +++ b/samples/client/petstore/gdscript/README.md @@ -35,36 +35,36 @@ All URIs are relative to *http://petstore.swagger.io/v2* Class | Method | HTTP request | Description ------------ | ------------- | ------------- | ------------- -*DemoPetApi* | [**add_pet**](DemoPetApi.md#add_pet) | **POST** /pet | Add a new pet to the store -*DemoPetApi* | [**delete_pet**](DemoPetApi.md#delete_pet) | **DELETE** /pet/{petId} | Deletes a pet -*DemoPetApi* | [**find_pets_by_status**](DemoPetApi.md#find_pets_by_status) | **GET** /pet/findByStatus | Finds Pets by status -*DemoPetApi* | [**find_pets_by_tags**](DemoPetApi.md#find_pets_by_tags) | **GET** /pet/findByTags | Finds Pets by tags -*DemoPetApi* | [**get_pet_by_id**](DemoPetApi.md#get_pet_by_id) | **GET** /pet/{petId} | Find pet by ID -*DemoPetApi* | [**update_pet**](DemoPetApi.md#update_pet) | **PUT** /pet | Update an existing pet -*DemoPetApi* | [**update_pet_with_form**](DemoPetApi.md#update_pet_with_form) | **POST** /pet/{petId} | Updates a pet in the store with form data -*DemoPetApi* | [**upload_file**](DemoPetApi.md#upload_file) | **POST** /pet/{petId}/uploadImage | uploads an image -*DemoStoreApi* | [**delete_order**](DemoStoreApi.md#delete_order) | **DELETE** /store/order/{orderId} | Delete purchase order by ID -*DemoStoreApi* | [**get_inventory**](DemoStoreApi.md#get_inventory) | **GET** /store/inventory | Returns pet inventories by status -*DemoStoreApi* | [**get_order_by_id**](DemoStoreApi.md#get_order_by_id) | **GET** /store/order/{orderId} | Find purchase order by ID -*DemoStoreApi* | [**place_order**](DemoStoreApi.md#place_order) | **POST** /store/order | Place an order for a pet -*DemoUserApi* | [**create_user**](DemoUserApi.md#create_user) | **POST** /user | Create user -*DemoUserApi* | [**create_users_with_array_input**](DemoUserApi.md#create_users_with_array_input) | **POST** /user/createWithArray | Creates list of users with given input array -*DemoUserApi* | [**create_users_with_list_input**](DemoUserApi.md#create_users_with_list_input) | **POST** /user/createWithList | Creates list of users with given input array -*DemoUserApi* | [**delete_user**](DemoUserApi.md#delete_user) | **DELETE** /user/{username} | Delete user -*DemoUserApi* | [**get_user_by_name**](DemoUserApi.md#get_user_by_name) | **GET** /user/{username} | Get user by user name -*DemoUserApi* | [**login_user**](DemoUserApi.md#login_user) | **GET** /user/login | Logs user into the system -*DemoUserApi* | [**logout_user**](DemoUserApi.md#logout_user) | **GET** /user/logout | Logs out current logged in user session -*DemoUserApi* | [**update_user**](DemoUserApi.md#update_user) | **PUT** /user/{username} | Updated user +*DemoPetApi* | [**add_pet**](apis/DemoPetApi.md#add_pet) | **POST** /pet | Add a new pet to the store +*DemoPetApi* | [**delete_pet**](apis/DemoPetApi.md#delete_pet) | **DELETE** /pet/{petId} | Deletes a pet +*DemoPetApi* | [**find_pets_by_status**](apis/DemoPetApi.md#find_pets_by_status) | **GET** /pet/findByStatus | Finds Pets by status +*DemoPetApi* | [**find_pets_by_tags**](apis/DemoPetApi.md#find_pets_by_tags) | **GET** /pet/findByTags | Finds Pets by tags +*DemoPetApi* | [**get_pet_by_id**](apis/DemoPetApi.md#get_pet_by_id) | **GET** /pet/{petId} | Find pet by ID +*DemoPetApi* | [**update_pet**](apis/DemoPetApi.md#update_pet) | **PUT** /pet | Update an existing pet +*DemoPetApi* | [**update_pet_with_form**](apis/DemoPetApi.md#update_pet_with_form) | **POST** /pet/{petId} | Updates a pet in the store with form data +*DemoPetApi* | [**upload_file**](apis/DemoPetApi.md#upload_file) | **POST** /pet/{petId}/uploadImage | uploads an image +*DemoStoreApi* | [**delete_order**](apis/DemoStoreApi.md#delete_order) | **DELETE** /store/order/{orderId} | Delete purchase order by ID +*DemoStoreApi* | [**get_inventory**](apis/DemoStoreApi.md#get_inventory) | **GET** /store/inventory | Returns pet inventories by status +*DemoStoreApi* | [**get_order_by_id**](apis/DemoStoreApi.md#get_order_by_id) | **GET** /store/order/{orderId} | Find purchase order by ID +*DemoStoreApi* | [**place_order**](apis/DemoStoreApi.md#place_order) | **POST** /store/order | Place an order for a pet +*DemoUserApi* | [**create_user**](apis/DemoUserApi.md#create_user) | **POST** /user | Create user +*DemoUserApi* | [**create_users_with_array_input**](apis/DemoUserApi.md#create_users_with_array_input) | **POST** /user/createWithArray | Creates list of users with given input array +*DemoUserApi* | [**create_users_with_list_input**](apis/DemoUserApi.md#create_users_with_list_input) | **POST** /user/createWithList | Creates list of users with given input array +*DemoUserApi* | [**delete_user**](apis/DemoUserApi.md#delete_user) | **DELETE** /user/{username} | Delete user +*DemoUserApi* | [**get_user_by_name**](apis/DemoUserApi.md#get_user_by_name) | **GET** /user/{username} | Get user by user name +*DemoUserApi* | [**login_user**](apis/DemoUserApi.md#login_user) | **GET** /user/login | Logs user into the system +*DemoUserApi* | [**logout_user**](apis/DemoUserApi.md#logout_user) | **GET** /user/logout | Logs out current logged in user session +*DemoUserApi* | [**update_user**](apis/DemoUserApi.md#update_user) | **PUT** /user/{username} | Updated user ## Documentation For Models -- [DemoApiResponse](DemoApiResponse.md) -- [DemoCategory](DemoCategory.md) -- [DemoOrder](DemoOrder.md) -- [DemoPet](DemoPet.md) -- [DemoTag](DemoTag.md) -- [DemoUser](DemoUser.md) +- [DemoApiResponse](models/DemoApiResponse.md) +- [DemoCategory](models/DemoCategory.md) +- [DemoOrder](models/DemoOrder.md) +- [DemoPet](models/DemoPet.md) +- [DemoTag](models/DemoTag.md) +- [DemoUser](models/DemoUser.md) ## Documentation For Authorization diff --git a/samples/client/petstore/gdscript/apis/DemoPetApi.gd b/samples/client/petstore/gdscript/apis/DemoPetApi.gd index c54aa7d1a7ff..c0dc44fe365b 100644 --- a/samples/client/petstore/gdscript/apis/DemoPetApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoPetApi.gd @@ -14,7 +14,7 @@ func add_pet( # Pet object that needs to be added to the store demoPet: DemoPet, on_success: Callable = Callable(), # func(result: Pet) - on_failure: Callable = Callable(), # func(error: ApiError) + on_failure: Callable = Callable(), # func(error: DemoApiError) ): # CollectionFormat: NO @@ -74,7 +74,7 @@ func delete_pet( # apiKey = null, on_success: Callable = Callable(), # func(result) - on_failure: Callable = Callable(), # func(error: ApiError) + on_failure: Callable = Callable(), # func(error: DemoApiError) ): # CollectionFormat: NO @@ -113,7 +113,7 @@ func find_pets_by_status( # Status values that need to be considered for filter status: Array, on_success: Callable = Callable(), # func(result: Array) - on_failure: Callable = Callable(), # func(error: ApiError) + on_failure: Callable = Callable(), # func(error: DemoApiError) ): # CollectionFormat: NO @@ -159,7 +159,7 @@ func find_pets_by_tags( # Tags to filter by tags: Array, on_success: Callable = Callable(), # func(result: Array) - on_failure: Callable = Callable(), # func(error: ApiError) + on_failure: Callable = Callable(), # func(error: DemoApiError) ): # CollectionFormat: NO push_warning("Usage of `find_pets_by_tags()` is deprecated.") @@ -205,7 +205,7 @@ func get_pet_by_id( # ID of pet to return petId: float, on_success: Callable = Callable(), # func(result: Pet) - on_failure: Callable = Callable(), # func(error: ApiError) + on_failure: Callable = Callable(), # func(error: DemoApiError) ): # CollectionFormat: NO @@ -247,7 +247,7 @@ func update_pet( # Pet object that needs to be added to the store demoPet: DemoPet, on_success: Callable = Callable(), # func(result: Pet) - on_failure: Callable = Callable(), # func(error: ApiError) + on_failure: Callable = Callable(), # func(error: DemoApiError) ): # CollectionFormat: NO @@ -310,7 +310,7 @@ func update_pet_with_form( # Updated status of the pet status = null, on_success: Callable = Callable(), # func(result) - on_failure: Callable = Callable(), # func(error: ApiError) + on_failure: Callable = Callable(), # func(error: DemoApiError) ): # CollectionFormat: NO @@ -369,7 +369,7 @@ func upload_file( # file to upload file = null, on_success: Callable = Callable(), # func(result: ApiResponse) - on_failure: Callable = Callable(), # func(error: ApiError) + on_failure: Callable = Callable(), # func(error: DemoApiError) ): # CollectionFormat: NO diff --git a/samples/client/petstore/gdscript/apis/DemoPetApi.md b/samples/client/petstore/gdscript/apis/DemoPetApi.md new file mode 100644 index 000000000000..da8a344e8d11 --- /dev/null +++ b/samples/client/petstore/gdscript/apis/DemoPetApi.md @@ -0,0 +1,399 @@ + +# DemoPetApi { #DemoPetApi } + + +All URIs are relative to *http://petstore.swagger.io/v2* + +Method | HTTP request | Description +------------- | ------------- | ------------- +[**add_pet**](#add_pet) | **POST** `/pet` | Add a new pet to the store +[**delete_pet**](#delete_pet) | **DELETE** `/pet/{petId}` | Deletes a pet +[**find_pets_by_status**](#find_pets_by_status) | **GET** `/pet/findByStatus` | Finds Pets by status +[**find_pets_by_tags**](#find_pets_by_tags) | **GET** `/pet/findByTags` | Finds Pets by tags +[**get_pet_by_id**](#get_pet_by_id) | **GET** `/pet/{petId}` | Find pet by ID +[**update_pet**](#update_pet) | **PUT** `/pet` | Update an existing pet +[**update_pet_with_form**](#update_pet_with_form) | **POST** `/pet/{petId}` | Updates a pet in the store with form data +[**upload_file**](#upload_file) | **POST** `/pet/{petId}/uploadImage` | uploads an image + +# **add_pet** { #add_pet } + + +> `add_pet(demoPet: DemoPet, on_success: Callable, on_failure: Callable)` + +Add a new pet to the store + + + +### Example + +* OAuth Authentication (`petstore_auth`) + +```gdscript + +var api = DemoPetApi.new() +api.bee_host = "localhost" # customize host if needed +api.bee_port = 8080 # use the factory to share configs + +# Customize configuration, if needed (TODO) +var config := DemoApiConfig.new() +config.host = "localhost" +config.port = 8080 +api.config = config + +var demoPet = DemoPet.new() +# … fill model with data + +api.add_pet( + # demoPet: DemoPet + # Pet object that needs to be added to the store + demoPet, + # On Success + func(result): # result is DemoPet + prints("Success!", result) + pass # do things + , + # On Error + func(error): # error is DemoApiError + printerr(str(error)) + pass # do things + , +) + +``` + +# **delete_pet** { #delete_pet } + + +> `delete_pet(petId: float,apiKey = null, on_success: Callable, on_failure: Callable)` + +Deletes a pet + + + +### Example + +* OAuth Authentication (`petstore_auth`) + +```gdscript + +var api = DemoPetApi.new() +api.bee_host = "localhost" # customize host if needed +api.bee_port = 8080 # use the factory to share configs + +# Customize configuration, if needed (TODO) +var config := DemoApiConfig.new() +config.host = "localhost" +config.port = 8080 +api.config = config + + +api.delete_pet( + # petId: float Eg: 789 + # Pet id to delete + petId, + # apiKey: String Eg: apiKey_example + # + apiKey, + # On Success + func(result): + prints("Success!", result) + pass # do things + , + # On Error + func(error): # error is DemoApiError + printerr(str(error)) + pass # do things + , +) + +``` + +# **find_pets_by_status** { #find_pets_by_status } + + +> `find_pets_by_status(status: Array, on_success: Callable, on_failure: Callable)` + +Finds Pets by status + +Multiple status values can be provided with comma separated strings + +### Example + +* OAuth Authentication (`petstore_auth`) + +```gdscript + +var api = DemoPetApi.new() +api.bee_host = "localhost" # customize host if needed +api.bee_port = 8080 # use the factory to share configs + +# Customize configuration, if needed (TODO) +var config := DemoApiConfig.new() +config.host = "localhost" +config.port = 8080 +api.config = config + + +api.find_pets_by_status( + # status: Array + # Status values that need to be considered for filter + status, + # On Success + func(result): # result is DemoPet + prints("Success!", result) + pass # do things + , + # On Error + func(error): # error is DemoApiError + printerr(str(error)) + pass # do things + , +) + +``` + +# **find_pets_by_tags** { #find_pets_by_tags } + + +> `find_pets_by_tags(tags: Array, on_success: Callable, on_failure: Callable)` + +Finds Pets by tags + +Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing. + +### Example + +* OAuth Authentication (`petstore_auth`) + +```gdscript + +var api = DemoPetApi.new() +api.bee_host = "localhost" # customize host if needed +api.bee_port = 8080 # use the factory to share configs + +# Customize configuration, if needed (TODO) +var config := DemoApiConfig.new() +config.host = "localhost" +config.port = 8080 +api.config = config + + +api.find_pets_by_tags( + # tags: Array + # Tags to filter by + tags, + # On Success + func(result): # result is DemoPet + prints("Success!", result) + pass # do things + , + # On Error + func(error): # error is DemoApiError + printerr(str(error)) + pass # do things + , +) + +``` + +# **get_pet_by_id** { #get_pet_by_id } + + +> `get_pet_by_id(petId: float, on_success: Callable, on_failure: Callable)` + +Find pet by ID + +Returns a single pet + +### Example + +* Api Key Authentication (`api_key`) + +```gdscript + +var api = DemoPetApi.new() +api.bee_host = "localhost" # customize host if needed +api.bee_port = 8080 # use the factory to share configs + +# Customize configuration, if needed (TODO) +var config := DemoApiConfig.new() +config.host = "localhost" +config.port = 8080 +api.config = config + + +api.get_pet_by_id( + # petId: float Eg: 789 + # ID of pet to return + petId, + # On Success + func(result): # result is DemoPet + prints("Success!", result) + pass # do things + , + # On Error + func(error): # error is DemoApiError + printerr(str(error)) + pass # do things + , +) + +``` + +# **update_pet** { #update_pet } + + +> `update_pet(demoPet: DemoPet, on_success: Callable, on_failure: Callable)` + +Update an existing pet + + + +### Example + +* OAuth Authentication (`petstore_auth`) + +```gdscript + +var api = DemoPetApi.new() +api.bee_host = "localhost" # customize host if needed +api.bee_port = 8080 # use the factory to share configs + +# Customize configuration, if needed (TODO) +var config := DemoApiConfig.new() +config.host = "localhost" +config.port = 8080 +api.config = config + +var demoPet = DemoPet.new() +# … fill model with data + +api.update_pet( + # demoPet: DemoPet + # Pet object that needs to be added to the store + demoPet, + # On Success + func(result): # result is DemoPet + prints("Success!", result) + pass # do things + , + # On Error + func(error): # error is DemoApiError + printerr(str(error)) + pass # do things + , +) + +``` + +# **update_pet_with_form** { #update_pet_with_form } + + +> `update_pet_with_form(petId: float,name = null,status = null, on_success: Callable, on_failure: Callable)` + +Updates a pet in the store with form data + + + +### Example + +* OAuth Authentication (`petstore_auth`) + +```gdscript + +var api = DemoPetApi.new() +api.bee_host = "localhost" # customize host if needed +api.bee_port = 8080 # use the factory to share configs + +# Customize configuration, if needed (TODO) +var config := DemoApiConfig.new() +config.host = "localhost" +config.port = 8080 +api.config = config + + +api.update_pet_with_form( + # petId: float Eg: 789 + # ID of pet that needs to be updated + petId, + # name: String Eg: name_example + # Updated name of the pet + name, + # status: String Eg: status_example + # Updated status of the pet + status, + # On Success + func(result): + prints("Success!", result) + pass # do things + , + # On Error + func(error): # error is DemoApiError + printerr(str(error)) + pass # do things + , +) + +``` + +# **upload_file** { #upload_file } + + +> `upload_file(petId: float,additionalMetadata = null,file = null, on_success: Callable, on_failure: Callable)` + +uploads an image + + + +### Example + +* OAuth Authentication (`petstore_auth`) + +```gdscript + +var api = DemoPetApi.new() +api.bee_host = "localhost" # customize host if needed +api.bee_port = 8080 # use the factory to share configs + +# Customize configuration, if needed (TODO) +var config := DemoApiConfig.new() +config.host = "localhost" +config.port = 8080 +api.config = config + + +api.upload_file( + # petId: float Eg: 789 + # ID of pet to update + petId, + # additionalMetadata: String Eg: additionalMetadata_example + # Additional data to pass to server + additionalMetadata, + # file: String Eg: BINARY_DATA_HERE + # file to upload + file, + # On Success + func(result): # result is DemoApiResponse + prints("Success!", result) + pass # do things + , + # On Error + func(error): # error is DemoApiError + printerr(str(error)) + pass # do things + , +) + +``` + + +### Authorization + +[api_key](../README.md#api_key), +[petstore_auth](../README.md#petstore_auth) + +[[Back to top]](#__pageTop) \ +[[Back to API list]](../README.md#documentation-for-api-endpoints) \ +[[Back to Model list]](../README.md#documentation-for-models) \ +[[Back to README]](../README.md) \ + diff --git a/samples/client/petstore/gdscript/apis/DemoStoreApi.gd b/samples/client/petstore/gdscript/apis/DemoStoreApi.gd index 2ba352a4d479..410dce06afd1 100644 --- a/samples/client/petstore/gdscript/apis/DemoStoreApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoStoreApi.gd @@ -16,7 +16,7 @@ func delete_order( # ID of the order that needs to be deleted orderId: String, on_success: Callable = Callable(), # func(result) - on_failure: Callable = Callable(), # func(error: ApiError) + on_failure: Callable = Callable(), # func(error: DemoApiError) ): # CollectionFormat: NO @@ -51,7 +51,7 @@ func delete_order( # Returns a map of status codes to quantities func get_inventory( on_success: Callable = Callable(), # func(result: Dictionary) - on_failure: Callable = Callable(), # func(error: ApiError) + on_failure: Callable = Callable(), # func(error: DemoApiError) ): # CollectionFormat: NO @@ -94,7 +94,7 @@ func get_order_by_id( # ID of pet that needs to be fetched orderId: float, on_success: Callable = Callable(), # func(result: Order) - on_failure: Callable = Callable(), # func(error: ApiError) + on_failure: Callable = Callable(), # func(error: DemoApiError) ): # CollectionFormat: NO @@ -150,7 +150,7 @@ func place_order( # order placed for purchasing the pet demoOrder: DemoOrder, on_success: Callable = Callable(), # func(result: Order) - on_failure: Callable = Callable(), # func(error: ApiError) + on_failure: Callable = Callable(), # func(error: DemoApiError) ): # CollectionFormat: NO diff --git a/samples/client/petstore/gdscript/apis/DemoStoreApi.md b/samples/client/petstore/gdscript/apis/DemoStoreApi.md new file mode 100644 index 000000000000..e8b055033985 --- /dev/null +++ b/samples/client/petstore/gdscript/apis/DemoStoreApi.md @@ -0,0 +1,196 @@ + +# DemoStoreApi { #DemoStoreApi } + + +All URIs are relative to *http://petstore.swagger.io/v2* + +Method | HTTP request | Description +------------- | ------------- | ------------- +[**delete_order**](#delete_order) | **DELETE** `/store/order/{orderId}` | Delete purchase order by ID +[**get_inventory**](#get_inventory) | **GET** `/store/inventory` | Returns pet inventories by status +[**get_order_by_id**](#get_order_by_id) | **GET** `/store/order/{orderId}` | Find purchase order by ID +[**place_order**](#place_order) | **POST** `/store/order` | Place an order for a pet + +# **delete_order** { #delete_order } + + +> `delete_order(orderId: String, on_success: Callable, on_failure: Callable)` + +Delete purchase order by ID + +For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors + +### Example + + +```gdscript + +var api = DemoStoreApi.new() +api.bee_host = "localhost" # customize host if needed +api.bee_port = 8080 # use the factory to share configs + +# Customize configuration, if needed (TODO) +var config := DemoApiConfig.new() +config.host = "localhost" +config.port = 8080 +api.config = config + + +api.delete_order( + # orderId: String Eg: orderId_example + # ID of the order that needs to be deleted + orderId, + # On Success + func(result): + prints("Success!", result) + pass # do things + , + # On Error + func(error): # error is DemoApiError + printerr(str(error)) + pass # do things + , +) + +``` + +# **get_inventory** { #get_inventory } + + +> `get_inventory( on_success: Callable, on_failure: Callable)` + +Returns pet inventories by status + +Returns a map of status codes to quantities + +### Example + +* Api Key Authentication (`api_key`) + +```gdscript + +var api = DemoStoreApi.new() +api.bee_host = "localhost" # customize host if needed +api.bee_port = 8080 # use the factory to share configs + +# Customize configuration, if needed (TODO) +var config := DemoApiConfig.new() +config.host = "localhost" +config.port = 8080 +api.config = config + + +api.get_inventory( + # On Success + func(result): # result is Demointeger + prints("Success!", result) + pass # do things + , + # On Error + func(error): # error is DemoApiError + printerr(str(error)) + pass # do things + , +) + +``` + +# **get_order_by_id** { #get_order_by_id } + + +> `get_order_by_id(orderId: float, on_success: Callable, on_failure: Callable)` + +Find purchase order by ID + +For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions + +### Example + + +```gdscript + +var api = DemoStoreApi.new() +api.bee_host = "localhost" # customize host if needed +api.bee_port = 8080 # use the factory to share configs + +# Customize configuration, if needed (TODO) +var config := DemoApiConfig.new() +config.host = "localhost" +config.port = 8080 +api.config = config + + +api.get_order_by_id( + # orderId: float Eg: 789 + # ID of pet that needs to be fetched + orderId, + # On Success + func(result): # result is DemoOrder + prints("Success!", result) + pass # do things + , + # On Error + func(error): # error is DemoApiError + printerr(str(error)) + pass # do things + , +) + +``` + +# **place_order** { #place_order } + + +> `place_order(demoOrder: DemoOrder, on_success: Callable, on_failure: Callable)` + +Place an order for a pet + + + +### Example + + +```gdscript + +var api = DemoStoreApi.new() +api.bee_host = "localhost" # customize host if needed +api.bee_port = 8080 # use the factory to share configs + +# Customize configuration, if needed (TODO) +var config := DemoApiConfig.new() +config.host = "localhost" +config.port = 8080 +api.config = config + +var demoOrder = DemoOrder.new() +# … fill model with data + +api.place_order( + # demoOrder: DemoOrder + # order placed for purchasing the pet + demoOrder, + # On Success + func(result): # result is DemoOrder + prints("Success!", result) + pass # do things + , + # On Error + func(error): # error is DemoApiError + printerr(str(error)) + pass # do things + , +) + +``` + + +### Authorization + +[api_key](../README.md#api_key), +[petstore_auth](../README.md#petstore_auth) + +[[Back to top]](#__pageTop) \ +[[Back to API list]](../README.md#documentation-for-api-endpoints) \ +[[Back to Model list]](../README.md#documentation-for-models) \ +[[Back to README]](../README.md) \ + diff --git a/samples/client/petstore/gdscript/apis/DemoUserApi.gd b/samples/client/petstore/gdscript/apis/DemoUserApi.gd index 93e66589676e..ec1e9a3500b2 100644 --- a/samples/client/petstore/gdscript/apis/DemoUserApi.gd +++ b/samples/client/petstore/gdscript/apis/DemoUserApi.gd @@ -16,7 +16,7 @@ func create_user( # Created user object demoUser: DemoUser, on_success: Callable = Callable(), # func(result) - on_failure: Callable = Callable(), # func(error: ApiError) + on_failure: Callable = Callable(), # func(error: DemoApiError) ): # CollectionFormat: NO @@ -67,7 +67,7 @@ func create_users_with_array_input( # List of user object user: Array, on_success: Callable = Callable(), # func(result) - on_failure: Callable = Callable(), # func(error: ApiError) + on_failure: Callable = Callable(), # func(error: DemoApiError) ): # CollectionFormat: NO @@ -118,7 +118,7 @@ func create_users_with_list_input( # List of user object user: Array, on_success: Callable = Callable(), # func(result) - on_failure: Callable = Callable(), # func(error: ApiError) + on_failure: Callable = Callable(), # func(error: DemoApiError) ): # CollectionFormat: NO @@ -171,7 +171,7 @@ func delete_user( # The name that needs to be deleted username: String, on_success: Callable = Callable(), # func(result) - on_failure: Callable = Callable(), # func(error: ApiError) + on_failure: Callable = Callable(), # func(error: DemoApiError) ): # CollectionFormat: NO @@ -207,7 +207,7 @@ func get_user_by_name( # The name that needs to be fetched. Use user1 for testing. username: String, on_success: Callable = Callable(), # func(result: User) - on_failure: Callable = Callable(), # func(error: ApiError) + on_failure: Callable = Callable(), # func(error: DemoApiError) ): # CollectionFormat: NO @@ -252,7 +252,7 @@ func login_user( # The password for login in clear text password: String, on_success: Callable = Callable(), # func(result: String) - on_failure: Callable = Callable(), # func(error: ApiError) + on_failure: Callable = Callable(), # func(error: DemoApiError) ): # CollectionFormat: NO @@ -311,7 +311,7 @@ func login_user( # Logs out current logged in user session func logout_user( on_success: Callable = Callable(), # func(result) - on_failure: Callable = Callable(), # func(error: ApiError) + on_failure: Callable = Callable(), # func(error: DemoApiError) ): # CollectionFormat: NO @@ -352,7 +352,7 @@ func update_user( # Updated user object demoUser: DemoUser, on_success: Callable = Callable(), # func(result) - on_failure: Callable = Callable(), # func(error: ApiError) + on_failure: Callable = Callable(), # func(error: DemoApiError) ): # CollectionFormat: NO diff --git a/samples/client/petstore/gdscript/apis/DemoUserApi.md b/samples/client/petstore/gdscript/apis/DemoUserApi.md new file mode 100644 index 000000000000..a8b1ac39f694 --- /dev/null +++ b/samples/client/petstore/gdscript/apis/DemoUserApi.md @@ -0,0 +1,385 @@ + +# DemoUserApi { #DemoUserApi } + + +All URIs are relative to *http://petstore.swagger.io/v2* + +Method | HTTP request | Description +------------- | ------------- | ------------- +[**create_user**](#create_user) | **POST** `/user` | Create user +[**create_users_with_array_input**](#create_users_with_array_input) | **POST** `/user/createWithArray` | Creates list of users with given input array +[**create_users_with_list_input**](#create_users_with_list_input) | **POST** `/user/createWithList` | Creates list of users with given input array +[**delete_user**](#delete_user) | **DELETE** `/user/{username}` | Delete user +[**get_user_by_name**](#get_user_by_name) | **GET** `/user/{username}` | Get user by user name +[**login_user**](#login_user) | **GET** `/user/login` | Logs user into the system +[**logout_user**](#logout_user) | **GET** `/user/logout` | Logs out current logged in user session +[**update_user**](#update_user) | **PUT** `/user/{username}` | Updated user + +# **create_user** { #create_user } + + +> `create_user(demoUser: DemoUser, on_success: Callable, on_failure: Callable)` + +Create user + +This can only be done by the logged in user. + +### Example + +* Api Key Authentication (`api_key`) + +```gdscript + +var api = DemoUserApi.new() +api.bee_host = "localhost" # customize host if needed +api.bee_port = 8080 # use the factory to share configs + +# Customize configuration, if needed (TODO) +var config := DemoApiConfig.new() +config.host = "localhost" +config.port = 8080 +api.config = config + +var demoUser = DemoUser.new() +# … fill model with data + +api.create_user( + # demoUser: DemoUser + # Created user object + demoUser, + # On Success + func(result): + prints("Success!", result) + pass # do things + , + # On Error + func(error): # error is DemoApiError + printerr(str(error)) + pass # do things + , +) + +``` + +# **create_users_with_array_input** { #create_users_with_array_input } + + +> `create_users_with_array_input(user: Array, on_success: Callable, on_failure: Callable)` + +Creates list of users with given input array + + + +### Example + +* Api Key Authentication (`api_key`) + +```gdscript + +var api = DemoUserApi.new() +api.bee_host = "localhost" # customize host if needed +api.bee_port = 8080 # use the factory to share configs + +# Customize configuration, if needed (TODO) +var config := DemoApiConfig.new() +config.host = "localhost" +config.port = 8080 +api.config = config + + +api.create_users_with_array_input( + # user: Array + # List of user object + user, + # On Success + func(result): + prints("Success!", result) + pass # do things + , + # On Error + func(error): # error is DemoApiError + printerr(str(error)) + pass # do things + , +) + +``` + +# **create_users_with_list_input** { #create_users_with_list_input } + + +> `create_users_with_list_input(user: Array, on_success: Callable, on_failure: Callable)` + +Creates list of users with given input array + + + +### Example + +* Api Key Authentication (`api_key`) + +```gdscript + +var api = DemoUserApi.new() +api.bee_host = "localhost" # customize host if needed +api.bee_port = 8080 # use the factory to share configs + +# Customize configuration, if needed (TODO) +var config := DemoApiConfig.new() +config.host = "localhost" +config.port = 8080 +api.config = config + + +api.create_users_with_list_input( + # user: Array + # List of user object + user, + # On Success + func(result): + prints("Success!", result) + pass # do things + , + # On Error + func(error): # error is DemoApiError + printerr(str(error)) + pass # do things + , +) + +``` + +# **delete_user** { #delete_user } + + +> `delete_user(username: String, on_success: Callable, on_failure: Callable)` + +Delete user + +This can only be done by the logged in user. + +### Example + +* Api Key Authentication (`api_key`) + +```gdscript + +var api = DemoUserApi.new() +api.bee_host = "localhost" # customize host if needed +api.bee_port = 8080 # use the factory to share configs + +# Customize configuration, if needed (TODO) +var config := DemoApiConfig.new() +config.host = "localhost" +config.port = 8080 +api.config = config + + +api.delete_user( + # username: String Eg: username_example + # The name that needs to be deleted + username, + # On Success + func(result): + prints("Success!", result) + pass # do things + , + # On Error + func(error): # error is DemoApiError + printerr(str(error)) + pass # do things + , +) + +``` + +# **get_user_by_name** { #get_user_by_name } + + +> `get_user_by_name(username: String, on_success: Callable, on_failure: Callable)` + +Get user by user name + + + +### Example + + +```gdscript + +var api = DemoUserApi.new() +api.bee_host = "localhost" # customize host if needed +api.bee_port = 8080 # use the factory to share configs + +# Customize configuration, if needed (TODO) +var config := DemoApiConfig.new() +config.host = "localhost" +config.port = 8080 +api.config = config + + +api.get_user_by_name( + # username: String Eg: username_example + # The name that needs to be fetched. Use user1 for testing. + username, + # On Success + func(result): # result is DemoUser + prints("Success!", result) + pass # do things + , + # On Error + func(error): # error is DemoApiError + printerr(str(error)) + pass # do things + , +) + +``` + +# **login_user** { #login_user } + + +> `login_user(username: String,password: String, on_success: Callable, on_failure: Callable)` + +Logs user into the system + + + +### Example + + +```gdscript + +var api = DemoUserApi.new() +api.bee_host = "localhost" # customize host if needed +api.bee_port = 8080 # use the factory to share configs + +# Customize configuration, if needed (TODO) +var config := DemoApiConfig.new() +config.host = "localhost" +config.port = 8080 +api.config = config + + +api.login_user( + # username: String Eg: username_example + # The user name for login + username, + # password: String Eg: password_example + # The password for login in clear text + password, + # On Success + func(result): # result is Demostring + prints("Success!", result) + pass # do things + , + # On Error + func(error): # error is DemoApiError + printerr(str(error)) + pass # do things + , +) + +``` + +# **logout_user** { #logout_user } + + +> `logout_user( on_success: Callable, on_failure: Callable)` + +Logs out current logged in user session + + + +### Example + +* Api Key Authentication (`api_key`) + +```gdscript + +var api = DemoUserApi.new() +api.bee_host = "localhost" # customize host if needed +api.bee_port = 8080 # use the factory to share configs + +# Customize configuration, if needed (TODO) +var config := DemoApiConfig.new() +config.host = "localhost" +config.port = 8080 +api.config = config + + +api.logout_user( + # On Success + func(result): + prints("Success!", result) + pass # do things + , + # On Error + func(error): # error is DemoApiError + printerr(str(error)) + pass # do things + , +) + +``` + +# **update_user** { #update_user } + + +> `update_user(username: String,demoUser: DemoUser, on_success: Callable, on_failure: Callable)` + +Updated user + +This can only be done by the logged in user. + +### Example + +* Api Key Authentication (`api_key`) + +```gdscript + +var api = DemoUserApi.new() +api.bee_host = "localhost" # customize host if needed +api.bee_port = 8080 # use the factory to share configs + +# Customize configuration, if needed (TODO) +var config := DemoApiConfig.new() +config.host = "localhost" +config.port = 8080 +api.config = config + +var demoUser = DemoUser.new() +# … fill model with data + +api.update_user( + # username: String Eg: username_example + # name that need to be deleted + username, + # demoUser: DemoUser + # Updated user object + demoUser, + # On Success + func(result): + prints("Success!", result) + pass # do things + , + # On Error + func(error): # error is DemoApiError + printerr(str(error)) + pass # do things + , +) + +``` + + +### Authorization + +[api_key](../README.md#api_key), +[petstore_auth](../README.md#petstore_auth) + +[[Back to top]](#__pageTop) \ +[[Back to API list]](../README.md#documentation-for-api-endpoints) \ +[[Back to Model list]](../README.md#documentation-for-models) \ +[[Back to README]](../README.md) \ + diff --git a/samples/client/petstore/gdscript/core/DemoApiBee.gd b/samples/client/petstore/gdscript/core/DemoApiBee.gd index 9d6beb58a475..ba773750e44e 100644 --- a/samples/client/petstore/gdscript/core/DemoApiBee.gd +++ b/samples/client/petstore/gdscript/core/DemoApiBee.gd @@ -1,6 +1,4 @@ extends RefCounted -# We class_name it for now (KISS), but eventually I'd like to remove this. -# Not trivial, though, because that means preloads and absolute paths. class_name DemoApiBee # Base class for all generated API endpoints. @@ -10,13 +8,6 @@ class_name DemoApiBee # We want to keep the amount of renaming to a minimum, though. # Therefore, we use the bee_ prefix, even if awkward. -# These are constants. -# To set different values at runtime, use the bee_xxxx properties below. -const BEE_DEFAULT_HOST := "petstore.swagger.io" -const BEE_DEFAULT_PORT_HTTP := 80 -const BEE_DEFAULT_PORT_HTTPS := 443 -const BEE_DEFAULT_POLLING_INTERVAL_MS := 500 # milliseconds - const BEE_CONTENT_TYPE_TEXT := "text/plain" const BEE_CONTENT_TYPE_HTML := "text/html" @@ -40,12 +31,14 @@ const BEE_CONSUMABLE_CONTENT_TYPES := [ BEE_CONTENT_TYPE_JSON, ] -# We'll probably only use this for logging + +# We'll probably only use this for logging. +# Each Api child can define its own, and it should be similar to class_name. var bee_name := "ApiBee" -# Godot's HTTP Client we are using. -# If none was set (by you), we'll make one. +# Godot's HTTP Client this Api instance is using. +# If none was set (by you), we'll lazily make one. var bee_client: HTTPClient: set(value): bee_client = value @@ -55,60 +48,16 @@ var bee_client: HTTPClient: return bee_client -# The host to connect to, with or without the scheme. -# Eg: "gitea.com", "https://gitea.com" -# We configure TLS accordingly to the provided scheme, if any. -var bee_host := BEE_DEFAULT_HOST: +# General configuration that can be shared across Api instances for convenience. +# If no configuration was provided, we'll lazily make one with defaults as best we can. +var bee_config: DemoApiConfig: set(value): - if value.begins_with("https://"): - bee_enable_ssl() - value = value.substr(8) # "https://".length() == 8 - elif value.begins_with("http://"): - bee_disable_ssl() - value = value.substr(7) # "http://".length() == 7 - bee_host = value - - -# Port through which the connection will be established. -# Note: changing the host may change the port as well if the scheme was provided, see above. -var bee_port := BEE_DEFAULT_PORT_HTTP - - -# Headers used as base for all requests made by this instance. -# Those are the lowest priority headers, and are merged with custom headers provided in the bee_request() method call -# to compute the final, actually sent headers. -# Note: the factory, if used, will set up here a shared dictionary across all instances. -var bee_headers_base := { - # Stigmergy: everyone does what is left to do (like ants do) - "User-Agent": "Stigmergiac/1.0 (Godot)", - # For my mental health's sake, only JSON is supported for now - "Accept": "application/json", - "Content-Type": "application/json", - # FIXME: Remove demo cheat code - "api_key": "special-key", -} - - -# High-priority headers, they will always override other headers coming from the base above or the method call. -# Note: the factory, if used, will set up here a shared dictionary across all instances. -var bee_headers_override := {} - -# Duration of sleep between poll() calls -var bee_polling_interval_ms := BEE_DEFAULT_POLLING_INTERVAL_MS # milliseconds - -# @private -var __bee_ssl_enabled := false -var __bee_verify_host := true # only if ssl enabled - - -func bee_enable_ssl(): - self.__bee_ssl_enabled = true - self.bee_port = BEE_DEFAULT_PORT_HTTPS - - -func bee_disable_ssl(): - self.__bee_ssl_enabled = false - self.bee_port = BEE_DEFAULT_PORT_HTTP + bee_config = value + # TODO: renew client (needs to invalidate on config's property change as well) + get: + if not bee_config: + bee_config = DemoApiConfig.new() + return bee_config func bee_next_loop_iteration(): @@ -135,15 +84,15 @@ func bee_connect_client_if_needed( on_success.call() var connecting := self.bee_client.connect_to_host( - self.bee_host, self.bee_port, - self.__bee_ssl_enabled, self.__bee_verify_host + self.bee_config.host, self.bee_config.port, + self.bee_config.ssl_enabled, self.bee_config.verify_host ) if connecting != OK: var error := DemoApiError.new() error.internal_code = connecting error.identifier = "apibee.connect_to_host.failure" error.message = "%s: failed to connect to `%s' port %d with error %d" % [ - self.bee_name, self.bee_host, self.bee_port, connecting + self.bee_name, self.bee_config.host, self.bee_config.port, connecting ] on_failure.call(error) return @@ -156,8 +105,8 @@ func bee_connect_client_if_needed( ): self.bee_client.poll() print("Connecting...") - if self.bee_polling_interval_ms: - OS.delay_msec(self.bee_polling_interval_ms) + if self.bee_config.polling_interval_ms: + OS.delay_msec(self.bee_config.polling_interval_ms) await bee_next_loop_iteration() if self.bee_client.get_status() != HTTPClient.STATUS_CONNECTED: @@ -165,7 +114,7 @@ func bee_connect_client_if_needed( error.internal_code = connecting error.identifier = "apibee.connect_to_host.wrong_status" error.message = "%s: failed to connect to `%s' port %d, with client status %d" % [ - self.bee_name, self.bee_host, self.bee_port, self.bee_client.get_status() + self.bee_name, self.bee_config.host, self.bee_config.port, self.bee_client.get_status() ] on_failure.call(error) return @@ -260,8 +209,8 @@ func bee_do_request_text( ): headers = headers.duplicate(true) - headers.merge(self.bee_headers_base) - headers.merge(self.bee_headers_override, true) + headers.merge(self.bee_config.headers_base) + headers.merge(self.bee_config.headers_override, true) var body_normalized = body if body is Object: @@ -312,8 +261,8 @@ func bee_do_request_text( # Keep polling for as long as the request is being processed. self.bee_client.poll() print("Requesting...") - if self.bee_polling_interval_ms: - OS.delay_msec(self.bee_polling_interval_ms) + if self.bee_config.polling_interval_ms: + OS.delay_msec(self.bee_config.polling_interval_ms) await bee_next_loop_iteration() # if OS.has_feature("web") or async: @@ -342,8 +291,8 @@ func bee_do_request_text( self.bee_client.poll() var chunk = self.bee_client.read_response_body_chunk() if chunk.size() == 0: # Got nothing, wait for buffers to fill a bit. - if self.bee_polling_interval_ms: - OS.delay_usec(self.bee_polling_interval_ms) + if self.bee_config.polling_interval_ms: + OS.delay_usec(self.bee_config.polling_interval_ms) await bee_next_loop_iteration() else: # Yummy data has arrived response_bytes = response_bytes + chunk diff --git a/samples/client/petstore/gdscript/core/DemoApiConfig.gd b/samples/client/petstore/gdscript/core/DemoApiConfig.gd new file mode 100644 index 000000000000..590a96c51a30 --- /dev/null +++ b/samples/client/petstore/gdscript/core/DemoApiConfig.gd @@ -0,0 +1,69 @@ +extends Resource +class_name DemoApiConfig + +# Configuration options for Api endpoints. +# +# Its purpose is to help you share configuration customizations across Apis. +# Since it is a Resource, you may use `ResourceSaver.save()` and `load()` +# to save it and load it from file, if you want. +# +# Not sure if this should hold the HTTPClient instance or not. Not for now. + +# These are constant, immutable default values. +# To set different values at runtime, use the public properties below. +const BEE_DEFAULT_HOST := "petstore.swagger.io" +const BEE_DEFAULT_PORT_HTTP := 80 +const BEE_DEFAULT_PORT_HTTPS := 443 +const BEE_DEFAULT_POLLING_INTERVAL_MS := 500 # milliseconds + + +# The host to connect to, with or without the protocol scheme. +# Eg: "gitea.com", "https://gitea.com" +# We toggle TLS accordingly to the provided scheme, if any. +var host := BEE_DEFAULT_HOST: + set(value): + if value.begins_with("https://"): + ssl_enabled = true + value = value.substr(8) # "https://".length() == 8 + elif value.begins_with("http://"): + ssl_enabled = false + value = value.substr(7) # "http://".length() == 7 + host = value + + +# Port through which the connection will be established. +# Note: changing the host may change the port as well if the scheme was provided, see above. +var port := BEE_DEFAULT_PORT_HTTP + + +# Headers used as base for all requests made by Api instances using this config. +# Those are the lowest priority headers, and are merged with custom headers provided in the bee_request() method call +# as well as the headers override below, to compute the final, actually sent headers. +var headers_base := { + # Stigmergy: everyone does what is left to do (like ants do) + "User-Agent": "Stigmergiac/1.0 (Godot)", + # For my mental health's sake, only JSON is supported for now + "Accept": "application/json", + "Content-Type": "application/json", + # FIXME: Remove demo cheat code + "api_key": "special-key", +} + + +# High-priority headers, they will always override other headers coming from the base above or the method call. +var headers_override := {} + + +# Duration of sleep between poll() calls. +var polling_interval_ms := BEE_DEFAULT_POLLING_INTERVAL_MS # milliseconds + + +# Should we encrypt packets ? Yes. Let's encrypt ! +var ssl_enabled := false: + set(value): + ssl_enabled = value + port = BEE_DEFAULT_PORT_HTTPS if ssl_enabled else BEE_DEFAULT_PORT_HTTP + + +var verify_host := true # only used if ssl is enabled, disable if trouble + diff --git a/samples/client/petstore/gdscript/demo/main.gd b/samples/client/petstore/gdscript/demo/main.gd index b2a140680d2a..329f174b8885 100644 --- a/samples/client/petstore/gdscript/demo/main.gd +++ b/samples/client/petstore/gdscript/demo/main.gd @@ -21,7 +21,7 @@ func _ready(): func _on_run_tests_button_pressed(): - run_all_tests(func(): pass) + run_all_tests(func(): pass) # optional Callables are unstable func _on_exit_button_pressed(): @@ -47,7 +47,11 @@ func fail(msg: String): gtfo(1) +var cfg := DemoApiConfig.new() + + func run_all_tests(on_done := Callable()): + cfg.port = 8081 log_text_edit.text = "" var started_at := Time.get_ticks_msec() @@ -59,21 +63,22 @@ func run_all_tests(on_done := Callable()): var ended_at := Time.get_ticks_msec() Logger.inform("Ran tests for %.2fs" % [0.001 * (ended_at - started_at)]) if failed: - print("FAILURE") + Logger.inform("FAILURE") else: - print("SUCCESS") + Logger.inform("SUCCESS") on_done.call() func run_test_01(): Logger.inform("Running test 01…") + var rick := DemoUser.new() rick.username = "Rick" rick.password = "ytrom&" var user_api := DemoUserApi.new() - user_api.bee_port = 8081 + user_api.bee_config = cfg user_api.create_user( rick, func(result): @@ -101,7 +106,7 @@ func run_test_01(): func authenticate(username: String, password: String, on_done: Callable): var user_api := DemoUserApi.new() - user_api.bee_port = 8081 + user_api.bee_config = cfg user_api.login_user( username, password, func(result): @@ -125,7 +130,7 @@ func add_monkey(on_done: Callable): #monkey.tags = ['tree', 'fur'] var pet_api := DemoPetApi.new() - pet_api.bee_port = 8081 + pet_api.bee_config = cfg pet_api.add_pet( monkey, func(result): @@ -149,7 +154,7 @@ func add_monkey(on_done: Callable): func update_monkey(monkey, new_name, on_done: Callable): var pet_api := DemoPetApi.new() - pet_api.bee_port = 8081 + pet_api.bee_config = cfg pet_api.update_pet_with_form( monkey.id, new_name, "available", func(result): @@ -174,12 +179,16 @@ func run_test_02(): Logger.inform("Running test 02…") var pet_api := DemoPetApi.new() - pet_api.bee_port = 8081 + pet_api.bee_config = cfg pet_api.find_pets_by_status( ['available'], func(result): prints("Found some pets.") prints(result) + if not (result is Array): + fail("Expected an array as result.") + if result.size() == 0: + fail("Expected some pets in the result.") emit_signal("test_ended") , func(error): diff --git a/samples/client/petstore/gdscript/project.godot b/samples/client/petstore/gdscript/project.godot index 904dffdfc2d2..6101e9b51455 100644 --- a/samples/client/petstore/gdscript/project.godot +++ b/samples/client/petstore/gdscript/project.godot @@ -15,6 +15,11 @@ _global_script_classes=[{ "path": "res://core/DemoApiBee.gd" }, { "base": "Resource", +"class": &"DemoApiConfig", +"language": &"GDScript", +"path": "res://core/DemoApiConfig.gd" +}, { +"base": "Resource", "class": &"DemoApiError", "language": &"GDScript", "path": "res://core/DemoApiError.gd" @@ -66,6 +71,7 @@ _global_script_classes=[{ }] _global_script_class_icons={ "DemoApiBee": "", +"DemoApiConfig": "", "DemoApiError": "", "DemoApiResponse": "", "DemoCategory": "", From 04f4d3f1930ccd9359b8946503daa84d0c0369ef Mon Sep 17 00:00:00 2001 From: Goutte Date: Sun, 23 Oct 2022 01:42:16 +0200 Subject: [PATCH 20/56] docs(gdscript): document usage a little --- .../main/resources/gdscript/README.handlebars | 17 +++- .../gdscript/api_doc_example.handlebars | 12 ++- samples/client/petstore/gdscript/README.md | 32 +++++++- .../petstore/gdscript/apis/DemoPetApi.md | 80 ++++++++----------- .../petstore/gdscript/apis/DemoStoreApi.md | 40 ++++------ .../petstore/gdscript/apis/DemoUserApi.md | 80 ++++++++----------- 6 files changed, 127 insertions(+), 134 deletions(-) diff --git a/modules/openapi-generator/src/main/resources/gdscript/README.handlebars b/modules/openapi-generator/src/main/resources/gdscript/README.handlebars index d67d9158100a..11af22ad8706 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/README.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/README.handlebars @@ -35,10 +35,19 @@ Then, enable the addon in your project settings. You can now use it anywhere in your code: -```gdscript -# TODO -var -``` +{{#with apiInfo}} +{{#each apis}} +{{#if @first}} +{{#with operations}} +{{#each operation}} +{{#if @first}} +{{>api_doc_example}} +{{/if}} +{{/each}} +{{/with}} +{{/if}} +{{/each}} +{{/with}} ## Documentation for API Endpoints diff --git a/modules/openapi-generator/src/main/resources/gdscript/api_doc_example.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api_doc_example.handlebars index b3bfd88c1d0c..58fa1175ff15 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/api_doc_example.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/api_doc_example.handlebars @@ -3,15 +3,13 @@ {{> doc_auth_partial}} --}} -var api = {{{classname}}}.new() -api.bee_host = "localhost" # customize host if needed -api.bee_port = 8080 # use the factory to share configs - -# Customize configuration, if needed (TODO) -var config := {{coreNamePrefix}}ApiConfig.new() +# Customize configuration, if needed +var config := {{>partials/api_config_class_name}}.new() config.host = "localhost" config.port = 8080 -api.config = config + +var api = {{{classname}}}.new() +api.config = config # optionally {{#each bodyParams}} {{#if dataType}} diff --git a/samples/client/petstore/gdscript/README.md b/samples/client/petstore/gdscript/README.md index 09bcb9c5be14..04819f0d3c11 100644 --- a/samples/client/petstore/gdscript/README.md +++ b/samples/client/petstore/gdscript/README.md @@ -1,6 +1,6 @@ # OpenAPI Petstore GDScript Client - This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters. +This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters. This Godot 4 addon is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: @@ -24,8 +24,34 @@ Then, enable the addon in your project settings. You can now use it anywhere in your code: ```gdscript -# TODO -var + +# Customize configuration, if needed +var config := DemoApiConfig.new() +config.host = "localhost" +config.port = 8080 + +var api = DemoPetApi.new() +api.config = config # optionally + +var demoPet = DemoPet.new() +# … fill model with data + +api.add_pet( + # demoPet: DemoPet + # Pet object that needs to be added to the store + demoPet, + # On Success + func(result): # result is DemoPet + prints("Success!", result) + pass # do things + , + # On Error + func(error): # error is DemoApiError + printerr(str(error)) + pass # do things + , +) + ``` diff --git a/samples/client/petstore/gdscript/apis/DemoPetApi.md b/samples/client/petstore/gdscript/apis/DemoPetApi.md index da8a344e8d11..57602c757c2d 100644 --- a/samples/client/petstore/gdscript/apis/DemoPetApi.md +++ b/samples/client/petstore/gdscript/apis/DemoPetApi.md @@ -30,15 +30,13 @@ Add a new pet to the store ```gdscript -var api = DemoPetApi.new() -api.bee_host = "localhost" # customize host if needed -api.bee_port = 8080 # use the factory to share configs - -# Customize configuration, if needed (TODO) +# Customize configuration, if needed var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 -api.config = config + +var api = DemoPetApi.new() +api.config = config # optionally var demoPet = DemoPet.new() # … fill model with data @@ -76,15 +74,13 @@ Deletes a pet ```gdscript -var api = DemoPetApi.new() -api.bee_host = "localhost" # customize host if needed -api.bee_port = 8080 # use the factory to share configs - -# Customize configuration, if needed (TODO) +# Customize configuration, if needed var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 -api.config = config + +var api = DemoPetApi.new() +api.config = config # optionally api.delete_pet( @@ -123,15 +119,13 @@ Multiple status values can be provided with comma separated strings ```gdscript -var api = DemoPetApi.new() -api.bee_host = "localhost" # customize host if needed -api.bee_port = 8080 # use the factory to share configs - -# Customize configuration, if needed (TODO) +# Customize configuration, if needed var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 -api.config = config + +var api = DemoPetApi.new() +api.config = config # optionally api.find_pets_by_status( @@ -167,15 +161,13 @@ Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 ```gdscript -var api = DemoPetApi.new() -api.bee_host = "localhost" # customize host if needed -api.bee_port = 8080 # use the factory to share configs - -# Customize configuration, if needed (TODO) +# Customize configuration, if needed var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 -api.config = config + +var api = DemoPetApi.new() +api.config = config # optionally api.find_pets_by_tags( @@ -211,15 +203,13 @@ Returns a single pet ```gdscript -var api = DemoPetApi.new() -api.bee_host = "localhost" # customize host if needed -api.bee_port = 8080 # use the factory to share configs - -# Customize configuration, if needed (TODO) +# Customize configuration, if needed var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 -api.config = config + +var api = DemoPetApi.new() +api.config = config # optionally api.get_pet_by_id( @@ -255,15 +245,13 @@ Update an existing pet ```gdscript -var api = DemoPetApi.new() -api.bee_host = "localhost" # customize host if needed -api.bee_port = 8080 # use the factory to share configs - -# Customize configuration, if needed (TODO) +# Customize configuration, if needed var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 -api.config = config + +var api = DemoPetApi.new() +api.config = config # optionally var demoPet = DemoPet.new() # … fill model with data @@ -301,15 +289,13 @@ Updates a pet in the store with form data ```gdscript -var api = DemoPetApi.new() -api.bee_host = "localhost" # customize host if needed -api.bee_port = 8080 # use the factory to share configs - -# Customize configuration, if needed (TODO) +# Customize configuration, if needed var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 -api.config = config + +var api = DemoPetApi.new() +api.config = config # optionally api.update_pet_with_form( @@ -351,15 +337,13 @@ uploads an image ```gdscript -var api = DemoPetApi.new() -api.bee_host = "localhost" # customize host if needed -api.bee_port = 8080 # use the factory to share configs - -# Customize configuration, if needed (TODO) +# Customize configuration, if needed var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 -api.config = config + +var api = DemoPetApi.new() +api.config = config # optionally api.upload_file( diff --git a/samples/client/petstore/gdscript/apis/DemoStoreApi.md b/samples/client/petstore/gdscript/apis/DemoStoreApi.md index e8b055033985..31ed94ff4bfe 100644 --- a/samples/client/petstore/gdscript/apis/DemoStoreApi.md +++ b/samples/client/petstore/gdscript/apis/DemoStoreApi.md @@ -25,15 +25,13 @@ For valid response try integer IDs with value < 1000. Anything above 1000 or non ```gdscript -var api = DemoStoreApi.new() -api.bee_host = "localhost" # customize host if needed -api.bee_port = 8080 # use the factory to share configs - -# Customize configuration, if needed (TODO) +# Customize configuration, if needed var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 -api.config = config + +var api = DemoStoreApi.new() +api.config = config # optionally api.delete_order( @@ -69,15 +67,13 @@ Returns a map of status codes to quantities ```gdscript -var api = DemoStoreApi.new() -api.bee_host = "localhost" # customize host if needed -api.bee_port = 8080 # use the factory to share configs - -# Customize configuration, if needed (TODO) +# Customize configuration, if needed var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 -api.config = config + +var api = DemoStoreApi.new() +api.config = config # optionally api.get_inventory( @@ -109,15 +105,13 @@ For valid response try integer IDs with value <= 5 or > 10. Other values will ge ```gdscript -var api = DemoStoreApi.new() -api.bee_host = "localhost" # customize host if needed -api.bee_port = 8080 # use the factory to share configs - -# Customize configuration, if needed (TODO) +# Customize configuration, if needed var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 -api.config = config + +var api = DemoStoreApi.new() +api.config = config # optionally api.get_order_by_id( @@ -152,15 +146,13 @@ Place an order for a pet ```gdscript -var api = DemoStoreApi.new() -api.bee_host = "localhost" # customize host if needed -api.bee_port = 8080 # use the factory to share configs - -# Customize configuration, if needed (TODO) +# Customize configuration, if needed var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 -api.config = config + +var api = DemoStoreApi.new() +api.config = config # optionally var demoOrder = DemoOrder.new() # … fill model with data diff --git a/samples/client/petstore/gdscript/apis/DemoUserApi.md b/samples/client/petstore/gdscript/apis/DemoUserApi.md index a8b1ac39f694..be27c56a6a15 100644 --- a/samples/client/petstore/gdscript/apis/DemoUserApi.md +++ b/samples/client/petstore/gdscript/apis/DemoUserApi.md @@ -30,15 +30,13 @@ This can only be done by the logged in user. ```gdscript -var api = DemoUserApi.new() -api.bee_host = "localhost" # customize host if needed -api.bee_port = 8080 # use the factory to share configs - -# Customize configuration, if needed (TODO) +# Customize configuration, if needed var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 -api.config = config + +var api = DemoUserApi.new() +api.config = config # optionally var demoUser = DemoUser.new() # … fill model with data @@ -76,15 +74,13 @@ Creates list of users with given input array ```gdscript -var api = DemoUserApi.new() -api.bee_host = "localhost" # customize host if needed -api.bee_port = 8080 # use the factory to share configs - -# Customize configuration, if needed (TODO) +# Customize configuration, if needed var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 -api.config = config + +var api = DemoUserApi.new() +api.config = config # optionally api.create_users_with_array_input( @@ -120,15 +116,13 @@ Creates list of users with given input array ```gdscript -var api = DemoUserApi.new() -api.bee_host = "localhost" # customize host if needed -api.bee_port = 8080 # use the factory to share configs - -# Customize configuration, if needed (TODO) +# Customize configuration, if needed var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 -api.config = config + +var api = DemoUserApi.new() +api.config = config # optionally api.create_users_with_list_input( @@ -164,15 +158,13 @@ This can only be done by the logged in user. ```gdscript -var api = DemoUserApi.new() -api.bee_host = "localhost" # customize host if needed -api.bee_port = 8080 # use the factory to share configs - -# Customize configuration, if needed (TODO) +# Customize configuration, if needed var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 -api.config = config + +var api = DemoUserApi.new() +api.config = config # optionally api.delete_user( @@ -207,15 +199,13 @@ Get user by user name ```gdscript -var api = DemoUserApi.new() -api.bee_host = "localhost" # customize host if needed -api.bee_port = 8080 # use the factory to share configs - -# Customize configuration, if needed (TODO) +# Customize configuration, if needed var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 -api.config = config + +var api = DemoUserApi.new() +api.config = config # optionally api.get_user_by_name( @@ -250,15 +240,13 @@ Logs user into the system ```gdscript -var api = DemoUserApi.new() -api.bee_host = "localhost" # customize host if needed -api.bee_port = 8080 # use the factory to share configs - -# Customize configuration, if needed (TODO) +# Customize configuration, if needed var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 -api.config = config + +var api = DemoUserApi.new() +api.config = config # optionally api.login_user( @@ -297,15 +285,13 @@ Logs out current logged in user session ```gdscript -var api = DemoUserApi.new() -api.bee_host = "localhost" # customize host if needed -api.bee_port = 8080 # use the factory to share configs - -# Customize configuration, if needed (TODO) +# Customize configuration, if needed var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 -api.config = config + +var api = DemoUserApi.new() +api.config = config # optionally api.logout_user( @@ -338,15 +324,13 @@ This can only be done by the logged in user. ```gdscript -var api = DemoUserApi.new() -api.bee_host = "localhost" # customize host if needed -api.bee_port = 8080 # use the factory to share configs - -# Customize configuration, if needed (TODO) +# Customize configuration, if needed var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 -api.config = config + +var api = DemoUserApi.new() +api.config = config # optionally var demoUser = DemoUser.new() # … fill model with data From a7bc60e945f167292935edaac6b8007be9c6f488 Mon Sep 17 00:00:00 2001 From: Goutte Date: Wed, 2 Nov 2022 08:38:16 +0100 Subject: [PATCH 21/56] feat(gdscript): add more reserved words, skip jsonld models and configure features We can now generate a client for an OAS server running ApiPlatform (PHP). --- .../languages/GdscriptClientCodegen.java | 980 +++++++++++++++++- .../main/resources/gdscript/ApiBee.handlebars | 24 +- .../resources/gdscript/ApiConfig.handlebars | 24 +- .../main/resources/gdscript/api.handlebars | 2 +- 4 files changed, 980 insertions(+), 50 deletions(-) diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java index 67776feb9008..b0205f4cf764 100644 --- a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java +++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java @@ -2,15 +2,13 @@ import io.swagger.v3.oas.models.media.Schema; import org.openapitools.codegen.*; -//import io.swagger.models.properties.ArrayProperty; -//import io.swagger.models.properties.Property; -//import io.swagger.models.parameters.Parameter; import java.io.File; -import java.util.Arrays; -import java.util.List; +import java.util.*; import org.openapitools.codegen.api.TemplatingEngineAdapter; +import org.openapitools.codegen.meta.features.*; +import org.openapitools.codegen.model.ModelsMap; import org.openapitools.codegen.templating.HandlebarsEngineAdapter; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -68,10 +66,113 @@ public String getHelp() { public GdscriptClientCodegen() { super(); + modifyFeatureSet(features -> features + .includeSchemaSupportFeatures( + SchemaSupportFeature.Simple, + SchemaSupportFeature.Composite + ) + .excludeSchemaSupportFeatures( + SchemaSupportFeature.Polymorphism, + SchemaSupportFeature.Union, + SchemaSupportFeature.allOf, + SchemaSupportFeature.anyOf, + SchemaSupportFeature.oneOf, + SchemaSupportFeature.not + ) + .includeDocumentationFeatures( + DocumentationFeature.Readme + ) + .includeWireFormatFeatures( + WireFormatFeature.JSON + ) + .excludeWireFormatFeatures( + WireFormatFeature.Custom, + WireFormatFeature.XML, + WireFormatFeature.PROTOBUF + ) + .includeSecurityFeatures( + SecurityFeature.BearerToken, + SecurityFeature.ApiKey, + SecurityFeature.OAuth2_Implicit // untested + ) + .excludeSecurityFeatures( + SecurityFeature.BasicAuth // desired + ) + .includeDataTypeFeatures( + DataTypeFeature.Array, + DataTypeFeature.ArrayOfModel, + DataTypeFeature.Binary, + DataTypeFeature.Boolean, + DataTypeFeature.Byte, + DataTypeFeature.Custom, // help (?) + DataTypeFeature.Date, + DataTypeFeature.DateTime, + DataTypeFeature.Decimal, + DataTypeFeature.Double, + DataTypeFeature.Enum, + DataTypeFeature.File, // untested + DataTypeFeature.Float, + DataTypeFeature.Int32, + DataTypeFeature.Int64, + DataTypeFeature.Null, + DataTypeFeature.Object, + DataTypeFeature.Password, + DataTypeFeature.String, + DataTypeFeature.Uuid + ) + .excludeDataTypeFeatures( + DataTypeFeature.AnyType, // Variant will be there eventually + DataTypeFeature.ArrayOfCollectionOfEnum, + DataTypeFeature.ArrayOfCollectionOfModel, + DataTypeFeature.ArrayOfCollectionOfPrimitives, + DataTypeFeature.ArrayOfEnum, + DataTypeFeature.CollectionFormat, + DataTypeFeature.CollectionFormatMulti, + DataTypeFeature.MapOfCollectionOfEnum, + DataTypeFeature.MapOfCollectionOfModel, + DataTypeFeature.MapOfCollectionOfPrimitives, + DataTypeFeature.MapOfEnum, + DataTypeFeature.MapOfModel, + DataTypeFeature.Maps + ) + .includeGlobalFeatures( + GlobalFeature.BasePath, + GlobalFeature.Examples, + GlobalFeature.ExternalDocumentation, + GlobalFeature.Host, + GlobalFeature.Info, + GlobalFeature.Produces, + GlobalFeature.Consumes, + GlobalFeature.Schemes, + GlobalFeature.ParameterStyling + ) + .excludeGlobalFeatures( + GlobalFeature.Callbacks, + GlobalFeature.ParameterizedServer, + GlobalFeature.MultiServer, + GlobalFeature.LinkObjects, + GlobalFeature.XMLStructureDefinitions + ) + .includeParameterFeatures( + ParameterFeature.Body, + ParameterFeature.Path, + ParameterFeature.Header, + ParameterFeature.FormUnencoded, + ParameterFeature.Query + ) + .excludeParameterFeatures( + ParameterFeature.FormMultipart, + ParameterFeature.Cookie + ) + ); + // It makes sense to package the generated code like a Godot addon, for ease of installation. - // Since most users will set the output dir, we need to document that fact. - String addonName = "oas." + "petstore"; // TODO: replace "petstore" from CLI or YAML or both (how?) - outputFolder = "generated-code" + File.separator + "gdscript" + File.separator + "addons" + File.separator + addonName; + // Since most users will set the output dir, we perhaps ought to to document that fact. + String addonName = "goas.client"; + outputFolder = "generated-code" + + File.separator + "gdscript" + + File.separator + "addons" + + File.separator + addonName; embeddedTemplateDir = templateDir = "gdscript"; apiPackage = "apis"; modelPackage = "models"; @@ -79,7 +180,7 @@ public GdscriptClientCodegen() { modelTemplateFiles.put("model.handlebars", ".gd"); apiTemplateFiles.put("api.handlebars", ".gd"); apiDocTemplateFiles.put("api_doc.handlebars", ".md"); - // more supported files are defined in processOpts() (for coreNamePrefix) + // more supported files are defined in processOpts() (they use coreNamePrefix) setReservedWordsLowerCase(getReservedWords()); @@ -100,21 +201,24 @@ public GdscriptClientCodegen() { typeMapping.put("map", "Dictionary"); typeMapping.put("set", "Array"); // No timezone support in Godot so I'm skipping Datetimes for now + // We might at some point enable datetime support for UTC (non-timezoned) typeMapping.put("date", "String"); typeMapping.put("datetime", "String"); + typeMapping.put("DateTime", "String"); // case matters (format: date-time) + typeMapping.put("date-time", "String"); // possibly useless //typeMapping.put("binary", "any"); - typeMapping.put("file", "String"); // untested- + typeMapping.put("file", "String"); // untested typeMapping.put("ByteArray", "Array"); typeMapping.put("UUID", "String"); //typeMapping.put("Error", "Error"); //typeMapping.put("AnyType", "Variant"); - - //cliOptions.add(new CliOption(PROJECT_NAME, "The name of the project !!")); cliOptions.add(new CliOption(CORE_NAME_PREFIX, "PascalCase prefix added to all core classes")); cliOptions.add(new CliOption(CORE_NAME_SUFFIX, "PascalCase suffix added to all core classes")); // This constructor is ran twice, because … reasons. + // Also, I have not taken care of escaping things properly in the templates. + // I'm not sure how to handle the different escaping strategies required. LOGGER.warn("---- THIS GENERATOR IS UNSAFE AND MALICIOUS OAS FILES MAY HURT YOU ----"); LOGGER.warn("PLEASE READ *CAREFULLY* THE OAS FILE YOU ARE USING BEFORE YOU TRUST IT."); LOGGER.info("This generation itself should be safe but maybe not the generated code."); @@ -132,6 +236,8 @@ public void processAdditionalProperties() { additionalProperties.put("apiDocPath", apiDocPath); additionalProperties.put("modelDocPath", modelDocPath); + additionalProperties.put("modelNameSuffix", modelNameSuffix); + if (additionalProperties.containsKey(CORE_NAME_PREFIX)) { setCoreNamePrefix((String) additionalProperties.get(CORE_NAME_PREFIX)); } else { @@ -161,7 +267,7 @@ public void processOpts() { if (templatingEngine instanceof HandlebarsEngineAdapter) { HandlebarsEngineAdapter handlebars = (HandlebarsEngineAdapter) templatingEngine; //handlebars.infiniteLoops(true); // will we want this eventually? - handlebars.setPrettyPrint(true); // removes blank lines from flow tags + handlebars.setPrettyPrint(true); // removes blank lines left by flow control tags } else { throw new RuntimeException("Only the HandlebarsEngineAdapter is supported for this generator"); } @@ -170,7 +276,7 @@ public void processOpts() { @Override public String escapeUnsafeCharacters(String input) { // There might be ways to inject code in Gdscript, but I don't see any for now. (no /* */ comments) - // TODO: review this with someone else + // TODO: review this with someone knowledgeable return input; } @@ -178,7 +284,7 @@ public String escapeUnsafeCharacters(String input) { public String escapeQuotationMark(String input) { // I've seen some other targets REMOVE the quotation marks altogether. // We might need to do that as well ? - // TODO: review this with someone else + // TODO: review this with someone knowledgeable return input .replace("\"", "\\\"") .replace("'", "\\'") @@ -208,16 +314,21 @@ public String modelDocFileFolder() { } - // When example is "null" (with quotes), mustache's {{#example}} triggers // Not sure why this happens on {{#example}} but not {{#description}} // Perhaps I'm just using mustache wrong… Anyway, it's voodoo. // Also, even with this fix, {{#example}} still triggers. // → That just because of how mustache works. (false or [] only) // → I'll switch to handlebars. - // → Pebble would perhaps help reduce injections, with custom filters + // → Pebble would perhaps help reduce injections, with custom escaping filters for each context: + // → Comments + // → Variable names + // → Function names + // → Quoted + // → Typed values (int, etc.) // → Handlebars also has a discrepancy between description and example, both 'null' // → We need this (hot?)fix in the end. + // → Or not, there's a {{#hasExamples}} we could perhaps use @Override public String toExampleValue(Schema schema) { if (schema.getExample() != null) { @@ -237,20 +348,46 @@ public String toDefaultValue(Schema schema) { return ""; } - // We are generous with the keywords, but what is actually accepted by GDScript ir more lenient - // than what is properly highlighted in the editor. Readability matters ? + // ApiPlatform for example generates `SomeModel.jsonld` models. + // We do not support jsonld for now, so we are skipping them. + @Override + public Map updateAllModels(Map objs) { + objs = super.updateAllModels(objs); + + String[] names = objs.keySet().toArray(new String[0]); + for (String modelName : names) { + // Skip models with underscores, responses and @context in jsonld + // eg: api_somemodel_get_collection_200_response, SomeModel_jsonld__context + if (modelName.contains("_")) { + objs.remove(modelName); + LOGGER.warn("Skipped model " + modelName + " (underscore not supported)"); + } + // Skip models with jsonld, we don't support them atm + // eg: Announcement.jsonld + if (modelName.contains("jsonld")) { + objs.remove(modelName); + LOGGER.warn("Skipped model " + modelName + " (jsonld not supported)"); + } + // Also skip Hydra models, we're not supporting them atm + if (modelName.contains("Hydra")) { + objs.remove(modelName); + LOGGER.warn("Skipped model " + modelName + " (hydra not supported)"); + } + } + + return objs; + } + protected List getReservedWords() { - // FIXME: Missing Nodes and other Objects globally available (RefCounted, Sprite2D, etc.) - // FIXME: Missing primitive types (Rect…) return Arrays.asList( // Local properties used in Model classes "bee_class_name", // Local method names used in base API class "bee_connect_client_if_needed", "bee_request", "bee_request_text", "bee_do_request_text", "bee_convert_http_method", "bee_urlize_path_param", "bee_escape_path_param", - "bee_next_loop_iteration", "bee_enable_ssl", "bee_disable_ssl", + "bee_next_loop_iteration", "bee_get_content_type", "bee_format_error_response", // Local properties used in base API class - "bee_client", "bee_host", "bee_port", "bee_name", + "bee_config", "bee_client", "bee_name", // Local variable names used in API methods (endpoints) "bzz_method", "bzz_path", "bzz_query", "bzz_result", "bzz_code", "bzz_headers", @@ -431,9 +568,800 @@ protected List getReservedWords() { // Constants "PI", "TAU", "INF", "NaN", - // Types TODO: extract all types from somewhere ; we're going to need all the Nodes, as well ?! - "float", "int", "String", "bool", "Dictionary", "Array", "Color", - "Quat", "Vector2", "Vector3", "Transform" + "float", "int", "bool", + + "AABB", + "AcceptDialog", + "AESContext", + "AnimatableBody2D", + "AnimatableBody3D", + "AnimatedSprite2D", + "AnimatedSprite3D", + "AnimatedTexture", + "AnimationLibrary", + "AnimationNodeAdd2", + "AnimationNodeAdd3", + "AnimationNodeAnimation", + "AnimationNodeBlend2", + "AnimationNodeBlend3", + "AnimationNodeBlendSpace1D", + "AnimationNodeBlendSpace2D", + "AnimationNodeBlendTree", + "AnimationNodeOneShot", + "AnimationNodeOutput", + "AnimationNodeStateMachinePlayback", + "AnimationNodeStateMachineTransition", + "AnimationNodeStateMachine", + "AnimationNodeSync", + "AnimationNodeTimeScale", + "AnimationNodeTimeSeek", + "AnimationNodeTransition", + "AnimationNode", + "AnimationPlayer", + "AnimationRootNode", + "AnimationTrackEditPlugin", + "AnimationTree", + "Animation", + "Area2D", + "Area3D", + "ArrayMesh", + "ArrayOccluder3D", + "AspectRatioContainer", + "AStar2D", + "AStar3D", + "AStarGrid2D", + "AtlasTexture", + "AudioBusLayout", + "AudioEffectAmplify", + "AudioEffectBandLimitFilter", + "AudioEffectBandPassFilter", + "AudioEffectCapture", + "AudioEffectChorus", + "AudioEffectCompressor", + "AudioEffectDelay", + "AudioEffectDistortion", + "AudioEffectEQ10", + "AudioEffectEQ21", + "AudioEffectEQ6", + "AudioEffectEQ", + "AudioEffectFilter", + "AudioEffectHighPassFilter", + "AudioEffectHighShelfFilter", + "AudioEffectInstance", + "AudioEffectLimiter", + "AudioEffectLowPassFilter", + "AudioEffectLowShelfFilter", + "AudioEffectNotchFilter", + "AudioEffectPanner", + "AudioEffectPhaser", + "AudioEffectPitchShift", + "AudioEffectRecord", + "AudioEffectReverb", + "AudioEffectSpectrumAnalyzerInstance", + "AudioEffectSpectrumAnalyzer", + "AudioEffectStereoEnhance", + "AudioEffect", + "AudioListener2D", + "AudioListener3D", + "AudioServer", + "AudioStreamGeneratorPlayback", + "AudioStreamGenerator", + "AudioStreamMicrophone", + "AudioStreamPlaybackResampled", + "AudioStreamPlayback", + "AudioStreamPlayer2D", + "AudioStreamPlayer3D", + "AudioStreamPlayer", + "AudioStreamRandomizer", + "AudioStreamWAV", + "AudioStream", + "BackBufferCopy", + "BaseButton", + "BaseMaterial3D", + "Basis", + "BitMap", + "Bone2D", + "BoneAttachment3D", + "BoneMap", + "BoxContainer", + "BoxMesh", + "BoxOccluder3D", + "BoxShape3D", + "ButtonGroup", + "Button", + "Callable", + "CallbackTweener", + "Camera2D", + "Camera3D", + "CameraAttributesPhysical", + "CameraAttributesPractical", + "CameraAttributes", + "CameraFeed", + "CameraServer", + "CameraTexture", + "CanvasGroup", + "CanvasItemMaterial", + "CanvasItem", + "CanvasLayer", + "CanvasModulate", + "CanvasTexture", + "CapsuleMesh", + "CapsuleShape2D", + "CapsuleShape3D", + "CenterContainer", + "CharacterBody2D", + "CharacterBody3D", + "CharFXTransform", + "CheckBox", + "CheckButton", + "CircleShape2D", + "ClassDB", + "CodeEdit", + "CodeHighlighter", + "CollisionObject2D", + "CollisionObject3D", + "CollisionPolygon2D", + "CollisionPolygon3D", + "CollisionShape2D", + "CollisionShape3D", + "ColorPickerButton", + "ColorPicker", + "ColorRect", + "Color", + "CompressedCubemapArray", + "CompressedCubemap", + "CompressedTexture2DArray", + "CompressedTexture2D", + "CompressedTexture3D", + "CompressedTextureLayered", + "ConcavePolygonShape2D", + "ConcavePolygonShape3D", + "ConeTwistJoint3D", + "ConfigFile", + "ConfirmationDialog", + "Container", + "Control", + "ConvexPolygonShape2D", + "ConvexPolygonShape3D", + "CPUParticles2D", + "CPUParticles3D", + "CryptoKey", + "Crypto", + "CubemapArray", + "Cubemap", + "Curve2D", + "Curve3D", + "CurveTexture", + "Curve", + "CurveXYZTexture", + "CylinderMesh", + "CylinderShape3D", + "DampedSpringJoint2D", + "Decal", + "Dictionary", + "DirAccess", + "DirectionalLight2D", + "DirectionalLight3D", + "DisplayServer", + "DTLSServer", + "EditorCommandPalette", + "EditorDebuggerPlugin", + "EditorExportPlatform", + "EditorExportPlugin", + "EditorFeatureProfile", + "EditorFileDialog", + "EditorFileSystemDirectory", + "EditorFileSystemImportFormatSupportQuery", + "EditorFileSystem", + "EditorImportPlugin", + "EditorInspectorPlugin", + "EditorInspector", + "EditorInterface", + "EditorNode3DGizmoPlugin", + "EditorNode3DGizmo", + "EditorPaths", + "EditorPlugin", + "EditorProperty", + "EditorResourceConversionPlugin", + "EditorResourcePicker", + "EditorResourcePreviewGenerator", + "EditorResourcePreview", + "EditorSceneFormatImporter", + "EditorScenePostImportPlugin", + "EditorScenePostImport", + "EditorScriptPicker", + "EditorScript", + "EditorSelection", + "EditorSettings", + "EditorSpinSlider", + "EditorSyntaxHighlighter", + "EditorTranslationParserPlugin", + "EditorUndoRedoManager", + "EditorVCSInterface", + "EncodedObjectAsID", + "EngineDebugger", + "EngineProfiler", + "Engine", + "Environment", + "Expression", + "FileAccess", + "FileDialog", + "FileSystemDock", + "FlowContainer", + "FogMaterial", + "FogVolume", + "FontFile", + "FontVariation", + "Font", + "Generic6DOFJoint3D", + "Geometry2D", + "Geometry3D", + "GeometryInstance3D", + "GPUParticles2D", + "GPUParticles3D", + "GPUParticlesAttractor3D", + "GPUParticlesAttractorBox3D", + "GPUParticlesAttractorSphere3D", + "GPUParticlesAttractorVectorField3D", + "GPUParticlesCollision3D", + "GPUParticlesCollisionBox3D", + "GPUParticlesCollisionHeightField3D", + "GPUParticlesCollisionSDF3D", + "GPUParticlesCollisionSphere3D", + "GradientTexture1D", + "GradientTexture2D", + "Gradient", + "GraphEdit", + "GraphNode", + "GridContainer", + "GrooveJoint2D", + "HashingContext", + "HBoxContainer", + "HeightMapShape3D", + "HFlowContainer", + "HingeJoint3D", + "HMACContext", + "HScrollBar", + "HSeparator", + "HSlider", + "HSplitContainer", + "HTTPClient", + "HTTPRequest", + "ImageFormatLoaderExtension", + "ImageFormatLoader", + "ImageTexture3D", + "ImageTextureLayered", + "ImageTexture", + "Image", + "ImmediateMesh", + "ImporterMeshInstance3D", + "ImporterMesh", + "InputEventAction", + "InputEventFromWindow", + "InputEventGesture", + "InputEventJoypadButton", + "InputEventJoypadMotion", + "InputEventKey", + "InputEventMagnifyGesture", + "InputEventMIDI", + "InputEventMouseButton", + "InputEventMouseMotion", + "InputEventMouse", + "InputEventPanGesture", + "InputEventScreenDrag", + "InputEventScreenTouch", + "InputEventShortcut", + "InputEventWithModifiers", + "InputEvent", + "InputMap", + "Input", + "InstancePlaceholder", + "IntervalTweener", + "IP", + "ItemList", + "JavaClassWrapper", + "JavaClass", + "JavaScriptBridge", + "JavaScriptObject", + "JNISingleton", + "Joint2D", + "Joint3D", + "JSONRPC", + "JSON", + "KinematicCollision2D", + "KinematicCollision3D", + "Label3D", + "LabelSettings", + "Label", + "Light2D", + "Light3D", + "LightmapGIData", + "LightmapGI", + "LightmapperRD", + "Lightmapper", + "LightmapProbe", + "LightOccluder2D", + "Line2D", + "LineEdit", + "LinkButton", + "MainLoop", + "MarginContainer", + "Marker2D", + "Marker3D", + "Marshalls", + "Material", + "MenuBar", + "MenuButton", + "MeshDataTool", + "MeshInstance2D", + "MeshInstance3D", + "MeshLibrary", + "MeshTexture", + "Mesh", + "MethodTweener", + "MissingNode", + "MissingResource", + "MovieWriter", + "MultiMeshInstance2D", + "MultiMeshInstance3D", + "MultiMesh", + "MultiplayerAPIExtension", + "MultiplayerAPI", + "MultiplayerPeerExtension", + "MultiplayerPeer", + "Mutex", + "NativeExtensionManager", + "NativeExtension", + "NavigationAgent2D", + "NavigationAgent3D", + "NavigationLink2D", + "NavigationLink3D", + "NavigationMeshGenerator", + "NavigationMesh", + "NavigationObstacle2D", + "NavigationObstacle3D", + "NavigationPathQueryParameters2D", + "NavigationPathQueryParameters3D", + "NavigationPathQueryResult2D", + "NavigationPathQueryResult3D", + "NavigationPolygon", + "NavigationRegion2D", + "NavigationRegion3D", + "NavigationServer2D", + "NavigationServer3D", + "NinePatchRect", + "Node2D", + "Node3DGizmo", + "Node3D", + "NodePath", + "Node", + "Object", + "Occluder3D", + "OccluderInstance3D", + "OccluderPolygon2D", + "OmniLight3D", + "OptimizedTranslation", + "OptionButton", + "ORMMaterial3D", + "OS", + "PackedByteArray", + "PackedColorArray", + "PackedDataContainerRef", + "PackedDataContainer", + "PackedFloat32Array", + "PackedFloat64Array", + "PackedInt32Array", + "PackedInt64Array", + "PackedScene", + "PackedStringArray", + "PackedVector2Array", + "PackedVector3Array", + "PacketPeerDTLS", + "PacketPeerExtension", + "PacketPeerStream", + "PacketPeerUDP", + "PacketPeer", + "PanelContainer", + "Panel", + "PanoramaSkyMaterial", + "ParallaxBackground", + "ParallaxLayer", + "ParticleProcessMaterial", + "Path2D", + "Path3D", + "PathFollow2D", + "PathFollow3D", + "PCKPacker", + "Performance", + "PhysicalBone2D", + "PhysicalBone3D", + "PhysicalSkyMaterial", + "PhysicsBody2D", + "PhysicsBody3D", + "PhysicsDirectBodyState2DExtension", + "PhysicsDirectBodyState2D", + "PhysicsDirectBodyState3DExtension", + "PhysicsDirectBodyState3D", + "PhysicsDirectSpaceState2DExtension", + "PhysicsDirectSpaceState2D", + "PhysicsDirectSpaceState3DExtension", + "PhysicsDirectSpaceState3D", + "PhysicsMaterial", + "PhysicsPointQueryParameters2D", + "PhysicsPointQueryParameters3D", + "PhysicsRayQueryParameters2D", + "PhysicsRayQueryParameters3D", + "PhysicsServer2DExtension", + "PhysicsServer2DManager", + "PhysicsServer2D", + "PhysicsServer3DExtension", + "PhysicsServer3DManager", + "PhysicsServer3DRenderingServerHandler", + "PhysicsServer3D", + "PhysicsShapeQueryParameters2D", + "PhysicsShapeQueryParameters3D", + "PhysicsTestMotionParameters2D", + "PhysicsTestMotionParameters3D", + "PhysicsTestMotionResult2D", + "PhysicsTestMotionResult3D", + "PinJoint2D", + "PinJoint3D", + "PlaceholderCubemapArray", + "PlaceholderCubemap", + "PlaceholderMaterial", + "PlaceholderMesh", + "PlaceholderTexture2DArray", + "PlaceholderTexture2D", + "PlaceholderTexture3D", + "PlaceholderTextureLayered", + "PlaneMesh", + "Plane", + "PointLight2D", + "PointMesh", + "Polygon2D", + "PolygonOccluder3D", + "PolygonPathFinder", + "PopupMenu", + "PopupPanel", + "Popup", + "PortableCompressedTexture2D", + "PrimitiveMesh", + "PrismMesh", + "ProceduralSkyMaterial", + "ProgressBar", + "Projection", + "ProjectSettings", + "PropertyTweener", + "QuadMesh", + "QuadOccluder3D", + "Quaternion", + "RandomNumberGenerator", + "Range", + "RayCast2D", + "RayCast3D", + "RDAttachmentFormat", + "RDFramebufferPass", + "RDPipelineColorBlendStateAttachment", + "RDPipelineColorBlendState", + "RDPipelineDepthStencilState", + "RDPipelineMultisampleState", + "RDPipelineRasterizationState", + "RDPipelineSpecializationConstant", + "RDSamplerState", + "RDShaderFile", + "RDShaderSource", + "RDShaderSPIRV", + "RDTextureFormat", + "RDTextureView", + "RDUniform", + "RDVertexAttribute", + "Rect2i", + "Rect2", + "RectangleShape2D", + "RefCounted", + "ReferenceRect", + "ReflectionProbe", + "RemoteTransform2D", + "RemoteTransform3D", + "RenderingDevice", + "RenderingServer", + "ResourceFormatLoader", + "ResourceFormatSaver", + "ResourceImporter", + "ResourceLoader", + "ResourcePreloader", + "ResourceSaver", + "ResourceUID", + "Resource", + "RibbonTrailMesh", + "RichTextEffect", + "RichTextLabel", + "RID", + "RigidBody2D", + "RigidBody3D", + "RootMotionView", + "SceneState", + "SceneTreeTimer", + "SceneTree", + "ScriptCreateDialog", + "ScriptEditorBase", + "ScriptEditor", + "ScriptExtension", + "ScriptLanguageExtension", + "ScriptLanguage", + "Script", + "ScrollBar", + "ScrollContainer", + "SegmentShape2D", + "Semaphore", + "SeparationRayShape2D", + "SeparationRayShape3D", + "Separator", + "ShaderGlobalsOverride", + "ShaderInclude", + "ShaderMaterial", + "Shader", + "Shape2D", + "Shape3D", + "ShapeCast2D", + "ShapeCast3D", + "Shortcut", + "Signal", + "Skeleton2D", + "Skeleton3D", + "SkeletonIK3D", + "SkeletonModification2DCCDIK", + "SkeletonModification2DFABRIK", + "SkeletonModification2DJiggle", + "SkeletonModification2DLookAt", + "SkeletonModification2DPhysicalBones", + "SkeletonModification2DStackHolder", + "SkeletonModification2DTwoBoneIK", + "SkeletonModification2D", + "SkeletonModification3DCCDIK", + "SkeletonModification3DFABRIK", + "SkeletonModification3DJiggle", + "SkeletonModification3DLookAt", + "SkeletonModification3DStackHolder", + "SkeletonModification3DTwoBoneIK", + "SkeletonModification3D", + "SkeletonModificationStack2D", + "SkeletonModificationStack3D", + "SkeletonProfileHumanoid", + "SkeletonProfile", + "SkinReference", + "Skin", + "Sky", + "SliderJoint3D", + "Slider", + "SoftBody3D", + "SphereMesh", + "SphereOccluder3D", + "SphereShape3D", + "SpinBox", + "SplitContainer", + "SpotLight3D", + "SpringArm3D", + "Sprite2D", + "Sprite3D", + "SpriteBase3D", + "SpriteFrames", + "StandardMaterial3D", + "StaticBody2D", + "StaticBody3D", + "StreamPeerBuffer", + "StreamPeerExtension", + "StreamPeerGZIP", + "StreamPeerTCP", + "StreamPeerTLS", + "StreamPeer", + "StringName", + "String", + "StyleBoxEmpty", + "StyleBoxFlat", + "StyleBoxLine", + "StyleBoxTexture", + "StyleBox", + "SubViewportContainer", + "SubViewport", + "SurfaceTool", + "SyntaxHighlighter", + "SystemFont", + "TabBar", + "TabContainer", + "TCPServer", + "TextEdit", + "TextLine", + "TextMesh", + "TextParagraph", + "TextServerDummy", + "TextServerExtension", + "TextServerManager", + "TextServer", + "Texture2DArray", + "Texture2D", + "Texture3D", + "TextureButton", + "TextureLayered", + "TextureProgressBar", + "TextureRect", + "Texture", + "ThemeDB", + "Theme", + "Thread", + "TileData", + "TileMapPattern", + "TileMap", + "TileSetAtlasSource", + "TileSetScenesCollectionSource", + "TileSetSource", + "TileSet", + "Timer", + "Time", + "TorusMesh", + "TouchScreenButton", + "Transform2D", + "Transform3D", + "TranslationServer", + "Translation", + "TreeItem", + "Tree", + "TriangleMesh", + "TubeTrailMesh", + "Tweener", + "Tween", + "UDPServer", + "UndoRedo", + "Variant", + "VBoxContainer", + "Vector2i", + "Vector2", + "Vector3i", + "Vector3", + "Vector4i", + "Vector4", + "VehicleBody3D", + "VehicleWheel3D", + "VFlowContainer", + "VideoStreamPlayer", + "VideoStream", + "ViewportTexture", + "Viewport", + "VisibleOnScreenEnabler2D", + "VisibleOnScreenEnabler3D", + "VisibleOnScreenNotifier2D", + "VisibleOnScreenNotifier3D", + "VisualInstance3D", + "VisualShaderNodeBillboard", + "VisualShaderNodeBooleanConstant", + "VisualShaderNodeBooleanParameter", + "VisualShaderNodeClamp", + "VisualShaderNodeColorConstant", + "VisualShaderNodeColorFunc", + "VisualShaderNodeColorOp", + "VisualShaderNodeColorParameter", + "VisualShaderNodeComment", + "VisualShaderNodeCompare", + "VisualShaderNodeConstant", + "VisualShaderNodeCubemapParameter", + "VisualShaderNodeCubemap", + "VisualShaderNodeCurveTexture", + "VisualShaderNodeCurveXYZTexture", + "VisualShaderNodeCustom", + "VisualShaderNodeDerivativeFunc", + "VisualShaderNodeDeterminant", + "VisualShaderNodeDistanceFade", + "VisualShaderNodeDotProduct", + "VisualShaderNodeExpression", + "VisualShaderNodeFaceForward", + "VisualShaderNodeFloatConstant", + "VisualShaderNodeFloatFunc", + "VisualShaderNodeFloatOp", + "VisualShaderNodeFloatParameter", + "VisualShaderNodeFresnel", + "VisualShaderNodeGlobalExpression", + "VisualShaderNodeGroupBase", + "VisualShaderNodeIf", + "VisualShaderNodeInput", + "VisualShaderNodeIntConstant", + "VisualShaderNodeIntFunc", + "VisualShaderNodeIntOp", + "VisualShaderNodeIntParameter", + "VisualShaderNodeIs", + "VisualShaderNodeLinearSceneDepth", + "VisualShaderNodeMix", + "VisualShaderNodeMultiplyAdd", + "VisualShaderNodeOuterProduct", + "VisualShaderNodeOutput", + "VisualShaderNodeParameterRef", + "VisualShaderNodeParameter", + "VisualShaderNodeParticleAccelerator", + "VisualShaderNodeParticleBoxEmitter", + "VisualShaderNodeParticleConeVelocity", + "VisualShaderNodeParticleEmitter", + "VisualShaderNodeParticleEmit", + "VisualShaderNodeParticleMeshEmitter", + "VisualShaderNodeParticleMultiplyByAxisAngle", + "VisualShaderNodeParticleOutput", + "VisualShaderNodeParticleRandomness", + "VisualShaderNodeParticleRingEmitter", + "VisualShaderNodeParticleSphereEmitter", + "VisualShaderNodeProximityFade", + "VisualShaderNodeRandomRange", + "VisualShaderNodeRemap", + "VisualShaderNodeResizableBase", + "VisualShaderNodeSample3D", + "VisualShaderNodeScreenUVToSDF", + "VisualShaderNodeSDFRaymarch", + "VisualShaderNodeSDFToScreenUV", + "VisualShaderNodeSmoothStep", + "VisualShaderNodeStep", + "VisualShaderNodeSwitch", + "VisualShaderNodeTexture2DArrayParameter", + "VisualShaderNodeTexture2DArray", + "VisualShaderNodeTexture2DParameter", + "VisualShaderNodeTexture3DParameter", + "VisualShaderNodeTexture3D", + "VisualShaderNodeTextureParameterTriplanar", + "VisualShaderNodeTextureParameter", + "VisualShaderNodeTextureSDFNormal", + "VisualShaderNodeTextureSDF", + "VisualShaderNodeTexture", + "VisualShaderNodeTransformCompose", + "VisualShaderNodeTransformConstant", + "VisualShaderNodeTransformDecompose", + "VisualShaderNodeTransformFunc", + "VisualShaderNodeTransformOp", + "VisualShaderNodeTransformParameter", + "VisualShaderNodeTransformVecMult", + "VisualShaderNodeUVFunc", + "VisualShaderNodeUVPolarCoord", + "VisualShaderNodeVaryingGetter", + "VisualShaderNodeVaryingSetter", + "VisualShaderNodeVarying", + "VisualShaderNodeVec2Constant", + "VisualShaderNodeVec2Parameter", + "VisualShaderNodeVec3Constant", + "VisualShaderNodeVec3Parameter", + "VisualShaderNodeVec4Constant", + "VisualShaderNodeVec4Parameter", + "VisualShaderNodeVectorBase", + "VisualShaderNodeVectorCompose", + "VisualShaderNodeVectorDecompose", + "VisualShaderNodeVectorDistance", + "VisualShaderNodeVectorFunc", + "VisualShaderNodeVectorLen", + "VisualShaderNodeVectorOp", + "VisualShaderNodeVectorRefract", + "VisualShaderNode", + "VisualShader", + "VoxelGIData", + "VoxelGI", + "VScrollBar", + "VSeparator", + "VSlider", + "VSplitContainer", + "WeakRef", + "Window", + "WorkerThreadPool", + "World2D", + "World3D", + "WorldBoundaryShape2D", + "WorldBoundaryShape3D", + "WorldEnvironment", + "X509Certificate", + "XMLParser", + "XRAnchor3D", + "XRCamera3D", + "XRController3D", + "XRInterfaceExtension", + "XRInterface", + "XRNode3D", + "XROrigin3D", + "XRPose", + "XRPositionalTracker", + "XRServer" ); } } + diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars index 1641b6e8b20d..b3bccf97abe0 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars @@ -128,48 +128,48 @@ func bee_request( path: String, headers: Dictionary, query: Dictionary, - body, # Variant that will be serialized + body, # Variant that will be serialized and sent on_success: Callable, # func(response: Variant, responseCode: int, responseHeaders: Dictionary) on_failure: Callable, # func(error: {{>partials/api_error_class_name}}) ): + # This method does not handle full deserialization, it only handles decode and not denormalization. + # Denormalization is handled in each generated API endpoint in the on_success callable of this method. + # This is because this method already has plethora of parameters and we don't want even more. bee_request_text( method, path, headers, query, body, func(responseText, responseCode, responseHeaders): var mime: String = responseHeaders['Mime'] - var deserializedResponse # Variant - var denormalizedResponse # Variant + var decodedResponse # Variant if BEE_CONTENT_TYPE_TEXT == mime: - deserializedResponse = responseText + decodedResponse = responseText elif BEE_CONTENT_TYPE_HTML == mime: - deserializedResponse = responseText + decodedResponse = responseText elif BEE_CONTENT_TYPE_JSON == mime: var parser := JSON.new() var parsing := parser.parse(responseText) if OK != parsing: var error := {{>partials/api_error_class_name}}.new() error.internal_code = parsing - error.identifier = "apibee.deserialize.cannot_parse_json" - error.message = "%s: failed to parse JSON at line %d.\n%s" % [ + error.identifier = "apibee.decode.cannot_parse_json" + error.message = "%s: failed to parse JSON response at line %d.\n%s" % [ self.bee_name, parser.get_error_line(), parser.get_error_message() ] on_failure.call(error) return - deserializedResponse = parser.data + decodedResponse = parser.data else: var error := {{>partials/api_error_class_name}}.new() error.internal_code = ERR_INVALID_DATA - error.identifier = "apibee.deserialize.mime_type_unsupported" + error.identifier = "apibee.decode.mime_type_unsupported" error.message = "%s: mime type `%s' is not supported (yet)" % [ self.bee_name, mime ] on_failure.call(error) return - denormalizedResponse = deserializedResponse # FIXME - - on_success.call(denormalizedResponse, responseCode, responseHeaders) + on_success.call(decodedResponse, responseCode, responseHeaders) , func(error): on_failure.call(error) diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars index ab622c34ace9..2dafd7b5e8d1 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars @@ -1,22 +1,24 @@ extends Resource class_name {{>partials/api_config_class_name}} +{{>partials/disclaimer_autogenerated}} + # Configuration options for Api endpoints. # # Its purpose is to help you share configuration customizations across Apis. # Since it is a Resource, you may use `ResourceSaver.save()` and `load()` # to save it and load it from file, if you want. -# -# Not sure if this should hold the HTTPClient instance or not. Not for now. + # These are constant, immutable default values. # To set different values at runtime, use the public properties below. const BEE_DEFAULT_HOST := "{{#if host}}{{{host}}}{{else}}localhost{{/if}}" const BEE_DEFAULT_PORT_HTTP := 80 const BEE_DEFAULT_PORT_HTTPS := 443 -const BEE_DEFAULT_POLLING_INTERVAL_MS := 500 # milliseconds +const BEE_DEFAULT_POLLING_INTERVAL_MS := 333 # milliseconds {{!-- +# Not sure if this should hold the HTTPClient instance or not. Not for now. # Godot's HTTP Client we are using. # If none was set (by you), we'll make one. var bee_client: HTTPClient: @@ -31,7 +33,7 @@ var bee_client: HTTPClient: # The host to connect to, with or without the protocol scheme. # Eg: "gitea.com", "https://gitea.com" # We toggle TLS accordingly to the provided scheme, if any. -var host := BEE_DEFAULT_HOST: +@export var host := BEE_DEFAULT_HOST: set(value): if value.begins_with("https://"): ssl_enabled = true @@ -44,37 +46,37 @@ var host := BEE_DEFAULT_HOST: # Port through which the connection will be established. # Note: changing the host may change the port as well if the scheme was provided, see above. -var port := BEE_DEFAULT_PORT_HTTP +@export var port := BEE_DEFAULT_PORT_HTTP # Headers used as base for all requests made by Api instances using this config. # Those are the lowest priority headers, and are merged with custom headers provided in the bee_request() method call # as well as the headers override below, to compute the final, actually sent headers. -var headers_base := { +@export var headers_base := { # Stigmergy: everyone does what is left to do (like ants do) "User-Agent": "Stigmergiac/1.0 (Godot)", # For my mental health's sake, only JSON is supported for now "Accept": "application/json", "Content-Type": "application/json", - # FIXME: Remove demo cheat code + # FIXME: Remove petstore demo cheat code "api_key": "special-key", } # High-priority headers, they will always override other headers coming from the base above or the method call. -var headers_override := {} +@export var headers_override := {} # Duration of sleep between poll() calls. -var polling_interval_ms := BEE_DEFAULT_POLLING_INTERVAL_MS # milliseconds +@export var polling_interval_ms := BEE_DEFAULT_POLLING_INTERVAL_MS # milliseconds # Should we encrypt packets ? Yes. Let's encrypt ! -var ssl_enabled := false: +@export var ssl_enabled := false: set(value): ssl_enabled = value port = BEE_DEFAULT_PORT_HTTPS if ssl_enabled else BEE_DEFAULT_PORT_HTTP -var verify_host := true # only used if ssl is enabled, disable if trouble +@export var verify_host := true # only used if ssl is enabled diff --git a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars index 8d3dd3e768f3..6a13b9bda0b1 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars @@ -28,7 +28,7 @@ func {{operationIdSnakeCase}}( {{#each allParams}} # {{paramName}}{{#if dataType}}: {{dataType}}{{/if}}{{#if defaultValue}} = {{{defaultValue}}}{{/if}}{{#if example}} Eg: {{{example}}}{{/if}} # {{{description}}} - {{paramName}}{{#if required}}{{#if dataType}}: {{{dataType}}}{{/if}}{{/if}}{{#unless required}} = {{#defaultValue}}{{{.}}}{{/defaultValue}}{{#unless defaultValue}}null{{/unless}}{{/unless}}, + {{paramName}}{{#if required}}{{#if dataType}}: {{{dataType}}}{{/if}}{{/if}}{{#unless required}} = {{#if defaultValue}}{{defaultValue}}{{/if}}{{#unless defaultValue}}null{{/unless}}{{/unless}}, {{/each}} on_success: Callable = Callable(), # func(result{{#if returnType}}: {{returnType}}{{/if}}) on_failure: Callable = Callable(), # func(error: {{>partials/api_error_class_name}}) From 07a8076c0896029df17655b36246e234c6e42347 Mon Sep 17 00:00:00 2001 From: Goutte Date: Wed, 2 Nov 2022 15:05:42 +0100 Subject: [PATCH 22/56] feat(gdscript): improve logging with a configurable log level --- .../main/resources/gdscript/ApiBee.handlebars | 25 +++++++----- .../resources/gdscript/ApiConfig.handlebars | 40 ++++++++++++++++++- 2 files changed, 54 insertions(+), 11 deletions(-) diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars index b3bccf97abe0..b88a02e0ae44 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars @@ -104,7 +104,7 @@ func bee_connect_client_if_needed( self.bee_client.get_status() == HTTPClient.STATUS_RESOLVING ): self.bee_client.poll() - print("Connecting...") + self.bee_config.log_debug("Connecting…") if self.bee_config.polling_interval_ms: OS.delay_msec(self.bee_config.polling_interval_ms) await bee_next_loop_iteration() @@ -261,7 +261,7 @@ func bee_do_request_text( while self.bee_client.get_status() == HTTPClient.STATUS_REQUESTING: # Keep polling for as long as the request is being processed. self.bee_client.poll() - print("Requesting...") + self.bee_config.log_debug("Requesting…") if self.bee_config.polling_interval_ms: OS.delay_msec(self.bee_config.polling_interval_ms) await bee_next_loop_iteration() @@ -298,13 +298,17 @@ func bee_do_request_text( else: # Yummy data has arrived response_bytes = response_bytes + chunk - print("REQUEST %s %s" % [method, path_queried]) - print("Headers: %s" % [str(headers)]) - prints(body_serialized) + self.bee_config.log_info("%s: REQUEST %s %s" % [self.bee_name, method, path_queried]) + if not headers.is_empty(): + self.bee_config.log_debug("→ HEADERS: %s" % [str(headers)]) + if body_serialized: + self.bee_config.log_debug("→ BODY: \n%s" % [body_serialized]) - prints("RESPONSE CODE:", response_code) - prints("RESPONSE HEADERS:", response_headers) - print("RESPONSE SIZE: %d bytes " % response_bytes.size()) + self.bee_config.log_info("%s: RESPONSE %d (%d bytes)" % [ + self.bee_name, response_code, response_bytes.size() + ]) + if not response_headers.is_empty(): + self.bee_config.log_debug("→ HEADERS: %s" % str(response_headers)) var response_text: String if encoding == "utf-8": @@ -316,6 +320,9 @@ func bee_do_request_text( else: response_text = response_bytes.get_string_from_ascii() + if response_text: + self.bee_config.log_debug("→ BODY: \n%s" % response_text) + if response_code >= 500: var error := {{>partials/api_error_class_name}}.new() error.internal_code = ERR_PRINTER_ON_FIRE @@ -367,7 +374,7 @@ func bee_convert_http_method(method: String) -> int: 'OPTIONS': return HTTPClient.METHOD_OPTIONS 'TRACE': return HTTPClient.METHOD_TRACE _: - printerr("%s: unknown http method `%s`, assuming GET." % [ + push_error("%s: unknown http method `%s`, assuming GET." % [ self.bee_name, method ]) return HTTPClient.METHOD_GET diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars index 2dafd7b5e8d1..cb4d25c50740 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars @@ -3,11 +3,17 @@ class_name {{>partials/api_config_class_name}} {{>partials/disclaimer_autogenerated}} -# Configuration options for Api endpoints. + +# Configuration options for Api endpoints +# --------------------------------------- # -# Its purpose is to help you share configuration customizations across Apis. +# Its purpose is to help you share configuration customizations across Apis: +# - host & port +# - headers & security schemes +# - log level # Since it is a Resource, you may use `ResourceSaver.save()` and `load()` # to save it and load it from file, if you want. +# # These are constant, immutable default values. @@ -17,6 +23,17 @@ const BEE_DEFAULT_PORT_HTTP := 80 const BEE_DEFAULT_PORT_HTTPS := 443 const BEE_DEFAULT_POLLING_INTERVAL_MS := 333 # milliseconds + +# Configuration also handles logging because it's convenient. +# You may extend this class and override the log methods with your own if you need to. +enum LogLevel { + SILENT, + ERROR, + WARNING, + INFO, + DEBUG, +} + {{!-- # Not sure if this should hold the HTTPClient instance or not. Not for now. # Godot's HTTP Client we are using. @@ -80,3 +97,22 @@ var bee_client: HTTPClient: @export var verify_host := true # only used if ssl is enabled + +# @export_enum ain't working for ints yet +@export var log_level := LogLevel.WARNING + +func log_error(message: String): + if self.log_level >= LogLevel.ERROR: + push_error(message) + +func log_warning(message: String): + if self.log_level >= LogLevel.WARNING: + push_warning(message) + +func log_info(message: String): + if self.log_level >= LogLevel.INFO: + print(message) + +func log_debug(message: String): + if self.log_level >= LogLevel.DEBUG: + print(message) From e1311245cffdcbc4113898512b3e5b819c9dc9c9 Mon Sep 17 00:00:00 2001 From: Goutte Date: Wed, 2 Nov 2022 16:17:04 +0100 Subject: [PATCH 23/56] feat(gdscript): add support for Basic Bearer and Header ApiKey (but I can't find the `description` template handler) --- .../resources/gdscript/ApiConfig.handlebars | 40 +++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars index cb4d25c50740..549bb6a01240 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars @@ -116,3 +116,43 @@ func log_info(message: String): func log_debug(message: String): if self.log_level >= LogLevel.DEBUG: print(message) + + +{{!-- +SAMPLE +authMethods=[ +CodegenSecurity{name='JWT', type='http', scheme='bearer', isBasic=true, isOAuth=false, isApiKey=false, isBasicBasic=false, isHttpSignature=false, isBasicBearer=true, bearerFormat='JWT', vendorExtensions={}, keyParamName='null', isKeyInQuery=false, isKeyInHeader=false, isKeyInCookie=false, flow='null', authorizationUrl='null', tokenUrl='null', refreshUrl='null', scopes=null, isCode=false, isPassword=false, isApplication=false, isImplicit=false}, +CodegenSecurity{name='noSpam', type='apiKey', scheme='null', isBasic=false, isOAuth=false, isApiKey=true, isBasicBasic=false, isHttpSignature=false, isBasicBearer=false, bearerFormat='null', vendorExtensions={}, keyParamName='GodotGame', isKeyInQuery=false, isKeyInHeader=true, isKeyInCookie=false, flow='null', authorizationUrl='null', tokenUrl='null', refreshUrl='null', scopes=null, isCode=false, isPassword=false, isApplication=false, isImplicit=false} +], +--}} + +{{#each authMethods}} +# Authentication method `{{name}}`. +{{#if description +{{#if isBasicBearer }} +# Basic Bearer Authentication `{{bearerFormat}}` +func set_security_{{name}}(value: String): + self.headers_base["Authorization"] = "Bearer %s" % value + + +{{else if isApiKey }} +# Api Key Authentication `{{keyParamName}}` +func set_security_{{name}}(value: String): + {{#if isKeyInHeader }} + self.headers_base[{{keyParamName}}] = value + {{else if isKeyInQuery }} + # Implementing this should be straightforward + log_error("Api Key in Query is not supported at the moment. (contribs welcome)") + {{else if isKeyInCookie }} + log_error("Api Key in Cookie is not supported at the moment. (contribs welcome)") + {{else }} + log_error("Unrecognized Api Key format (contribs welcome).") + {{/if}} + + +{{else}} +# → Skipped because it's not implemented in the gdscript templates. (contribs welcome) + + +{{/if}} +{{/each}} From 6cf380fc8802e8df3dbcd5ebc0723890ffa4bff1 Mon Sep 17 00:00:00 2001 From: Goutte Date: Wed, 2 Nov 2022 16:19:22 +0100 Subject: [PATCH 24/56] fix(gdscript) Too late to amend >.< --- .../src/main/resources/gdscript/ApiConfig.handlebars | 1 - 1 file changed, 1 deletion(-) diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars index 549bb6a01240..626b2c04aba4 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars @@ -128,7 +128,6 @@ CodegenSecurity{name='noSpam', type='apiKey', scheme='null', isBasic=false, isOA {{#each authMethods}} # Authentication method `{{name}}`. -{{#if description {{#if isBasicBearer }} # Basic Bearer Authentication `{{bearerFormat}}` func set_security_{{name}}(value: String): From 85d3b6ebd969763c11ad12f20cca9ae6e0bb5471 Mon Sep 17 00:00:00 2001 From: Goutte Date: Wed, 2 Nov 2022 16:20:31 +0100 Subject: [PATCH 25/56] fix(gdscript) dangsarnit --- .../src/main/resources/gdscript/ApiConfig.handlebars | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars index 626b2c04aba4..46358b5fba1a 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars @@ -138,7 +138,7 @@ func set_security_{{name}}(value: String): # Api Key Authentication `{{keyParamName}}` func set_security_{{name}}(value: String): {{#if isKeyInHeader }} - self.headers_base[{{keyParamName}}] = value + self.headers_base["{{keyParamName}}"] = value {{else if isKeyInQuery }} # Implementing this should be straightforward log_error("Api Key in Query is not supported at the moment. (contribs welcome)") From bd5f8058acfffae2fd9094ef3d678db8c7ecc79a Mon Sep 17 00:00:00 2001 From: Goutte Date: Wed, 2 Nov 2022 19:59:09 +0100 Subject: [PATCH 26/56] chore(gdscript): clean up a sprint artifact --- .../src/main/resources/gdscript/ApiConfig.handlebars | 10 ---------- samples/client/petstore/gdscript/demo/main.gd | 1 + 2 files changed, 1 insertion(+), 10 deletions(-) diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars index 46358b5fba1a..4465b19f88a9 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars @@ -75,8 +75,6 @@ var bee_client: HTTPClient: # For my mental health's sake, only JSON is supported for now "Accept": "application/json", "Content-Type": "application/json", - # FIXME: Remove petstore demo cheat code - "api_key": "special-key", } @@ -118,14 +116,6 @@ func log_debug(message: String): print(message) -{{!-- -SAMPLE -authMethods=[ -CodegenSecurity{name='JWT', type='http', scheme='bearer', isBasic=true, isOAuth=false, isApiKey=false, isBasicBasic=false, isHttpSignature=false, isBasicBearer=true, bearerFormat='JWT', vendorExtensions={}, keyParamName='null', isKeyInQuery=false, isKeyInHeader=false, isKeyInCookie=false, flow='null', authorizationUrl='null', tokenUrl='null', refreshUrl='null', scopes=null, isCode=false, isPassword=false, isApplication=false, isImplicit=false}, -CodegenSecurity{name='noSpam', type='apiKey', scheme='null', isBasic=false, isOAuth=false, isApiKey=true, isBasicBasic=false, isHttpSignature=false, isBasicBearer=false, bearerFormat='null', vendorExtensions={}, keyParamName='GodotGame', isKeyInQuery=false, isKeyInHeader=true, isKeyInCookie=false, flow='null', authorizationUrl='null', tokenUrl='null', refreshUrl='null', scopes=null, isCode=false, isPassword=false, isApplication=false, isImplicit=false} -], ---}} - {{#each authMethods}} # Authentication method `{{name}}`. {{#if isBasicBearer }} diff --git a/samples/client/petstore/gdscript/demo/main.gd b/samples/client/petstore/gdscript/demo/main.gd index 329f174b8885..7015162a94b2 100644 --- a/samples/client/petstore/gdscript/demo/main.gd +++ b/samples/client/petstore/gdscript/demo/main.gd @@ -52,6 +52,7 @@ var cfg := DemoApiConfig.new() func run_all_tests(on_done := Callable()): cfg.port = 8081 + cfg.headers_base['api_key'] = "special-key" log_text_edit.text = "" var started_at := Time.get_ticks_msec() From 35f2146fe9a442c8a22628801328dec6f3950ddf Mon Sep 17 00:00:00 2001 From: Goutte Date: Tue, 29 Nov 2022 15:18:00 +0100 Subject: [PATCH 27/56] fix: don't forget the HTTP error code when relevant --- .../src/main/resources/gdscript/ApiBee.handlebars | 3 +++ 1 file changed, 3 insertions(+) diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars index b88a02e0ae44..36e57e33e696 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars @@ -326,6 +326,7 @@ func bee_do_request_text( if response_code >= 500: var error := {{>partials/api_error_class_name}}.new() error.internal_code = ERR_PRINTER_ON_FIRE + error.response_code = response_code error.identifier = "apibee.response.5xx" error.message = "%s: request to `%s' made the server hiccup with a %d." % [ self.bee_name, path, response_code @@ -338,6 +339,7 @@ func bee_do_request_text( elif response_code >= 400: var error := {{>partials/api_error_class_name}}.new() error.identifier = "apibee.response.4xx" + error.response_code = response_code error.message = "%s: request to `%s' was denied with a %d." % [ self.bee_name, path, response_code ] @@ -349,6 +351,7 @@ func bee_do_request_text( elif response_code >= 300: var error := {{>partials/api_error_class_name}}.new() error.identifier = "apibee.response.3xx" + error.response_code = response_code error.message = "%s: request to `%s' was redirected with a %d. We do not support redirects in that client yet." % [ self.bee_name, path, response_code ] From 96d2db068b6c3357f151834b8dcd4872fd3a67a4 Mon Sep 17 00:00:00 2001 From: Goutte Date: Tue, 29 Nov 2022 15:32:02 +0100 Subject: [PATCH 28/56] feat: use Resource as base class for models --- .../src/main/resources/gdscript/model.handlebars | 4 ++-- .../gdscript/partials/model_statement_extends.handlebars | 4 +--- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars index 544e0c071573..56dec78e4768 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars @@ -41,7 +41,7 @@ var bee_class_name := "{{classname}}" {{#if isEnum}} # Allowed values: {{#with allowableValues}}{{#each values}}"{{this}}"{{#unless @last}}, {{/unless}}{{/each}}{{/with}} {{/if}} -var {{name}}: {{>partials/data_type}}{{#if defaultValue}} = {{{defaultValue}}}{{/if}}: +@export var {{name}}: {{>partials/data_type}}{{#if defaultValue}} = {{{defaultValue}}}{{/if}}: set(value): {{#if deprecated}} if str(value) != "": @@ -130,4 +130,4 @@ func bee_normalize_fully() -> Dictionary: } --}} {{/with}} -{{/each}} \ No newline at end of file +{{/each}} diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/model_statement_extends.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/model_statement_extends.handlebars index 4f464a3977e6..4249efa1f9e3 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/partials/model_statement_extends.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/model_statement_extends.handlebars @@ -1,3 +1 @@ -{{! TODO: extend Resource and add @export annots -- more work for you if you want ~}} -{{! extends Resource ~}} -extends RefCounted \ No newline at end of file +extends Resource From 004040e1849c7d24bd2d6214b3569f4dfab9d613 Mon Sep 17 00:00:00 2001 From: Bagrat Date: Thu, 9 Mar 2023 11:05:54 +0100 Subject: [PATCH 29/56] fix. Default string values now with "quotes" --- .../openapitools/codegen/languages/GdscriptClientCodegen.java | 4 ++++ .../src/main/resources/gdscript/api.handlebars | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java index b0205f4cf764..3c690b80ea5a 100644 --- a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java +++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java @@ -1,6 +1,7 @@ package org.openapitools.codegen.languages; import io.swagger.v3.oas.models.media.Schema; +import io.swagger.v3.oas.models.media.StringSchema; import org.openapitools.codegen.*; import java.io.File; @@ -342,6 +343,9 @@ public String toExampleValue(Schema schema) { @Override public String toDefaultValue(Schema schema) { if (schema.getDefault() != null) { + if (schema instanceof StringSchema) { + return "\"" + schema.getDefault().toString() + "\"" ; + } return schema.getDefault().toString(); } diff --git a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars index 6a13b9bda0b1..d932c43e43af 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars @@ -28,7 +28,7 @@ func {{operationIdSnakeCase}}( {{#each allParams}} # {{paramName}}{{#if dataType}}: {{dataType}}{{/if}}{{#if defaultValue}} = {{{defaultValue}}}{{/if}}{{#if example}} Eg: {{{example}}}{{/if}} # {{{description}}} - {{paramName}}{{#if required}}{{#if dataType}}: {{{dataType}}}{{/if}}{{/if}}{{#unless required}} = {{#if defaultValue}}{{defaultValue}}{{/if}}{{#unless defaultValue}}null{{/unless}}{{/unless}}, + {{paramName}}{{#if required}}{{#if dataType}}: {{{dataType}}}{{/if}}{{/if}}{{#unless required}} = {{#if defaultValue}}{{{defaultValue}}}{{/if}}{{#unless defaultValue}}null{{/unless}}{{/unless}}, {{/each}} on_success: Callable = Callable(), # func(result{{#if returnType}}: {{returnType}}{{/if}}) on_failure: Callable = Callable(), # func(error: {{>partials/api_error_class_name}}) From a0c79e4f1a7eafc607bb37a725085c371d4e7813 Mon Sep 17 00:00:00 2001 From: Bagrat Date: Wed, 15 Mar 2023 22:39:27 +0100 Subject: [PATCH 30/56] temporary remove settings as godot api have changed --- .../src/main/resources/gdscript/ApiBee.handlebars | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars index 36e57e33e696..fd0dc3daf768 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars @@ -84,8 +84,7 @@ func bee_connect_client_if_needed( on_success.call() var connecting := self.bee_client.connect_to_host( - self.bee_config.host, self.bee_config.port, - self.bee_config.ssl_enabled, self.bee_config.verify_host + self.bee_config.host, self.bee_config.port ) if connecting != OK: var error := {{>partials/api_error_class_name}}.new() From bae1399e6cb9ef2c56d5dfd869da09160eb72218 Mon Sep 17 00:00:00 2001 From: Bagrat Date: Thu, 16 Mar 2023 14:53:57 +0100 Subject: [PATCH 31/56] kick ci --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 68195c874354..b87ce120d199 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@

OpenAPI Generator

- +
From fd47ffacd8b2f5b9e80ad06b658e8e824703f057 Mon Sep 17 00:00:00 2001 From: Goutte Date: Sun, 9 Apr 2023 16:50:13 +0200 Subject: [PATCH 32/56] docs: review gdscript java class --- .../languages/GdscriptClientCodegen.java | 18 +----------------- 1 file changed, 1 insertion(+), 17 deletions(-) diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java index 3c690b80ea5a..fc7ae453c0f1 100644 --- a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java +++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java @@ -262,7 +262,7 @@ public void processOpts() { supportingFiles.add(new SupportingFile("README.handlebars", "", "README.md")); // Ensure we're using the appropriate template engine, and configure it while we're at it. - // We had to use handlebars because the truthy value of mustache includes `""` and `"null"`, + // We had to use handlebars because the truthy values of mustache include `""` and `"null"`, // and things went south for default values and examples (but descriptions were OK, somehow) TemplatingEngineAdapter templatingEngine = getTemplatingEngine(); if (templatingEngine instanceof HandlebarsEngineAdapter) { @@ -315,21 +315,6 @@ public String modelDocFileFolder() { } - // When example is "null" (with quotes), mustache's {{#example}} triggers - // Not sure why this happens on {{#example}} but not {{#description}} - // Perhaps I'm just using mustache wrong… Anyway, it's voodoo. - // Also, even with this fix, {{#example}} still triggers. - // → That just because of how mustache works. (false or [] only) - // → I'll switch to handlebars. - // → Pebble would perhaps help reduce injections, with custom escaping filters for each context: - // → Comments - // → Variable names - // → Function names - // → Quoted - // → Typed values (int, etc.) - // → Handlebars also has a discrepancy between description and example, both 'null' - // → We need this (hot?)fix in the end. - // → Or not, there's a {{#hasExamples}} we could perhaps use @Override public String toExampleValue(Schema schema) { if (schema.getExample() != null) { @@ -339,7 +324,6 @@ public String toExampleValue(Schema schema) { return ""; } - // → Same code smell, I'm probably handling this wrong. @Override public String toDefaultValue(Schema schema) { if (schema.getDefault() != null) { From fdbf5b7c769be59a9cd18bfa30331fd5d348a95a Mon Sep 17 00:00:00 2001 From: Goutte Date: Tue, 11 Apr 2023 16:40:56 +0200 Subject: [PATCH 33/56] feat: support for TLS, some refacto, some review There's still a lot of holes, TODOs and FIXMEs. --- .../main/resources/gdscript/ApiBee.handlebars | 137 ++++++++++++------ .../resources/gdscript/ApiConfig.handlebars | 63 +++++--- .../main/resources/gdscript/README.handlebars | 12 +- .../src/main/resources/gdscript/README.md | 4 - .../main/resources/gdscript/api.handlebars | 4 +- 5 files changed, 152 insertions(+), 68 deletions(-) diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars index fd0dc3daf768..cd1ffbf1eb5b 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars @@ -6,7 +6,7 @@ class_name {{>partials/api_base_class_name}} # Every property/method defined here may collide with userland, # so these are all listed and excluded in our CodeGen Java file. # We want to keep the amount of renaming to a minimum, though. -# Therefore, we use the bee_ prefix, even if awkward. +# Therefore, we use the bee_ and _bee_ prefixes, even if awkward. const BEE_CONTENT_TYPE_TEXT := "text/plain" @@ -49,7 +49,8 @@ var bee_client: HTTPClient: # General configuration that can be shared across Api instances for convenience. -# If no configuration was provided, we'll lazily make one with defaults as best we can. +# If no configuration was provided, we'll lazily make one with defaults, +# but you probably want to make your own with your own domain and scheme. var bee_config: {{>partials/api_config_class_name}}: set(value): bee_config = value @@ -60,12 +61,12 @@ var bee_config: {{>partials/api_config_class_name}}: return bee_config -func bee_next_loop_iteration(): - # I can't find `idle_frame` in 4-beta3, but we probably want idle_frame here +func _bee_next_loop_iteration(): + # I can't find `idle_frame` in 4.0, but we probably want idle_frame here return Engine.get_main_loop().process_frame -func bee_connect_client_if_needed( +func _bee_connect_client_if_needed( on_success: Callable, # func() on_failure: Callable, # func(error: {{>partials/api_error_class_name}}) #finally: Callable, @@ -84,14 +85,15 @@ func bee_connect_client_if_needed( on_success.call() var connecting := self.bee_client.connect_to_host( - self.bee_config.host, self.bee_config.port + self.bee_config.host, self.bee_config.port, self.bee_config.tls_options ) if connecting != OK: var error := {{>partials/api_error_class_name}}.new() error.internal_code = connecting error.identifier = "apibee.connect_to_host.failure" - error.message = "%s: failed to connect to `%s' port %d with error %d" % [ - self.bee_name, self.bee_config.host, self.bee_config.port, connecting + error.message = "%s: failed to connect to `%s' port `%d' with error: %s" % [ + self.bee_name, self.bee_config.host, self.bee_config.port, + _bee_httpclient_status_string(connecting), ] on_failure.call(error) return @@ -106,14 +108,16 @@ func bee_connect_client_if_needed( self.bee_config.log_debug("Connecting…") if self.bee_config.polling_interval_ms: OS.delay_msec(self.bee_config.polling_interval_ms) - await bee_next_loop_iteration() + await _bee_next_loop_iteration() - if self.bee_client.get_status() != HTTPClient.STATUS_CONNECTED: + var connected := self.bee_client.get_status() + if connected != HTTPClient.STATUS_CONNECTED: var error := {{>partials/api_error_class_name}}.new() - error.internal_code = connecting + error.internal_code = connected as Error error.identifier = "apibee.connect_to_host.wrong_status" - error.message = "%s: failed to connect to `%s' port %d, with client status %d" % [ - self.bee_name, self.bee_config.host, self.bee_config.port, self.bee_client.get_status() + error.message = "%s: failed to connect to `%s' port `%d' : %s" % [ + self.bee_name, self.bee_config.host, self.bee_config.port, + _bee_httpclient_status_string(connected), ] on_failure.call(error) return @@ -121,7 +125,6 @@ func bee_connect_client_if_needed( on_success.call() -# @protected func bee_request( method: int, # one of HTTPClient.METHOD_XXXXX path: String, @@ -135,7 +138,7 @@ func bee_request( # Denormalization is handled in each generated API endpoint in the on_success callable of this method. # This is because this method already has plethora of parameters and we don't want even more. - bee_request_text( + _bee_request_text( method, path, headers, query, body, func(responseText, responseCode, responseHeaders): var mime: String = responseHeaders['Mime'] @@ -176,8 +179,7 @@ func bee_request( ) -# @protected -func bee_request_text( +func _bee_request_text( method: int, # one of HTTPClient.METHOD_XXXXX path: String, headers: Dictionary, @@ -186,9 +188,9 @@ func bee_request_text( on_success: Callable, # func(responseText: String, responseCode: int, responseHeaders: Dictionary) on_failure: Callable, # func(error: {{>partials/api_error_class_name}}) ): - bee_connect_client_if_needed( + _bee_connect_client_if_needed( func(): - bee_do_request_text(method, path, headers, query, body, on_success, on_failure) + _bee_do_request_text(method, path, headers, query, body, on_success, on_failure) , func(error): on_failure.call(error) @@ -196,8 +198,7 @@ func bee_request_text( ) -# @protected -func bee_do_request_text( +func _bee_do_request_text( method: int, # one of HTTPClient.METHOD_XXXXX path: String, headers: Dictionary, @@ -227,7 +228,7 @@ func bee_do_request_text( body_normalized = body.bee_normalize() var body_serialized := "" - var content_type := self.bee_get_content_type(headers) + var content_type := self._bee_get_content_type(headers) if content_type == BEE_CONTENT_TYPE_JSON: body_serialized = JSON.stringify(body_normalized) elif content_type == BEE_CONTENT_TYPE_FORM: @@ -246,6 +247,12 @@ func bee_do_request_text( for key in headers: headers_for_godot.append("%s: %s" % [key, headers[key]]) + self.bee_config.log_info("%s: REQUEST %s %s" % [self.bee_name, method, path_queried]) + if not headers.is_empty(): + self.bee_config.log_debug("→ HEADERS: %s" % [str(headers)]) + if body_serialized: + self.bee_config.log_debug("→ BODY: \n%s" % [body_serialized]) + var requesting := self.bee_client.request(method, path_queried, headers_for_godot, body_serialized) if requesting != OK: var error := {{>partials/api_error_class_name}}.new() @@ -263,14 +270,13 @@ func bee_do_request_text( self.bee_config.log_debug("Requesting…") if self.bee_config.polling_interval_ms: OS.delay_msec(self.bee_config.polling_interval_ms) - await bee_next_loop_iteration() -# if OS.has_feature("web") or async: + await _bee_next_loop_iteration() if not self.bee_client.has_response(): var error := {{>partials/api_error_class_name}}.new() error.identifier = "apibee.request.no_response" - error.message = "%s: request to `%s' yielded no response whatsoever." % [ - self.bee_name, path + error.message = "%s: request to `%s' returned no response whatsoever. (status=%d)" % [ + self.bee_name, path, self.bee_client.get_status(), ] on_failure.call(error) return @@ -293,16 +299,10 @@ func bee_do_request_text( if chunk.size() == 0: # Got nothing, wait for buffers to fill a bit. if self.bee_config.polling_interval_ms: OS.delay_usec(self.bee_config.polling_interval_ms) - await bee_next_loop_iteration() + await _bee_next_loop_iteration() else: # Yummy data has arrived response_bytes = response_bytes + chunk - self.bee_config.log_info("%s: REQUEST %s %s" % [self.bee_name, method, path_queried]) - if not headers.is_empty(): - self.bee_config.log_debug("→ HEADERS: %s" % [str(headers)]) - if body_serialized: - self.bee_config.log_debug("→ BODY: \n%s" % [body_serialized]) - self.bee_config.log_info("%s: RESPONSE %d (%d bytes)" % [ self.bee_name, response_code, response_bytes.size() ]) @@ -331,7 +331,7 @@ func bee_do_request_text( self.bee_name, path, response_code ] error.message += "\n%s" % [ - bee_format_error_response(response_text) + _bee_format_error_response(response_text) ] on_failure.call(error) return @@ -343,7 +343,7 @@ func bee_do_request_text( self.bee_name, path, response_code ] error.message += "\n%s" % [ - bee_format_error_response(response_text) + _bee_format_error_response(response_text) ] on_failure.call(error) return @@ -363,7 +363,7 @@ func bee_do_request_text( on_success.call(response_text, response_code, response_headers) -func bee_convert_http_method(method: String) -> int: +func _bee_convert_http_method(method: String) -> int: match method: 'GET': return HTTPClient.METHOD_GET 'POST': return HTTPClient.METHOD_POST @@ -382,23 +382,23 @@ func bee_convert_http_method(method: String) -> int: return HTTPClient.METHOD_GET -func bee_urlize_path_param(anything) -> String: - var serialized := bee_escape_path_param(str(anything)) +func _bee_urlize_path_param(anything) -> String: + var serialized := _bee_escape_path_param(str(anything)) return serialized -func bee_escape_path_param(value: String) -> String: +func _bee_escape_path_param(value: String) -> String: # TODO: escape for URL return value -func bee_get_content_type(headers: Dictionary) -> String: +func _bee_get_content_type(headers: Dictionary) -> String: if headers.has("Content-Type"): return headers["Content-Type"] return BEE_PRODUCIBLE_CONTENT_TYPES[0] -func bee_format_error_response(response: String) -> String: +func _bee_format_error_response(response: String) -> String: # TODO: handle other (de)serialization schemes var parser := JSON.new() var parsing := parser.parse(response) @@ -414,3 +414,58 @@ func bee_format_error_response(response: String) -> String: else: return response return s + + +func _bee_httpclient_status_info(status: int) -> Dictionary: + # At some point Godot ought to natively implement this and we won't need this "shim" anymore. + match status: + HTTPClient.STATUS_DISCONNECTED: return { + "name": "STATUS_DISCONNECTED", + "description": "Disconnected from the server." + } + HTTPClient.STATUS_RESOLVING: return { + "name": "STATUS_RESOLVING", + "description": "Currently resolving the hostname for the given URL into an IP." + } + HTTPClient.STATUS_CANT_RESOLVE: return { + "name": "STATUS_CANT_RESOLVE", + "description": "DNS failure: Can't resolve the hostname for the given URL." + } + HTTPClient.STATUS_CONNECTING: return { + "name": "STATUS_CONNECTING", + "description": "Currently connecting to server." + } + HTTPClient.STATUS_CANT_CONNECT: return { + "name": "STATUS_CANT_CONNECT", + "description": "Can't connect to the server." + } + HTTPClient.STATUS_CONNECTED: return { + "name": "STATUS_CONNECTED", + "description": "Connection established." + } + HTTPClient.STATUS_REQUESTING: return { + "name": "STATUS_REQUESTING", + "description": "Currently sending request." + } + HTTPClient.STATUS_BODY: return { + "name": "STATUS_BODY", + "description": "HTTP body received." + } + HTTPClient.STATUS_CONNECTION_ERROR: return { + "name": "STATUS_CONNECTION_ERROR", + "description": "Error in HTTP connection." + } + HTTPClient.STATUS_TLS_HANDSHAKE_ERROR: return { + "name": "STATUS_TLS_HANDSHAKE_ERROR", + "description": "Error in TLS handshake." + } + return { + "name": "UNKNOWN (%d)" % status, + "description": "Unknown HTTPClient status." + } + + +func _bee_httpclient_status_string(status: int) -> String: + var info := _bee_httpclient_status_info(status) + return "%s (%s)" % [info["description"], info["name"]] + diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars index 4465b19f88a9..a2c2db373f28 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiConfig.handlebars @@ -5,19 +5,24 @@ class_name {{>partials/api_config_class_name}} # Configuration options for Api endpoints -# --------------------------------------- +# ======================================= # -# Its purpose is to help you share configuration customizations across Apis: -# - host & port -# - headers & security schemes +# Helps share configuration customizations across Apis: +# - host, port & scheme +# - extra headers +# - security layer options (TLS certificates) # - log level +# +# You probably want to make an instance of this class with your own values, +# and feed it to each Api's `bee_config` before calling the Api's methods. +# # Since it is a Resource, you may use `ResourceSaver.save()` and `load()` -# to save it and load it from file, if you want. +# to save it and load it from file, for convenience. # -# These are constant, immutable default values. -# To set different values at runtime, use the public properties below. +# These are constant, immutable default values. Best not edit them. +# To set different values at runtime, use the @export'ed properties below. const BEE_DEFAULT_HOST := "{{#if host}}{{{host}}}{{else}}localhost{{/if}}" const BEE_DEFAULT_PORT_HTTP := 80 const BEE_DEFAULT_PORT_HTTPS := 443 @@ -25,7 +30,6 @@ const BEE_DEFAULT_POLLING_INTERVAL_MS := 333 # milliseconds # Configuration also handles logging because it's convenient. -# You may extend this class and override the log methods with your own if you need to. enum LogLevel { SILENT, ERROR, @@ -34,10 +38,17 @@ enum LogLevel { DEBUG, } + +# Log level to configure verbosity. +# @export_enum ain't working for ints yet (2023-03) +@export var log_level := LogLevel.WARNING + {{!-- # Not sure if this should hold the HTTPClient instance or not. Not for now. +# Godot recommends using a single client for all requests, so it should. + # Godot's HTTP Client we are using. -# If none was set (by you), we'll make one. +# If none was set (by you), we'll lazily make one. var bee_client: HTTPClient: set(value): bee_client = value @@ -53,10 +64,10 @@ var bee_client: HTTPClient: @export var host := BEE_DEFAULT_HOST: set(value): if value.begins_with("https://"): - ssl_enabled = true + tls_enabled = true value = value.substr(8) # "https://".length() == 8 elif value.begins_with("http://"): - ssl_enabled = false + tls_enabled = false value = value.substr(7) # "http://".length() == 7 host = value @@ -86,18 +97,32 @@ var bee_client: HTTPClient: @export var polling_interval_ms := BEE_DEFAULT_POLLING_INTERVAL_MS # milliseconds -# Should we encrypt packets ? Yes. Let's encrypt ! -@export var ssl_enabled := false: +# Enable the Transport Security Layer (packet encryption, HTTPS) +@export var tls_enabled := false: set(value): - ssl_enabled = value - port = BEE_DEFAULT_PORT_HTTPS if ssl_enabled else BEE_DEFAULT_PORT_HTTP + tls_enabled = value + port = BEE_DEFAULT_PORT_HTTPS if tls_enabled else BEE_DEFAULT_PORT_HTTP -@export var verify_host := true # only used if ssl is enabled +# You should preload your *.crt file (the whole chain) in here if you want TLS. +# I usually concatenate my /etc/ssl/certs/ca-certificates.crt and webserver certs here. +# Remember to add the *.crt file to the exports, if necessary. +@export var trusted_chain: X509Certificate # only used if tls is enabled +@export var common_name_override := "" # for TLSOptions -# @export_enum ain't working for ints yet -@export var log_level := LogLevel.WARNING +# Dynamic accessor using the TLS properties above, but you may inject your own +# for example if you need to use TLSOptions.client_unsafe. Best not @export this. +var tls_options: TLSOptions: + set(value): + tls_options = value + get: + if not tls_enabled: + return null + if not tls_options: + tls_options = TLSOptions.client(trusted_chain, common_name_override) + return tls_options + func log_error(message: String): if self.log_level >= LogLevel.ERROR: @@ -140,7 +165,7 @@ func set_security_{{name}}(value: String): {{else}} -# → Skipped because it's not implemented in the gdscript templates. (contribs welcome) +# → Skipped: not implemented in the gdscript templates. (contribs welcome) {{/if}} diff --git a/modules/openapi-generator/src/main/resources/gdscript/README.handlebars b/modules/openapi-generator/src/main/resources/gdscript/README.handlebars index 11af22ad8706..945e922998d5 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/README.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/README.handlebars @@ -4,7 +4,7 @@ {{{appDescriptionWithNewLines}}} {{/if}} -This Godot 4 addon is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: +This Godot 4 addon was automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: {{#if servers}} − Servers: @@ -109,4 +109,12 @@ Class | Method | HTTP request | Description {{/each}} {{/if}} -{{/each}} \ No newline at end of file +{{/each}} + + +## Troubleshooting + +### `TLS handshake error: -9984` + +https://github.com/godotengine/godot/issues/59080#issuecomment-1065973210 + diff --git a/modules/openapi-generator/src/main/resources/gdscript/README.md b/modules/openapi-generator/src/main/resources/gdscript/README.md index 543cbe5435a6..3ff666f3c92b 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/README.md +++ b/modules/openapi-generator/src/main/resources/gdscript/README.md @@ -24,7 +24,3 @@ Godot does not have an `Exception` (`try / catch`) mechanism, by design. Therefore, whenever there's trouble in paradise, we pass around an `ApiError` object. (a `RefCounted`, don't worry about garbage collection) - - - - diff --git a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars index d932c43e43af..83494e95f11e 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars @@ -132,10 +132,10 @@ func {{operationIdSnakeCase}}( {{/if}} {{/each}} # Convert the String HTTP method to a Constant Godot understands - var bzz_method := self.bee_convert_http_method("{{httpMethod}}") + var bzz_method := self._bee_convert_http_method("{{httpMethod}}") # Compute the URL path to the API resource - var bzz_path := "{{{contextPath}}}{{{path}}}"{{#each pathParams}}.replace("{" + "{{baseName}}" + "}", bee_urlize_path_param({{{paramName}}})){{/each}} + var bzz_path := "{{{contextPath}}}{{{path}}}"{{#each pathParams}}.replace("{" + "{{baseName}}" + "}", _bee_urlize_path_param({{{paramName}}})){{/each}} # Collect the headers var bzz_headers := Dictionary() From 407489d043ce898407f699e68b8ae970842d9eb0 Mon Sep 17 00:00:00 2001 From: Goutte Date: Wed, 12 Apr 2023 13:12:43 +0200 Subject: [PATCH 34/56] feat: experimental support of Request inline objects The inline response objects are still not supported. --- .../languages/GdscriptClientCodegen.java | 12 ++++--- .../main/resources/gdscript/api.handlebars | 36 +++++++++++++++---- .../gdscript/api_doc_example.handlebars | 4 ++- .../main/resources/gdscript/model.handlebars | 6 ++-- 4 files changed, 44 insertions(+), 14 deletions(-) diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java index fc7ae453c0f1..77ad447887b5 100644 --- a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java +++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java @@ -328,11 +328,15 @@ public String toExampleValue(Schema schema) { public String toDefaultValue(Schema schema) { if (schema.getDefault() != null) { if (schema instanceof StringSchema) { - return "\"" + schema.getDefault().toString() + "\"" ; + return "\"" + schema.getDefault().toString().replace("\"", "") + "\"" ; } return schema.getDefault().toString(); } + if (schema instanceof StringSchema) { + return "\"\""; + } + return ""; } @@ -371,9 +375,9 @@ protected List getReservedWords() { // Local properties used in Model classes "bee_class_name", // Local method names used in base API class - "bee_connect_client_if_needed", "bee_request", "bee_request_text", "bee_do_request_text", - "bee_convert_http_method", "bee_urlize_path_param", "bee_escape_path_param", - "bee_next_loop_iteration", "bee_get_content_type", "bee_format_error_response", + "bee_connect_client_if_needed", "bee_request", "_bee_request_text", "_bee_do_request_text", + "_bee_convert_http_method", "_bee_urlize_path_param", "_bee_escape_path_param", + "_bee_next_loop_iteration", "_bee_get_content_type", "_bee_format_error_response", // Local properties used in base API class "bee_config", "bee_client", "bee_name", // Local variable names used in API methods (endpoints) diff --git a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars index 83494e95f11e..9ea8a50e1d8e 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars @@ -9,6 +9,18 @@ {{#with operations}} {{#each operation}} +class {{coreNamePrefix}}{{operationIdCamelCase}}Request: + pass + + {{#allParams}} + # {{description}} + + {{#vars}} + var {{baseName}}: {{dataType}}{{#if defaultValue}} = {{{defaultValue}}}{{/if}} + {{/vars}} + {{/allParams}} + + {{#if isDeprecated}} # /!. DEPRECATED {{/if}} @@ -25,13 +37,7 @@ # {{{notes}}} {{/if}} func {{operationIdSnakeCase}}( - {{#each allParams}} - # {{paramName}}{{#if dataType}}: {{dataType}}{{/if}}{{#if defaultValue}} = {{{defaultValue}}}{{/if}}{{#if example}} Eg: {{{example}}}{{/if}} - # {{{description}}} - {{paramName}}{{#if required}}{{#if dataType}}: {{{dataType}}}{{/if}}{{/if}}{{#unless required}} = {{#if defaultValue}}{{{defaultValue}}}{{/if}}{{#unless defaultValue}}null{{/unless}}{{/unless}}, - {{/each}} - on_success: Callable = Callable(), # func(result{{#if returnType}}: {{returnType}}{{/if}}) - on_failure: Callable = Callable(), # func(error: {{>partials/api_error_class_name}}) +{{>partials/api_method_params}} ): {{!-- # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames. @@ -202,6 +208,22 @@ func {{operationIdSnakeCase}}( on_failure.call(bzz_error) , # ざわ‥ ) + + +func {{operationIdSnakeCase}}_threaded( +{{>partials/api_method_params}} +) -> Thread: + var bzz_thread := Thread.new() + var bzz_callable := Callable(self, "{{operationIdSnakeCase}}") + bzz_callable.bind( + {{#each allParams}} + {{paramName}}, + {{/each}} + on_success, + on_failure, + ) + bzz_thread.start(bzz_callable) + return bzz_thread {{/each}} {{/with}} diff --git a/modules/openapi-generator/src/main/resources/gdscript/api_doc_example.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api_doc_example.handlebars index 58fa1175ff15..ae7bb259417d 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/api_doc_example.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/api_doc_example.handlebars @@ -3,10 +3,12 @@ {{> doc_auth_partial}} --}} -# Customize configuration, if needed +# Customize configuration var config := {{>partials/api_config_class_name}}.new() config.host = "localhost" config.port = 8080 +config.trusted_chain = preload("res://my_cert_chain.crt") +config.tls_enabled = true var api = {{{classname}}}.new() api.config = config # optionally diff --git a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars index 56dec78e4768..90991c382a1f 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars @@ -5,6 +5,7 @@ # {{classname}} Model {{#if description}} +{{! FIXME: multiline description (how?) }} # {{{description}}} {{/if}} # namespace: {{modelPackage}} @@ -24,14 +25,15 @@ var bee_class_name := "{{classname}}" # /!. DEPRECATED {{/if}} {{#if description}} +{{! FIXME: multiline description (how?) }} # {{{description}}} {{/if}} # Type: {{>partials/data_type}} {{#if isDate}} -# (but it's actually a Date ; no generated conversion because of lack of support for timezones in Godot) +# (but it's actually a Date ; no timezones support in Godot) {{/if}} {{#if isDateTime}} -# (but it's actually a DateTime ; no generated conversion because of lack of support for timezones in Godot) +# (but it's actually a DateTime ; no timezones support in Godot) {{/if}} # Required: {{#unless required}}False{{/unless}}{{#if required}}True{{/if}} {{#if example}} From 1b290b999ec36c7dbe7cdaa08641fd72fcaf8ff0 Mon Sep 17 00:00:00 2001 From: Goutte Date: Thu, 13 Apr 2023 09:33:11 +0200 Subject: [PATCH 35/56] feat(gdscript): support inline request and response objects --- .../languages/GdscriptClientCodegen.java | 69 ++++++++++--------- .../main/resources/gdscript/api.handlebars | 40 ++--------- .../gdscript/partials/api_headers.handlebars | 3 + .../gdscript/partials/complex_type.handlebars | 5 +- .../gdscript/partials/data_type.handlebars | 6 +- 5 files changed, 51 insertions(+), 72 deletions(-) diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java index 77ad447887b5..1f896db104dd 100644 --- a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java +++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java @@ -207,23 +207,20 @@ public GdscriptClientCodegen() { typeMapping.put("datetime", "String"); typeMapping.put("DateTime", "String"); // case matters (format: date-time) typeMapping.put("date-time", "String"); // possibly useless - //typeMapping.put("binary", "any"); + //typeMapping.put("binary", "?"); typeMapping.put("file", "String"); // untested typeMapping.put("ByteArray", "Array"); typeMapping.put("UUID", "String"); - //typeMapping.put("Error", "Error"); + //typeMapping.put("Error", "?"); //typeMapping.put("AnyType", "Variant"); cliOptions.add(new CliOption(CORE_NAME_PREFIX, "PascalCase prefix added to all core classes")); cliOptions.add(new CliOption(CORE_NAME_SUFFIX, "PascalCase suffix added to all core classes")); - // This constructor is ran twice, because … reasons. // Also, I have not taken care of escaping things properly in the templates. // I'm not sure how to handle the different escaping strategies required. - LOGGER.warn("---- THIS GENERATOR IS UNSAFE AND MALICIOUS OAS FILES MAY HURT YOU ----"); + LOGGER.warn("---- THE GENERATED CODE MAY BE UNSAFE AND MALICIOUS OAS FILES MAY HURT YOU ----"); LOGGER.warn("PLEASE READ *CAREFULLY* THE OAS FILE YOU ARE USING BEFORE YOU TRUST IT."); - LOGGER.info("This generation itself should be safe but maybe not the generated code."); - } @Override @@ -231,12 +228,9 @@ public String defaultTemplatingEngine() { return "handlebars"; } - public void processAdditionalProperties() { - additionalProperties.put("apiDocPath", apiDocPath); additionalProperties.put("modelDocPath", modelDocPath); - additionalProperties.put("modelNameSuffix", modelNameSuffix); if (additionalProperties.containsKey(CORE_NAME_PREFIX)) { @@ -274,6 +268,16 @@ public void processOpts() { } } + @Override + public String apiDocFileFolder() { + return (outputFolder + File.separator + apiDocPath); + } + + @Override + public String modelDocFileFolder() { + return (outputFolder + File.separator + modelDocPath); + } + @Override public String escapeUnsafeCharacters(String input) { // There might be ways to inject code in Gdscript, but I don't see any for now. (no /* */ comments) @@ -292,6 +296,13 @@ public String escapeQuotationMark(String input) { ; } + public String escapeStringLiteral(String input) { + return input + .replace("\"", "\\\"") + .replaceAll("[\\\\]+$", "") + ; + } + // In GDScript we want our file names to match our class names. // This ensures we get the (optional) prefix and suffix added to the file name. // Perhaps we'll even do (optional) snake_case in here later on. @@ -304,21 +315,10 @@ public String toCoreFilename(String name) { return camelize(getCoreNamePrefix() + '_' + name + '_' + getCoreNameSuffix()); } - @Override - public String apiDocFileFolder() { - return (outputFolder + File.separator + apiDocPath); - } - - @Override - public String modelDocFileFolder() { - return (outputFolder + File.separator + modelDocPath); - } - - @Override public String toExampleValue(Schema schema) { if (schema.getExample() != null) { - return super.toExampleValue(schema); + return escapeStringLiteral(super.toExampleValue(schema)); } return ""; @@ -328,7 +328,7 @@ public String toExampleValue(Schema schema) { public String toDefaultValue(Schema schema) { if (schema.getDefault() != null) { if (schema instanceof StringSchema) { - return "\"" + schema.getDefault().toString().replace("\"", "") + "\"" ; + return "\"" + escapeStringLiteral(schema.getDefault().toString()) + "\""; } return schema.getDefault().toString(); } @@ -337,23 +337,28 @@ public String toDefaultValue(Schema schema) { return "\"\""; } - return ""; + return super.toDefaultValue(schema); + } + + @Override + public String getTypeDeclaration(Schema schema) { + String type = super.getTypeDeclaration(schema); + + // purpose: camelize the inline response models dataType (requests are already fine) + // Possibly not the correct way to do it but I've tried many, many things. + if (type.contains("_")) { + type = camelize(type); + } + + return type; } - // ApiPlatform for example generates `SomeModel.jsonld` models. - // We do not support jsonld for now, so we are skipping them. @Override public Map updateAllModels(Map objs) { objs = super.updateAllModels(objs); String[] names = objs.keySet().toArray(new String[0]); for (String modelName : names) { - // Skip models with underscores, responses and @context in jsonld - // eg: api_somemodel_get_collection_200_response, SomeModel_jsonld__context - if (modelName.contains("_")) { - objs.remove(modelName); - LOGGER.warn("Skipped model " + modelName + " (underscore not supported)"); - } // Skip models with jsonld, we don't support them atm // eg: Announcement.jsonld if (modelName.contains("jsonld")) { @@ -361,7 +366,7 @@ public Map updateAllModels(Map objs) { LOGGER.warn("Skipped model " + modelName + " (jsonld not supported)"); } // Also skip Hydra models, we're not supporting them atm - if (modelName.contains("Hydra")) { + if (modelName.contains("Hydra") || modelName.contains("hydra")) { objs.remove(modelName); LOGGER.warn("Skipped model " + modelName + " (hydra not supported)"); } diff --git a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars index 9ea8a50e1d8e..22df52339df8 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars @@ -1,26 +1,11 @@ -{{>partials/api_headers}} - -# API {{classname}} - {{>partials/api_statement_extends}} - {{>partials/api_statement_class_name}} +{{>partials/api_headers}} + {{#with operations}} {{#each operation}} -class {{coreNamePrefix}}{{operationIdCamelCase}}Request: - pass - - {{#allParams}} - # {{description}} - - {{#vars}} - var {{baseName}}: {{dataType}}{{#if defaultValue}} = {{{defaultValue}}}{{/if}} - {{/vars}} - {{/allParams}} - - {{#if isDeprecated}} # /!. DEPRECATED {{/if}} @@ -39,21 +24,11 @@ class {{coreNamePrefix}}{{operationIdCamelCase}}Request: func {{operationIdSnakeCase}}( {{>partials/api_method_params}} ): - {{!-- - # Note: `bzz_` prefix in variable names is to reduce collisions and therefore renames. - # Warn: Make sure all local variable names here are also listed in our Java CodeGen. - --}} - # CollectionFormat: {{#if collectionFormat}}YES{{/if}}{{#unless collectionFormat}}NO{{/unless}} {{#if isDeprecated}} push_warning("Usage of `{{operationIdSnakeCase}}()` is deprecated.") {{/if}} {{#each allParams}} -{{!-- - # Verify required param `{{paramName}}` is set - # → done by the (non-nullable) type in func signature, - # perhaps we could check against null or empty array anyway? ---}} {{#if hasValidation}} # Validate param `{{paramName}}` constraints {{#if maxLength}} @@ -120,11 +95,9 @@ func {{operationIdSnakeCase}}( {{/if}} {{/if}} {{#if pattern}} - {{!#if isString}}{{! We are lenient and casting the param to string before trying to match }} var bzz_{{paramName}}_regex := RegEx.new() - {{! We have to trim encapsulating slashes, and we don't support flags }} - {{! A solution would be to use another RegEx to extract that data from the pattern }} - {{! Perhaps not, since the encapsulating slashes are seemingly added by the engine… }} + {{! These regex trimming shenanigans will fail if regex has flags }} + {{! A solution would be to use another RegEx to extract that data from the pattern ? }} bzz_{{paramName}}_regex.compile("{{{pattern}}}".trim_prefix('/').trim_suffix('/')) if not bzz_{{paramName}}_regex.search(str({{paramName}})): var error := {{>partials/api_error_class_name}}.new() @@ -132,7 +105,6 @@ func {{operationIdSnakeCase}}( error.message = "Invalid value for `{{paramName}}`, must conform to the pattern `{{{pattern}}}`." on_failure.call(error) return - {{!/if}} {{/if}} {{/if}} @@ -157,7 +129,6 @@ func {{operationIdSnakeCase}}( bzz_found_producible_mime = true break if not bzz_found_producible_mime: - # This is a bit strict, perhaps we could just push a warning and send JSON anyway? var error := {{>partials/api_error_class_name}}.new() error.identifier = "{{operationIdSnakeCase}}.headers.content_type" error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." @@ -182,6 +153,7 @@ func {{operationIdSnakeCase}}( var bzz_body = null {{#if bodyParams}} {{#each bodyParams}} + {{! What should happen here when there are multiple body params? for now last wins }} bzz_body = {{paramName}} {{/each}} {{/if}} @@ -199,7 +171,7 @@ func {{operationIdSnakeCase}}( {{#if isArray}} bzz_result = {{>partials/complex_type}}.bee_denormalize_multiple(bzz_result) {{else if isModel}} - bzz_result = {{>partials/complex_type}}.bee_denormalize_single(bzz_result) + bzz_result = {{>partials/data_type}}.bee_denormalize_single(bzz_result) {{/if}} {{/with}} on_success.call(bzz_result) diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/api_headers.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/api_headers.handlebars index abc3202e3550..ade76368be55 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/partials/api_headers.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/api_headers.handlebars @@ -1 +1,4 @@ {{>partials/disclaimer_autogenerated}} + +# API {{classname}} +# Instantiate this object and use it to make requests to the API. diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/complex_type.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/complex_type.handlebars index fe7ba46ce46d..4e0e28c153c9 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/partials/complex_type.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/complex_type.handlebars @@ -1,3 +1,2 @@ -{{! Hotfix to ensure our complex types include the "namespace" }} -{{! FIXME: Unregistered helper name 'modelNameSuffix', processing template }} -{{modelNamePrefix}}{{complexType}}{{modelNameSuffix}} \ No newline at end of file +{{! Hotfix to ensure our complex types include the "namespace" ~}} +{{modelNamePrefix}}{{complexType}}{{modelNameSuffix~}} diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/data_type.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/data_type.handlebars index 5479dbd5a733..7048df07b84f 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/partials/data_type.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/data_type.handlebars @@ -1,3 +1,3 @@ -{{! Hotfix to ensure our data types include the "namespace" }} -{{#if isModel}}{{modelNamePrefix}}{{dataType}}{{modelNameSuffix}}{{/if~}} -{{#unless isModel}}{{dataType}}{{/unless}} \ No newline at end of file +{{! Hotfix to ensure our data types include the "namespace" ~}} +{{#if isModel}}{{modelNamePrefix}}{{{dataType}}}{{modelNameSuffix}}{{/if~}} +{{#unless isModel}}{{{dataType}}}{{/unless~}} From 6491c91e56327e936f8b91b80355048d55a51212 Mon Sep 17 00:00:00 2001 From: Goutte Date: Thu, 13 Apr 2023 11:44:36 +0200 Subject: [PATCH 36/56] chore(gdscript): review the templates --- .../main/resources/gdscript/api.handlebars | 1 + .../main/resources/gdscript/model.handlebars | 23 ++++++------------- .../api_statement_class_name.handlebars | 2 +- .../partials/api_statement_extends.handlebars | 2 +- .../disclaimer_autogenerated.handlebars | 2 +- .../partials/model_headers.handlebars | 8 ++++++- .../model_statement_class_name.handlebars | 2 +- 7 files changed, 19 insertions(+), 21 deletions(-) diff --git a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars index 22df52339df8..f8a87ca4360d 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars @@ -1,6 +1,7 @@ {{>partials/api_statement_extends}} {{>partials/api_statement_class_name}} + {{>partials/api_headers}} {{#with operations}} diff --git a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars index 90991c382a1f..4927f0ef5a08 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars @@ -1,22 +1,14 @@ -{{>partials/api_headers}} - {{#each models}} {{#with model}} - -# {{classname}} Model -{{#if description}} -{{! FIXME: multiline description (how?) }} -# {{{description}}} -{{/if}} -# namespace: {{modelPackage}} - {{>partials/model_statement_extends}} - {{>partials/model_statement_class_name}} +{{>partials/model_headers}} + + # It's convenient to know the class name, for error messages. -# https://github.com/godotengine/godot/issues/21789 +# Remove once https://github.com/godotengine/godot/issues/21789 var bee_class_name := "{{classname}}" @@ -28,12 +20,11 @@ var bee_class_name := "{{classname}}" {{! FIXME: multiline description (how?) }} # {{{description}}} {{/if}} -# Type: {{>partials/data_type}} {{#if isDate}} -# (but it's actually a Date ; no timezones support in Godot) +# (but it's actually a Date ; no timezones support in Gdscript) {{/if}} {{#if isDateTime}} -# (but it's actually a DateTime ; no timezones support in Godot) +# (but it's actually a DateTime ; no timezones support in Gdscript) {{/if}} # Required: {{#unless required}}False{{/unless}}{{#if required}}True{{/if}} {{#if example}} @@ -51,7 +42,7 @@ var bee_class_name := "{{classname}}" {{/if}} {{#if isEnum}} if str(value) != "" and not (str(value) in __{{name}}__allowable__values): - printerr("{{classname}}: tried to set property `{{name}}` to a value that is not allowed." + + push_error("{{classname}}: tried to set property `{{name}}` to a value that is not allowed." + " Allowed values: {{#with allowableValues}}{{#each values}}`{{this}}`{{#unless @last}}, {{/unless}}{{/each}}{{/with}}") return {{/if}} diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_class_name.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_class_name.handlebars index d9bc3d09cb98..909ca91ef095 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_class_name.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_class_name.handlebars @@ -1 +1 @@ -{{>partials/statement_class_name}} \ No newline at end of file +{{>partials/statement_class_name}} diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_extends.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_extends.handlebars index 40d581d706b0..1c54bc905c0d 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_extends.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/api_statement_extends.handlebars @@ -1 +1 @@ -extends {{>partials/api_base_class_name}} \ No newline at end of file +extends {{>partials/api_base_class_name}} diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/disclaimer_autogenerated.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/disclaimer_autogenerated.handlebars index cc37040af118..03873f4648d1 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/partials/disclaimer_autogenerated.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/disclaimer_autogenerated.handlebars @@ -1,4 +1,4 @@ # THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. # For more information on how to customize templates, see: # https://openapi-generator.tech -# The OpenAPI Generator Community, © Public Domain, 2022 \ No newline at end of file +# The OpenAPI Generator Community, © Public Domain, 2022 diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/model_headers.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/model_headers.handlebars index 7949f58a71ba..0f8264c7102e 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/partials/model_headers.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/model_headers.handlebars @@ -1 +1,7 @@ -{{>partials/disclaimer_autogenerated}} \ No newline at end of file +{{>partials/disclaimer_autogenerated}} + +# {{classname}} Model +{{#if description}} +{{! FIXME: multiline description (how?) }} +# {{{description}}} +{{/if}} diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/model_statement_class_name.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/model_statement_class_name.handlebars index d9bc3d09cb98..909ca91ef095 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/partials/model_statement_class_name.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/model_statement_class_name.handlebars @@ -1 +1 @@ -{{>partials/statement_class_name}} \ No newline at end of file +{{>partials/statement_class_name}} From 696dea0d4a1784ee4307f02b2760150c121f99cf Mon Sep 17 00:00:00 2001 From: Goutte Date: Fri, 14 Apr 2023 01:04:39 +0200 Subject: [PATCH 37/56] fix(gdscript): unexpected nulls in default values {{#if defaultValue}} evaluates to true for null if we call super here. --- .../openapitools/codegen/languages/GdscriptClientCodegen.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java index 1f896db104dd..71c869a691b0 100644 --- a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java +++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java @@ -337,7 +337,7 @@ public String toDefaultValue(Schema schema) { return "\"\""; } - return super.toDefaultValue(schema); + return null; // if instead we call super here, we get "null" where we should not } @Override From 39600e756bda2548309d9736eb31aed46507c01c Mon Sep 17 00:00:00 2001 From: Goutte Date: Fri, 14 Apr 2023 04:00:15 +0200 Subject: [PATCH 38/56] refacto(gdscript): replace "bee" prefix by "bzz", use a constructor Now we pass the config and the client via the constructor. This reduces the area of the public surface a bit, for the better I think. This commit also cleans up the class name shenanigans. --- .../main/resources/gdscript/ApiBee.handlebars | 210 ++++++++++-------- .../main/resources/gdscript/api.handlebars | 13 +- .../gdscript/api_doc_example.handlebars | 23 +- .../main/resources/gdscript/model.handlebars | 23 +- 4 files changed, 141 insertions(+), 128 deletions(-) diff --git a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars index cd1ffbf1eb5b..542e08a06f5d 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/ApiBee.handlebars @@ -1,3 +1,4 @@ +{{! TODO: would be nice to be able to customize parent class from CLI }} extends RefCounted class_name {{>partials/api_base_class_name}} @@ -6,7 +7,7 @@ class_name {{>partials/api_base_class_name}} # Every property/method defined here may collide with userland, # so these are all listed and excluded in our CodeGen Java file. # We want to keep the amount of renaming to a minimum, though. -# Therefore, we use the bee_ and _bee_ prefixes, even if awkward. +# Therefore, we use the _bzz_ prefix, even if awkward. const BEE_CONTENT_TYPE_TEXT := "text/plain" @@ -32,92 +33,107 @@ const BEE_CONSUMABLE_CONTENT_TYPES := [ ] -# We'll probably only use this for logging. -# Each Api child can define its own, and it should be similar to class_name. -var bee_name := "ApiBee" - - # Godot's HTTP Client this Api instance is using. # If none was set (by you), we'll lazily make one. -var bee_client: HTTPClient: +var _bzz_client: HTTPClient: set(value): - bee_client = value + _bzz_client = value get: - if not bee_client: - bee_client = HTTPClient.new() - return bee_client + if not _bzz_client: + _bzz_client = HTTPClient.new() + return _bzz_client # General configuration that can be shared across Api instances for convenience. # If no configuration was provided, we'll lazily make one with defaults, # but you probably want to make your own with your own domain and scheme. -var bee_config: {{>partials/api_config_class_name}}: +var _bzz_config: {{>partials/api_config_class_name}}: set(value): - bee_config = value - # TODO: renew client (needs to invalidate on config's property change as well) + _bzz_config = value + get: + if not _bzz_config: + _bzz_config = {{>partials/api_config_class_name}}.new() + return _bzz_config + + +var _bzz_name: String: get: - if not bee_config: - bee_config = {{>partials/api_config_class_name}}.new() - return bee_config + return _bzz_get_api_name() + + +# Constructor, where you probably want to inject your configuration, +# and as Godot recommends re-using HTTP clients, your client as well. +func _init(config : {{>partials/api_config_class_name}} = null, client : HTTPClient = null): + if config != null: + self._bzz_config = config + if client != null: + self._bzz_client = client + + +{{! We'll probably only use this for logging. }} +{{! Each Api child can define its own, and it should be similar to class_name. }} +{{! https://github.com/godotengine/godot/issues/21789 }} +func _bzz_get_api_name() -> String: + return "ApiBee" -func _bee_next_loop_iteration(): +func _bzz_next_loop_iteration(): # I can't find `idle_frame` in 4.0, but we probably want idle_frame here return Engine.get_main_loop().process_frame -func _bee_connect_client_if_needed( +func _bzz_connect_client_if_needed( on_success: Callable, # func() on_failure: Callable, # func(error: {{>partials/api_error_class_name}}) #finally: Callable, ): if ( - self.bee_client.get_status() == HTTPClient.STATUS_CONNECTED + self._bzz_client.get_status() == HTTPClient.STATUS_CONNECTED or - self.bee_client.get_status() == HTTPClient.STATUS_RESOLVING + self._bzz_client.get_status() == HTTPClient.STATUS_RESOLVING or - self.bee_client.get_status() == HTTPClient.STATUS_CONNECTING + self._bzz_client.get_status() == HTTPClient.STATUS_CONNECTING or - self.bee_client.get_status() == HTTPClient.STATUS_REQUESTING + self._bzz_client.get_status() == HTTPClient.STATUS_REQUESTING or - self.bee_client.get_status() == HTTPClient.STATUS_BODY + self._bzz_client.get_status() == HTTPClient.STATUS_BODY ): on_success.call() - var connecting := self.bee_client.connect_to_host( - self.bee_config.host, self.bee_config.port, self.bee_config.tls_options + var connecting := self._bzz_client.connect_to_host( + self._bzz_config.host, self._bzz_config.port, self._bzz_config.tls_options ) if connecting != OK: var error := {{>partials/api_error_class_name}}.new() error.internal_code = connecting error.identifier = "apibee.connect_to_host.failure" error.message = "%s: failed to connect to `%s' port `%d' with error: %s" % [ - self.bee_name, self.bee_config.host, self.bee_config.port, - _bee_httpclient_status_string(connecting), + _bzz_name, self._bzz_config.host, self._bzz_config.port, + _bzz_httpclient_status_string(connecting), ] on_failure.call(error) return # Wait until resolved and connected. while ( - self.bee_client.get_status() == HTTPClient.STATUS_CONNECTING + self._bzz_client.get_status() == HTTPClient.STATUS_CONNECTING or - self.bee_client.get_status() == HTTPClient.STATUS_RESOLVING + self._bzz_client.get_status() == HTTPClient.STATUS_RESOLVING ): - self.bee_client.poll() - self.bee_config.log_debug("Connecting…") - if self.bee_config.polling_interval_ms: - OS.delay_msec(self.bee_config.polling_interval_ms) - await _bee_next_loop_iteration() + self._bzz_client.poll() + self._bzz_config.log_debug("Connecting…") + if self._bzz_config.polling_interval_ms: + OS.delay_msec(self._bzz_config.polling_interval_ms) + await _bzz_next_loop_iteration() - var connected := self.bee_client.get_status() + var connected := self._bzz_client.get_status() if connected != HTTPClient.STATUS_CONNECTED: var error := {{>partials/api_error_class_name}}.new() error.internal_code = connected as Error error.identifier = "apibee.connect_to_host.wrong_status" error.message = "%s: failed to connect to `%s' port `%d' : %s" % [ - self.bee_name, self.bee_config.host, self.bee_config.port, - _bee_httpclient_status_string(connected), + _bzz_name, self._bzz_config.host, self._bzz_config.port, + _bzz_httpclient_status_string(connected), ] on_failure.call(error) return @@ -125,7 +141,7 @@ func _bee_connect_client_if_needed( on_success.call() -func bee_request( +func bzz_request( method: int, # one of HTTPClient.METHOD_XXXXX path: String, headers: Dictionary, @@ -138,7 +154,7 @@ func bee_request( # Denormalization is handled in each generated API endpoint in the on_success callable of this method. # This is because this method already has plethora of parameters and we don't want even more. - _bee_request_text( + _bzz_request_text( method, path, headers, query, body, func(responseText, responseCode, responseHeaders): var mime: String = responseHeaders['Mime'] @@ -156,7 +172,7 @@ func bee_request( error.internal_code = parsing error.identifier = "apibee.decode.cannot_parse_json" error.message = "%s: failed to parse JSON response at line %d.\n%s" % [ - self.bee_name, parser.get_error_line(), parser.get_error_message() + _bzz_name, parser.get_error_line(), parser.get_error_message() ] on_failure.call(error) return @@ -166,7 +182,7 @@ func bee_request( error.internal_code = ERR_INVALID_DATA error.identifier = "apibee.decode.mime_type_unsupported" error.message = "%s: mime type `%s' is not supported (yet)" % [ - self.bee_name, mime + _bzz_name, mime ] on_failure.call(error) return @@ -179,7 +195,7 @@ func bee_request( ) -func _bee_request_text( +func _bzz_request_text( method: int, # one of HTTPClient.METHOD_XXXXX path: String, headers: Dictionary, @@ -188,9 +204,9 @@ func _bee_request_text( on_success: Callable, # func(responseText: String, responseCode: int, responseHeaders: Dictionary) on_failure: Callable, # func(error: {{>partials/api_error_class_name}}) ): - _bee_connect_client_if_needed( + _bzz_connect_client_if_needed( func(): - _bee_do_request_text(method, path, headers, query, body, on_success, on_failure) + _bzz_do_request_text(method, path, headers, query, body, on_success, on_failure) , func(error): on_failure.call(error) @@ -198,7 +214,7 @@ func _bee_request_text( ) -func _bee_do_request_text( +func _bzz_do_request_text( method: int, # one of HTTPClient.METHOD_XXXXX path: String, headers: Dictionary, @@ -209,36 +225,36 @@ func _bee_do_request_text( ): headers = headers.duplicate(true) - headers.merge(self.bee_config.headers_base) - headers.merge(self.bee_config.headers_override, true) + headers.merge(self._bzz_config.headers_base) + headers.merge(self._bzz_config.headers_override, true) var body_normalized = body if body is Object: - if body.has_method('bee_collect_missing_properties'): - var missing_properties : Array = body.bee_collect_missing_properties() + if body.has_method('bzz_collect_missing_properties'): + var missing_properties : Array = body.bzz_collect_missing_properties() if missing_properties: var error := {{>partials/api_error_class_name}}.new() error.identifier = "apibee.request.body.missing_properties" error.message = "%s: `%s' is missing required properties %s." % [ - self.bee_name, body.bee_class_name, missing_properties + _bzz_name, body.bzz_class_name, missing_properties ] on_failure.call(error) return - if body.has_method('bee_normalize'): - body_normalized = body.bee_normalize() + if body.has_method('bzz_normalize'): + body_normalized = body.bzz_normalize() var body_serialized := "" - var content_type := self._bee_get_content_type(headers) + var content_type := self._bzz_get_content_type(headers) if content_type == BEE_CONTENT_TYPE_JSON: body_serialized = JSON.stringify(body_normalized) elif content_type == BEE_CONTENT_TYPE_FORM: - body_serialized = self.bee_client.query_string_from_dict(body_normalized) + body_serialized = self._bzz_client.query_string_from_dict(body_normalized) else: # TODO: Handle other serialization schemes (json+ld, xml…) push_warning("Unsupported content-type `%s`." % content_type) var path_queried := path - var query_string := self.bee_client.query_string_from_dict(query) + var query_string := self._bzz_client.query_string_from_dict(query) if query_string: path_queried = "%s?%s" % [path, query_string] @@ -247,42 +263,42 @@ func _bee_do_request_text( for key in headers: headers_for_godot.append("%s: %s" % [key, headers[key]]) - self.bee_config.log_info("%s: REQUEST %s %s" % [self.bee_name, method, path_queried]) + self._bzz_config.log_info("%s: REQUEST %s %s" % [_bzz_name, method, path_queried]) if not headers.is_empty(): - self.bee_config.log_debug("→ HEADERS: %s" % [str(headers)]) + self._bzz_config.log_debug("→ HEADERS: %s" % [str(headers)]) if body_serialized: - self.bee_config.log_debug("→ BODY: \n%s" % [body_serialized]) + self._bzz_config.log_debug("→ BODY: \n%s" % [body_serialized]) - var requesting := self.bee_client.request(method, path_queried, headers_for_godot, body_serialized) + var requesting := self._bzz_client.request(method, path_queried, headers_for_godot, body_serialized) if requesting != OK: var error := {{>partials/api_error_class_name}}.new() error.internal_code = requesting error.identifier = "apibee.request.failure" error.message = "%s: failed to request to path `%s'." % [ - self.bee_name, path + _bzz_name, path ] on_failure.call(error) return - while self.bee_client.get_status() == HTTPClient.STATUS_REQUESTING: + while self._bzz_client.get_status() == HTTPClient.STATUS_REQUESTING: # Keep polling for as long as the request is being processed. - self.bee_client.poll() - self.bee_config.log_debug("Requesting…") - if self.bee_config.polling_interval_ms: - OS.delay_msec(self.bee_config.polling_interval_ms) - await _bee_next_loop_iteration() + self._bzz_client.poll() + self._bzz_config.log_debug("Requesting…") + if self._bzz_config.polling_interval_ms: + OS.delay_msec(self._bzz_config.polling_interval_ms) + await _bzz_next_loop_iteration() - if not self.bee_client.has_response(): + if not self._bzz_client.has_response(): var error := {{>partials/api_error_class_name}}.new() error.identifier = "apibee.request.no_response" error.message = "%s: request to `%s' returned no response whatsoever. (status=%d)" % [ - self.bee_name, path, self.bee_client.get_status(), + _bzz_name, path, self._bzz_client.get_status(), ] on_failure.call(error) return - var response_code := self.bee_client.get_response_code() - var response_headers := self.bee_client.get_response_headers_as_dictionary() + var response_code := self._bzz_client.get_response_code() + var response_headers := self._bzz_client.get_response_headers_as_dictionary() # FIXME: extract from headers "Content-Type": "application/json; charset=utf-8" # This begs for a HttpResponse class ; wait for Godot? var encoding := "utf-8" @@ -293,21 +309,21 @@ func _bee_do_request_text( # TODO: cap the size of this, perhaps? var response_bytes := PackedByteArray() - while self.bee_client.get_status() == HTTPClient.STATUS_BODY: - self.bee_client.poll() - var chunk = self.bee_client.read_response_body_chunk() + while self._bzz_client.get_status() == HTTPClient.STATUS_BODY: + self._bzz_client.poll() + var chunk = self._bzz_client.read_response_body_chunk() if chunk.size() == 0: # Got nothing, wait for buffers to fill a bit. - if self.bee_config.polling_interval_ms: - OS.delay_usec(self.bee_config.polling_interval_ms) - await _bee_next_loop_iteration() + if self._bzz_config.polling_interval_ms: + OS.delay_usec(self._bzz_config.polling_interval_ms) + await _bzz_next_loop_iteration() else: # Yummy data has arrived response_bytes = response_bytes + chunk - self.bee_config.log_info("%s: RESPONSE %d (%d bytes)" % [ - self.bee_name, response_code, response_bytes.size() + self._bzz_config.log_info("%s: RESPONSE %d (%d bytes)" % [ + _bzz_name, response_code, response_bytes.size() ]) if not response_headers.is_empty(): - self.bee_config.log_debug("→ HEADERS: %s" % str(response_headers)) + self._bzz_config.log_debug("→ HEADERS: %s" % str(response_headers)) var response_text: String if encoding == "utf-8": @@ -320,7 +336,7 @@ func _bee_do_request_text( response_text = response_bytes.get_string_from_ascii() if response_text: - self.bee_config.log_debug("→ BODY: \n%s" % response_text) + self._bzz_config.log_debug("→ BODY: \n%s" % response_text) if response_code >= 500: var error := {{>partials/api_error_class_name}}.new() @@ -328,10 +344,10 @@ func _bee_do_request_text( error.response_code = response_code error.identifier = "apibee.response.5xx" error.message = "%s: request to `%s' made the server hiccup with a %d." % [ - self.bee_name, path, response_code + _bzz_name, path, response_code ] error.message += "\n%s" % [ - _bee_format_error_response(response_text) + _bzz_format_error_response(response_text) ] on_failure.call(error) return @@ -340,10 +356,10 @@ func _bee_do_request_text( error.identifier = "apibee.response.4xx" error.response_code = response_code error.message = "%s: request to `%s' was denied with a %d." % [ - self.bee_name, path, response_code + _bzz_name, path, response_code ] error.message += "\n%s" % [ - _bee_format_error_response(response_text) + _bzz_format_error_response(response_text) ] on_failure.call(error) return @@ -352,18 +368,18 @@ func _bee_do_request_text( error.identifier = "apibee.response.3xx" error.response_code = response_code error.message = "%s: request to `%s' was redirected with a %d. We do not support redirects in that client yet." % [ - self.bee_name, path, response_code + _bzz_name, path, response_code ] on_failure.call(error) return # Should we close ? - #self.bee_client.close() + #self._bzz_client.close() on_success.call(response_text, response_code, response_headers) -func _bee_convert_http_method(method: String) -> int: +func _bzz_convert_http_method(method: String) -> int: match method: 'GET': return HTTPClient.METHOD_GET 'POST': return HTTPClient.METHOD_POST @@ -377,28 +393,28 @@ func _bee_convert_http_method(method: String) -> int: 'TRACE': return HTTPClient.METHOD_TRACE _: push_error("%s: unknown http method `%s`, assuming GET." % [ - self.bee_name, method + _bzz_name, method ]) return HTTPClient.METHOD_GET -func _bee_urlize_path_param(anything) -> String: - var serialized := _bee_escape_path_param(str(anything)) +func _bzz_urlize_path_param(anything) -> String: + var serialized := _bzz_escape_path_param(str(anything)) return serialized -func _bee_escape_path_param(value: String) -> String: +func _bzz_escape_path_param(value: String) -> String: # TODO: escape for URL return value -func _bee_get_content_type(headers: Dictionary) -> String: +func _bzz_get_content_type(headers: Dictionary) -> String: if headers.has("Content-Type"): return headers["Content-Type"] return BEE_PRODUCIBLE_CONTENT_TYPES[0] -func _bee_format_error_response(response: String) -> String: +func _bzz_format_error_response(response: String) -> String: # TODO: handle other (de)serialization schemes var parser := JSON.new() var parsing := parser.parse(response) @@ -416,7 +432,7 @@ func _bee_format_error_response(response: String) -> String: return s -func _bee_httpclient_status_info(status: int) -> Dictionary: +func _bzz_httpclient_status_info(status: int) -> Dictionary: # At some point Godot ought to natively implement this and we won't need this "shim" anymore. match status: HTTPClient.STATUS_DISCONNECTED: return { @@ -465,7 +481,7 @@ func _bee_httpclient_status_info(status: int) -> Dictionary: } -func _bee_httpclient_status_string(status: int) -> String: - var info := _bee_httpclient_status_info(status) +func _bzz_httpclient_status_string(status: int) -> String: + var info := _bzz_httpclient_status_info(status) return "%s (%s)" % [info["description"], info["name"]] diff --git a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars index f8a87ca4360d..4005ce25f2f5 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/api.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/api.handlebars @@ -4,6 +4,9 @@ {{>partials/api_headers}} +func _bzz_get_api_name() -> String: + return "{{classname}}" + {{#with operations}} {{#each operation}} @@ -111,10 +114,10 @@ func {{operationIdSnakeCase}}( {{/if}} {{/each}} # Convert the String HTTP method to a Constant Godot understands - var bzz_method := self._bee_convert_http_method("{{httpMethod}}") + var bzz_method := self._bzz_convert_http_method("{{httpMethod}}") # Compute the URL path to the API resource - var bzz_path := "{{{contextPath}}}{{{path}}}"{{#each pathParams}}.replace("{" + "{{baseName}}" + "}", _bee_urlize_path_param({{{paramName}}})){{/each}} + var bzz_path := "{{{contextPath}}}{{{path}}}"{{#each pathParams}}.replace("{" + "{{baseName}}" + "}", _bzz_urlize_path_param({{{paramName}}})){{/each}} # Collect the headers var bzz_headers := Dictionary() @@ -165,14 +168,14 @@ func {{operationIdSnakeCase}}( {{/each}} {{/if}} - self.bee_request( + self.bzz_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): {{#with returnProperty}} {{#if isArray}} - bzz_result = {{>partials/complex_type}}.bee_denormalize_multiple(bzz_result) + bzz_result = {{>partials/complex_type}}.bzz_denormalize_multiple(bzz_result) {{else if isModel}} - bzz_result = {{>partials/data_type}}.bee_denormalize_single(bzz_result) + bzz_result = {{>partials/data_type}}.bzz_denormalize_single(bzz_result) {{/if}} {{/with}} on_success.call(bzz_result) diff --git a/modules/openapi-generator/src/main/resources/gdscript/api_doc_example.handlebars b/modules/openapi-generator/src/main/resources/gdscript/api_doc_example.handlebars index ae7bb259417d..f889faa4f386 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/api_doc_example.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/api_doc_example.handlebars @@ -1,27 +1,27 @@ ```gdscript -{{!-- -{{> doc_auth_partial}} ---}} # Customize configuration var config := {{>partials/api_config_class_name}}.new() config.host = "localhost" config.port = 8080 -config.trusted_chain = preload("res://my_cert_chain.crt") -config.tls_enabled = true +#config.tls_enabled = true +#config.trusted_chain = preload("res://my_cert_chain.crt") -var api = {{{classname}}}.new() -api.config = config # optionally +# Instantiate the api +var api = {{{classname}}}.new(config) +# You can also provide your own HTTPClient, to re-use it across apis. +#var api = {{{classname}}}.new(config, client) {{#each bodyParams}} {{#if dataType}} {{#if isModel}} var {{paramName}} = {{dataType}}.new() -# … fill model with data +# … fill model {{paramName}} with data {{/if}} {{/if}} {{/each}} +# Invoke an endpoint api.{{{operationIdSnakeCase}}}( {{#each allParams}} # {{paramName}}{{#if dataType}}: {{dataType}}{{/if}}{{#if defaultValue}} = {{{defaultValue}}}{{/if}}{{#if example}} Eg: {{{example}}}{{/if}} @@ -31,13 +31,12 @@ api.{{{operationIdSnakeCase}}}( {{/each}} # On Success func(result):{{#with returnProperty}} # result is {{>partials/complex_type}}{{/with}} - prints("Success!", result) - pass # do things + prints("Success!", "{{operationIdSnakeCase}}", result) + pass # do things, make stuff , # On Error func(error): # error is {{>partials/api_error_class_name}} - printerr(str(error)) - pass # do things + push_error(str(error)) , ) diff --git a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars index 4927f0ef5a08..1eeb8a0479c0 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/model.handlebars +++ b/modules/openapi-generator/src/main/resources/gdscript/model.handlebars @@ -7,11 +7,6 @@ {{>partials/model_headers}} -# It's convenient to know the class name, for error messages. -# Remove once https://github.com/godotengine/godot/issues/21789 -var bee_class_name := "{{classname}}" - - {{#each vars}} {{#if deprecated}} # /!. DEPRECATED @@ -59,7 +54,7 @@ var __{{name}}__allowable__values := [ {{/each}} -func bee_collect_missing_properties() -> Array: +func bzz_collect_missing_properties() -> Array: var bzz_missing_properties := Array() {{#each vars}} {{#if required}} @@ -70,7 +65,7 @@ func bee_collect_missing_properties() -> Array: return bzz_missing_properties -func bee_normalize() -> Dictionary: +func bzz_normalize() -> Dictionary: var bzz_dictionary := Dictionary() {{#each vars}} if self.__{{name}}__was__set: @@ -81,15 +76,15 @@ func bee_normalize() -> Dictionary: # Won't work for JSON+LD {{!-- LEAKING if we specify return -> {{classname}} in func def --}} -static func bee_denormalize_single(from_dict: Dictionary): +static func bzz_denormalize_single(from_dict: Dictionary): var me := new() {{#each vars}} if from_dict.has("{{name}}"): {{#if isModel}} - me.{{name}} = {{>partials/complex_type}}.bee_denormalize_single(from_dict["{{name}}"]) + me.{{name}} = {{>partials/complex_type}}.bzz_denormalize_single(from_dict["{{name}}"]) {{else if isArray}} {{#if mostInnerItems.isModel}} - me.{{name}} = {{>partials/complex_type}}.bee_denormalize_multiple(from_dict["{{name}}"]) + me.{{name}} = {{>partials/complex_type}}.bzz_denormalize_multiple(from_dict["{{name}}"]) {{else}} me.{{name}} = from_dict["{{name}}"] {{/if}} @@ -102,20 +97,20 @@ static func bee_denormalize_single(from_dict: Dictionary): # Won't work for JSON+LD {{!-- LEAKING if we specify return -> {{classname}} in func def --}} -static func bee_denormalize_multiple(from_array: Array): +static func bzz_denormalize_multiple(from_array: Array): var mes := Array() for element in from_array: if element is Array: - mes.append(bee_denormalize_multiple(element)) + mes.append(bzz_denormalize_multiple(element)) elif element is Dictionary: # TODO: perhaps check first if it looks like a match or an intermediate container - mes.append(bee_denormalize_single(element)) + mes.append(bzz_denormalize_single(element)) else: mes.append(element) return mes {{!-- UNUSED -func bee_normalize_fully() -> Dictionary: +func bzz_normalize_fully() -> Dictionary: return { {{#each vars}} "{{name}}": self.{{name}}, From 95e3d585db19bd6574f6f367b992ecbfd1a1a505 Mon Sep 17 00:00:00 2001 From: Goutte Date: Fri, 14 Apr 2023 14:30:40 +0200 Subject: [PATCH 39/56] fix(gdscript): add missing file --- .../gdscript/partials/api_method_params.handlebars | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 modules/openapi-generator/src/main/resources/gdscript/partials/api_method_params.handlebars diff --git a/modules/openapi-generator/src/main/resources/gdscript/partials/api_method_params.handlebars b/modules/openapi-generator/src/main/resources/gdscript/partials/api_method_params.handlebars new file mode 100644 index 000000000000..3399ff88d094 --- /dev/null +++ b/modules/openapi-generator/src/main/resources/gdscript/partials/api_method_params.handlebars @@ -0,0 +1,7 @@ + {{#each allParams}} + # {{paramName}}{{#if dataType}}: {{dataType}}{{/if}}{{#if defaultValue}} = {{{defaultValue}}}{{/if}}{{#if example}} Eg: {{{example}}}{{/if}} + # {{{description}}} + {{paramName}}{{#if required}}{{#if dataType}}: {{{dataType}}}{{/if}}{{/if}}{{#unless required}} = {{#if defaultValue}}{{{defaultValue}}}{{/if}}{{#unless defaultValue}}null{{/unless}}{{/unless}}, + {{/each}} + on_success: Callable = Callable(), # func(result{{#if returnType}}: {{returnType}}{{/if}}) + on_failure: Callable = Callable(), # func(error: {{>partials/api_error_class_name}}) From 141c119f848536a388387256e759e2956ea98c02 Mon Sep 17 00:00:00 2001 From: Goutte Date: Fri, 14 Apr 2023 17:36:18 +0200 Subject: [PATCH 40/56] test(gdscript): refactor the test project to use the generated lib as addon Since there is no singleton in the generated client, the addon need not be enabled in the project configuration to be usable. The --headless mode is broken for now, as things changed in Godot 4 since the beta. --- bin/configs/gdscript-petstore.yaml | 12 +- samples/client/petstore/gdscript/README.md | 118 +---- .../.openapi-generator-ignore | 0 .../.openapi-generator/FILES | 16 + .../.openapi-generator/VERSION | 1 + .../addons/oas.petstore.client/README.md | 126 +++++ .../oas.petstore.client}/apis/DemoPetApi.gd | 254 +++++++-- .../oas.petstore.client}/apis/DemoPetApi.md | 162 +++--- .../oas.petstore.client}/apis/DemoStoreApi.gd | 111 +++- .../oas.petstore.client}/apis/DemoStoreApi.md | 78 +-- .../oas.petstore.client}/apis/DemoUserApi.gd | 229 +++++++-- .../oas.petstore.client}/apis/DemoUserApi.md | 158 +++--- .../oas.petstore.client/core/DemoApiBee.gd | 482 ++++++++++++++++++ .../oas.petstore.client/core/DemoApiConfig.gd | 142 ++++++ .../oas.petstore.client}/core/DemoApiError.gd | 0 .../models/DemoApiResponse.gd | 32 +- .../models/DemoCategory.gd | 29 +- .../oas.petstore.client}/models/DemoOrder.gd | 45 +- .../oas.petstore.client}/models/DemoPet.gd | 47 +- .../oas.petstore.client}/models/DemoTag.gd | 29 +- .../oas.petstore.client}/models/DemoUser.gd | 47 +- .../petstore/gdscript/core/DemoApiBee.gd | 406 --------------- .../petstore/gdscript/core/DemoApiConfig.gd | 69 --- samples/client/petstore/gdscript/demo/main.gd | 26 +- .../client/petstore/gdscript/demo/main.tscn | 12 - samples/client/petstore/gdscript/icon.svg | 120 ++++- .../client/petstore/gdscript/project.godot | 76 --- 27 files changed, 1723 insertions(+), 1104 deletions(-) rename samples/client/petstore/gdscript/{ => addons/oas.petstore.client}/.openapi-generator-ignore (100%) create mode 100644 samples/client/petstore/gdscript/addons/oas.petstore.client/.openapi-generator/FILES create mode 100644 samples/client/petstore/gdscript/addons/oas.petstore.client/.openapi-generator/VERSION create mode 100644 samples/client/petstore/gdscript/addons/oas.petstore.client/README.md rename samples/client/petstore/gdscript/{ => addons/oas.petstore.client}/apis/DemoPetApi.gd (68%) rename samples/client/petstore/gdscript/{ => addons/oas.petstore.client}/apis/DemoPetApi.md (59%) rename samples/client/petstore/gdscript/{ => addons/oas.petstore.client}/apis/DemoStoreApi.gd (70%) rename samples/client/petstore/gdscript/{ => addons/oas.petstore.client}/apis/DemoStoreApi.md (63%) rename samples/client/petstore/gdscript/{ => addons/oas.petstore.client}/apis/DemoUserApi.gd (69%) rename samples/client/petstore/gdscript/{ => addons/oas.petstore.client}/apis/DemoUserApi.md (60%) create mode 100644 samples/client/petstore/gdscript/addons/oas.petstore.client/core/DemoApiBee.gd create mode 100644 samples/client/petstore/gdscript/addons/oas.petstore.client/core/DemoApiConfig.gd rename samples/client/petstore/gdscript/{ => addons/oas.petstore.client}/core/DemoApiError.gd (100%) rename samples/client/petstore/gdscript/{ => addons/oas.petstore.client}/models/DemoApiResponse.gd (72%) rename samples/client/petstore/gdscript/{ => addons/oas.petstore.client}/models/DemoCategory.gd (68%) rename samples/client/petstore/gdscript/{ => addons/oas.petstore.client}/models/DemoOrder.gd (74%) rename samples/client/petstore/gdscript/{ => addons/oas.petstore.client}/models/DemoPet.gd (75%) rename samples/client/petstore/gdscript/{ => addons/oas.petstore.client}/models/DemoTag.gd (68%) rename samples/client/petstore/gdscript/{ => addons/oas.petstore.client}/models/DemoUser.gd (79%) delete mode 100644 samples/client/petstore/gdscript/core/DemoApiBee.gd delete mode 100644 samples/client/petstore/gdscript/core/DemoApiConfig.gd diff --git a/bin/configs/gdscript-petstore.yaml b/bin/configs/gdscript-petstore.yaml index 3dbcc21cfb91..02f3aa82940e 100644 --- a/bin/configs/gdscript-petstore.yaml +++ b/bin/configs/gdscript-petstore.yaml @@ -1,5 +1,15 @@ +# Run this configuration to update the sample project used in integration testing: +# bin/generate-samples.sh bin/configs/gdscript-petstore.yaml + generatorName: gdscript -outputDir: samples/client/petstore/gdscript +outputDir: samples/client/petstore/gdscript/addons/oas.petstore.client +# We have two test servers available. +# See https://github.com/OpenAPITools/openapi-generator/wiki/Integration-Tests +# A: Newer, recommended echo server OAS, that we're failing for now: +# Exception: Could not process model 'Bird'. Please make sure that your schema is correct! +# Caused by: java.lang.RuntimeException: reserved word color not allowed +#inputSpec: modules/openapi-generator/src/test/resources/3_0/echo_api.yaml +# B: Older (legacy, deprecated) petstore server OAS inputSpec: modules/openapi-generator/src/test/resources/3_0/petstore.yaml templateDir: modules/openapi-generator/src/main/resources/gdscript additionalProperties: diff --git a/samples/client/petstore/gdscript/README.md b/samples/client/petstore/gdscript/README.md index 04819f0d3c11..9adaba961af3 100644 --- a/samples/client/petstore/gdscript/README.md +++ b/samples/client/petstore/gdscript/README.md @@ -1,114 +1,22 @@ -# OpenAPI Petstore GDScript Client +# Petstore GDScript Testing Client -This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters. +## What -This Godot 4 addon is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: +- [Godot] `4.x` project +- Made for `--headless` mode +- Returns non-zero exit code upon test failure +- Uses [GUT] as test engine -− Servers: - - [http://petstore.swagger.io/v2](http://petstore.swagger.io/v2) -- API version: 1.0.0 -- Build package: org.openapitools.codegen.languages.GdscriptClientCodegen +## Run + godot --headless samples/client/petstore/gdscript -## Requirements. +## Update -Godot `4.x`. +Refresh the generated files, after modifying the gdscript templates or java generator: + bin/generate-samples.sh bin/configs/gdscript-petstore.yaml -## Installation & Usage - -Copy the files into the `addon` directory of your Godot project. - -Then, enable the addon in your project settings. - -You can now use it anywhere in your code: - -```gdscript - -# Customize configuration, if needed -var config := DemoApiConfig.new() -config.host = "localhost" -config.port = 8080 - -var api = DemoPetApi.new() -api.config = config # optionally - -var demoPet = DemoPet.new() -# … fill model with data - -api.add_pet( - # demoPet: DemoPet - # Pet object that needs to be added to the store - demoPet, - # On Success - func(result): # result is DemoPet - prints("Success!", result) - pass # do things - , - # On Error - func(error): # error is DemoApiError - printerr(str(error)) - pass # do things - , -) - -``` - - -## Documentation for API Endpoints - -All URIs are relative to *http://petstore.swagger.io/v2* - -Class | Method | HTTP request | Description ------------- | ------------- | ------------- | ------------- -*DemoPetApi* | [**add_pet**](apis/DemoPetApi.md#add_pet) | **POST** /pet | Add a new pet to the store -*DemoPetApi* | [**delete_pet**](apis/DemoPetApi.md#delete_pet) | **DELETE** /pet/{petId} | Deletes a pet -*DemoPetApi* | [**find_pets_by_status**](apis/DemoPetApi.md#find_pets_by_status) | **GET** /pet/findByStatus | Finds Pets by status -*DemoPetApi* | [**find_pets_by_tags**](apis/DemoPetApi.md#find_pets_by_tags) | **GET** /pet/findByTags | Finds Pets by tags -*DemoPetApi* | [**get_pet_by_id**](apis/DemoPetApi.md#get_pet_by_id) | **GET** /pet/{petId} | Find pet by ID -*DemoPetApi* | [**update_pet**](apis/DemoPetApi.md#update_pet) | **PUT** /pet | Update an existing pet -*DemoPetApi* | [**update_pet_with_form**](apis/DemoPetApi.md#update_pet_with_form) | **POST** /pet/{petId} | Updates a pet in the store with form data -*DemoPetApi* | [**upload_file**](apis/DemoPetApi.md#upload_file) | **POST** /pet/{petId}/uploadImage | uploads an image -*DemoStoreApi* | [**delete_order**](apis/DemoStoreApi.md#delete_order) | **DELETE** /store/order/{orderId} | Delete purchase order by ID -*DemoStoreApi* | [**get_inventory**](apis/DemoStoreApi.md#get_inventory) | **GET** /store/inventory | Returns pet inventories by status -*DemoStoreApi* | [**get_order_by_id**](apis/DemoStoreApi.md#get_order_by_id) | **GET** /store/order/{orderId} | Find purchase order by ID -*DemoStoreApi* | [**place_order**](apis/DemoStoreApi.md#place_order) | **POST** /store/order | Place an order for a pet -*DemoUserApi* | [**create_user**](apis/DemoUserApi.md#create_user) | **POST** /user | Create user -*DemoUserApi* | [**create_users_with_array_input**](apis/DemoUserApi.md#create_users_with_array_input) | **POST** /user/createWithArray | Creates list of users with given input array -*DemoUserApi* | [**create_users_with_list_input**](apis/DemoUserApi.md#create_users_with_list_input) | **POST** /user/createWithList | Creates list of users with given input array -*DemoUserApi* | [**delete_user**](apis/DemoUserApi.md#delete_user) | **DELETE** /user/{username} | Delete user -*DemoUserApi* | [**get_user_by_name**](apis/DemoUserApi.md#get_user_by_name) | **GET** /user/{username} | Get user by user name -*DemoUserApi* | [**login_user**](apis/DemoUserApi.md#login_user) | **GET** /user/login | Logs user into the system -*DemoUserApi* | [**logout_user**](apis/DemoUserApi.md#logout_user) | **GET** /user/logout | Logs out current logged in user session -*DemoUserApi* | [**update_user**](apis/DemoUserApi.md#update_user) | **PUT** /user/{username} | Updated user - - -## Documentation For Models - -- [DemoApiResponse](models/DemoApiResponse.md) -- [DemoCategory](models/DemoCategory.md) -- [DemoOrder](models/DemoOrder.md) -- [DemoPet](models/DemoPet.md) -- [DemoTag](models/DemoTag.md) -- [DemoUser](models/DemoUser.md) - - -## Documentation For Authorization - - -## api_key - -- **Type**: API key -- **API key parameter name**: api_key -- **Location**: HTTP header - - Authentication schemes defined for the API: -## petstore_auth - -- **Type**: OAuth -- **Flow**: implicit -- **Authorization URL**: http://petstore.swagger.io/api/oauth/dialog -- **Scopes**: - - **write:pets**: modify pets in your account - - **read:pets**: read your pets +[Godot]: https://godotengine.org +[GUT]: https://github.com/bitwes/Gut diff --git a/samples/client/petstore/gdscript/.openapi-generator-ignore b/samples/client/petstore/gdscript/addons/oas.petstore.client/.openapi-generator-ignore similarity index 100% rename from samples/client/petstore/gdscript/.openapi-generator-ignore rename to samples/client/petstore/gdscript/addons/oas.petstore.client/.openapi-generator-ignore diff --git a/samples/client/petstore/gdscript/addons/oas.petstore.client/.openapi-generator/FILES b/samples/client/petstore/gdscript/addons/oas.petstore.client/.openapi-generator/FILES new file mode 100644 index 000000000000..d00050b7e846 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/oas.petstore.client/.openapi-generator/FILES @@ -0,0 +1,16 @@ +README.md +apis/DemoPetApi.gd +apis/DemoPetApi.md +apis/DemoStoreApi.gd +apis/DemoStoreApi.md +apis/DemoUserApi.gd +apis/DemoUserApi.md +core/DemoApiBee.gd +core/DemoApiConfig.gd +core/DemoApiError.gd +models/DemoApiResponse.gd +models/DemoCategory.gd +models/DemoOrder.gd +models/DemoPet.gd +models/DemoTag.gd +models/DemoUser.gd diff --git a/samples/client/petstore/gdscript/addons/oas.petstore.client/.openapi-generator/VERSION b/samples/client/petstore/gdscript/addons/oas.petstore.client/.openapi-generator/VERSION new file mode 100644 index 000000000000..ed829dbcddec --- /dev/null +++ b/samples/client/petstore/gdscript/addons/oas.petstore.client/.openapi-generator/VERSION @@ -0,0 +1 @@ +6.2.1-SNAPSHOT \ No newline at end of file diff --git a/samples/client/petstore/gdscript/addons/oas.petstore.client/README.md b/samples/client/petstore/gdscript/addons/oas.petstore.client/README.md new file mode 100644 index 000000000000..9c453fc19bfa --- /dev/null +++ b/samples/client/petstore/gdscript/addons/oas.petstore.client/README.md @@ -0,0 +1,126 @@ +# OpenAPI Petstore GDScript Client + +This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters. + +This Godot 4 addon was automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: + +− Servers: + - [http://petstore.swagger.io/v2](http://petstore.swagger.io/v2) +- API version: 1.0.0 +- Build package: org.openapitools.codegen.languages.GdscriptClientCodegen + + +## Requirements. + +Godot `4.x`. + + +## Installation & Usage + +Copy the files into the `addon` directory of your Godot project. + +Then, enable the addon in your project settings. + +You can now use it anywhere in your code: + +```gdscript + +# Customize configuration +var config := DemoApiConfig.new() +config.host = "localhost" +config.port = 8080 +#config.tls_enabled = true +#config.trusted_chain = preload("res://my_cert_chain.crt") + +# Instantiate the api +var api = DemoPetApi.new(config) +# You can also provide your own HTTPClient, to re-use it across apis. +#var api = DemoPetApi.new(config, client) + +var demoPet = DemoPet.new() +# … fill model demoPet with data + +# Invoke an endpoint +api.add_pet( + # demoPet: DemoPet + # Pet object that needs to be added to the store + demoPet, + # On Success + func(result): # result is DemoPet + prints("Success!", "add_pet", result) + pass # do things, make stuff + , + # On Error + func(error): # error is DemoApiError + push_error(str(error)) + , +) + +``` + + +## Documentation for API Endpoints + +All URIs are relative to *http://petstore.swagger.io/v2* + +Class | Method | HTTP request | Description +------------ | ------------- | ------------- | ------------- +*DemoPetApi* | [**add_pet**](apis/DemoPetApi.md#add_pet) | **POST** /pet | Add a new pet to the store +*DemoPetApi* | [**delete_pet**](apis/DemoPetApi.md#delete_pet) | **DELETE** /pet/{petId} | Deletes a pet +*DemoPetApi* | [**find_pets_by_status**](apis/DemoPetApi.md#find_pets_by_status) | **GET** /pet/findByStatus | Finds Pets by status +*DemoPetApi* | [**find_pets_by_tags**](apis/DemoPetApi.md#find_pets_by_tags) | **GET** /pet/findByTags | Finds Pets by tags +*DemoPetApi* | [**get_pet_by_id**](apis/DemoPetApi.md#get_pet_by_id) | **GET** /pet/{petId} | Find pet by ID +*DemoPetApi* | [**update_pet**](apis/DemoPetApi.md#update_pet) | **PUT** /pet | Update an existing pet +*DemoPetApi* | [**update_pet_with_form**](apis/DemoPetApi.md#update_pet_with_form) | **POST** /pet/{petId} | Updates a pet in the store with form data +*DemoPetApi* | [**upload_file**](apis/DemoPetApi.md#upload_file) | **POST** /pet/{petId}/uploadImage | uploads an image +*DemoStoreApi* | [**delete_order**](apis/DemoStoreApi.md#delete_order) | **DELETE** /store/order/{orderId} | Delete purchase order by ID +*DemoStoreApi* | [**get_inventory**](apis/DemoStoreApi.md#get_inventory) | **GET** /store/inventory | Returns pet inventories by status +*DemoStoreApi* | [**get_order_by_id**](apis/DemoStoreApi.md#get_order_by_id) | **GET** /store/order/{orderId} | Find purchase order by ID +*DemoStoreApi* | [**place_order**](apis/DemoStoreApi.md#place_order) | **POST** /store/order | Place an order for a pet +*DemoUserApi* | [**create_user**](apis/DemoUserApi.md#create_user) | **POST** /user | Create user +*DemoUserApi* | [**create_users_with_array_input**](apis/DemoUserApi.md#create_users_with_array_input) | **POST** /user/createWithArray | Creates list of users with given input array +*DemoUserApi* | [**create_users_with_list_input**](apis/DemoUserApi.md#create_users_with_list_input) | **POST** /user/createWithList | Creates list of users with given input array +*DemoUserApi* | [**delete_user**](apis/DemoUserApi.md#delete_user) | **DELETE** /user/{username} | Delete user +*DemoUserApi* | [**get_user_by_name**](apis/DemoUserApi.md#get_user_by_name) | **GET** /user/{username} | Get user by user name +*DemoUserApi* | [**login_user**](apis/DemoUserApi.md#login_user) | **GET** /user/login | Logs user into the system +*DemoUserApi* | [**logout_user**](apis/DemoUserApi.md#logout_user) | **GET** /user/logout | Logs out current logged in user session +*DemoUserApi* | [**update_user**](apis/DemoUserApi.md#update_user) | **PUT** /user/{username} | Updated user + + +## Documentation For Models + +- [DemoApiResponse](models/DemoApiResponse.md) +- [DemoCategory](models/DemoCategory.md) +- [DemoOrder](models/DemoOrder.md) +- [DemoPet](models/DemoPet.md) +- [DemoTag](models/DemoTag.md) +- [DemoUser](models/DemoUser.md) + + +## Documentation For Authorization + + +## api_key + +- **Type**: API key +- **API key parameter name**: api_key +- **Location**: HTTP header + + Authentication schemes defined for the API: +## petstore_auth + +- **Type**: OAuth +- **Flow**: implicit +- **Authorization URL**: http://petstore.swagger.io/api/oauth/dialog +- **Scopes**: + - **write:pets**: modify pets in your account + - **read:pets**: read your pets + + + +## Troubleshooting + +### `TLS handshake error: -9984` + +https://github.com/godotengine/godot/issues/59080#issuecomment-1065973210 + diff --git a/samples/client/petstore/gdscript/apis/DemoPetApi.gd b/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoPetApi.gd similarity index 68% rename from samples/client/petstore/gdscript/apis/DemoPetApi.gd rename to samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoPetApi.gd index c0dc44fe365b..80b6bdcb71a1 100644 --- a/samples/client/petstore/gdscript/apis/DemoPetApi.gd +++ b/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoPetApi.gd @@ -1,11 +1,17 @@ +extends DemoApiBee +class_name DemoPetApi + # THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. # For more information on how to customize templates, see: # https://openapi-generator.tech # The OpenAPI Generator Community, © Public Domain, 2022 + # API DemoPetApi +# Instantiate this object and use it to make requests to the API. + +func _bzz_get_api_name() -> String: + return "DemoPetApi" -extends DemoApiBee -class_name DemoPetApi # Operation addPet → POST /pet # Add a new pet to the store @@ -16,10 +22,9 @@ func add_pet( on_success: Callable = Callable(), # func(result: Pet) on_failure: Callable = Callable(), # func(error: DemoApiError) ): - # CollectionFormat: NO # Convert the String HTTP method to a Constant Godot understands - var bzz_method := self.bee_convert_http_method("POST") + var bzz_method := self._bzz_convert_http_method("POST") # Compute the URL path to the API resource var bzz_path := "/v2/pet" @@ -34,7 +39,6 @@ func add_pet( bzz_found_producible_mime = true break if not bzz_found_producible_mime: - # This is a bit strict, perhaps we could just push a warning and send JSON anyway? var error := DemoApiError.new() error.identifier = "add_pet.headers.content_type" error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." @@ -53,10 +57,10 @@ func add_pet( var bzz_body = null bzz_body = demoPet - self.bee_request( + self.bzz_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - bzz_result = DemoPet.bee_denormalize_single(bzz_result) + bzz_result = DemoPet.bzz_denormalize_single(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): @@ -64,25 +68,42 @@ func add_pet( , # ざわ‥ ) + +func add_pet_threaded( + # demoPet: DemoPet + # Pet object that needs to be added to the store + demoPet: DemoPet, + on_success: Callable = Callable(), # func(result: Pet) + on_failure: Callable = Callable(), # func(error: DemoApiError) +) -> Thread: + var bzz_thread := Thread.new() + var bzz_callable := Callable(self, "add_pet") + bzz_callable.bind( + demoPet, + on_success, + on_failure, + ) + bzz_thread.start(bzz_callable) + return bzz_thread + # Operation deletePet → DELETE /pet/{petId} # Deletes a pet func delete_pet( # petId: float Eg: 789 # Pet id to delete petId: float, - # apiKey: String Eg: apiKey_example + # apiKey: String = "" Eg: apiKey_example # - apiKey = null, + apiKey = "", on_success: Callable = Callable(), # func(result) on_failure: Callable = Callable(), # func(error: DemoApiError) ): - # CollectionFormat: NO # Convert the String HTTP method to a Constant Godot understands - var bzz_method := self.bee_convert_http_method("DELETE") + var bzz_method := self._bzz_convert_http_method("DELETE") # Compute the URL path to the API resource - var bzz_path := "/v2/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + var bzz_path := "/v2/pet/{petId}".replace("{" + "petId" + "}", _bzz_urlize_path_param(petId)) # Collect the headers var bzz_headers := Dictionary() @@ -94,7 +115,7 @@ func delete_pet( var bzz_body = null - self.bee_request( + self.bzz_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): on_success.call(bzz_result) @@ -104,6 +125,28 @@ func delete_pet( , # ざわ‥ ) + +func delete_pet_threaded( + # petId: float Eg: 789 + # Pet id to delete + petId: float, + # apiKey: String = "" Eg: apiKey_example + # + apiKey = "", + on_success: Callable = Callable(), # func(result) + on_failure: Callable = Callable(), # func(error: DemoApiError) +) -> Thread: + var bzz_thread := Thread.new() + var bzz_callable := Callable(self, "delete_pet") + bzz_callable.bind( + petId, + apiKey, + on_success, + on_failure, + ) + bzz_thread.start(bzz_callable) + return bzz_thread + # Operation findPetsByStatus → GET /pet/findByStatus # Finds Pets by status # @@ -115,10 +158,9 @@ func find_pets_by_status( on_success: Callable = Callable(), # func(result: Array) on_failure: Callable = Callable(), # func(error: DemoApiError) ): - # CollectionFormat: NO # Convert the String HTTP method to a Constant Godot understands - var bzz_method := self.bee_convert_http_method("GET") + var bzz_method := self._bzz_convert_http_method("GET") # Compute the URL path to the API resource var bzz_path := "/v2/pet/findByStatus" @@ -138,10 +180,10 @@ func find_pets_by_status( var bzz_body = null - self.bee_request( + self.bzz_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - bzz_result = DemoPet.bee_denormalize_multiple(bzz_result) + bzz_result = DemoPet.bzz_denormalize_multiple(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): @@ -149,6 +191,24 @@ func find_pets_by_status( , # ざわ‥ ) + +func find_pets_by_status_threaded( + # status: Array + # Status values that need to be considered for filter + status: Array, + on_success: Callable = Callable(), # func(result: Array) + on_failure: Callable = Callable(), # func(error: DemoApiError) +) -> Thread: + var bzz_thread := Thread.new() + var bzz_callable := Callable(self, "find_pets_by_status") + bzz_callable.bind( + status, + on_success, + on_failure, + ) + bzz_thread.start(bzz_callable) + return bzz_thread + # /!. DEPRECATED # Operation findPetsByTags → GET /pet/findByTags # Finds Pets by tags @@ -161,11 +221,10 @@ func find_pets_by_tags( on_success: Callable = Callable(), # func(result: Array) on_failure: Callable = Callable(), # func(error: DemoApiError) ): - # CollectionFormat: NO push_warning("Usage of `find_pets_by_tags()` is deprecated.") # Convert the String HTTP method to a Constant Godot understands - var bzz_method := self.bee_convert_http_method("GET") + var bzz_method := self._bzz_convert_http_method("GET") # Compute the URL path to the API resource var bzz_path := "/v2/pet/findByTags" @@ -185,10 +244,10 @@ func find_pets_by_tags( var bzz_body = null - self.bee_request( + self.bzz_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - bzz_result = DemoPet.bee_denormalize_multiple(bzz_result) + bzz_result = DemoPet.bzz_denormalize_multiple(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): @@ -196,6 +255,24 @@ func find_pets_by_tags( , # ざわ‥ ) + +func find_pets_by_tags_threaded( + # tags: Array + # Tags to filter by + tags: Array, + on_success: Callable = Callable(), # func(result: Array) + on_failure: Callable = Callable(), # func(error: DemoApiError) +) -> Thread: + var bzz_thread := Thread.new() + var bzz_callable := Callable(self, "find_pets_by_tags") + bzz_callable.bind( + tags, + on_success, + on_failure, + ) + bzz_thread.start(bzz_callable) + return bzz_thread + # Operation getPetById → GET /pet/{petId} # Find pet by ID # @@ -207,13 +284,12 @@ func get_pet_by_id( on_success: Callable = Callable(), # func(result: Pet) on_failure: Callable = Callable(), # func(error: DemoApiError) ): - # CollectionFormat: NO # Convert the String HTTP method to a Constant Godot understands - var bzz_method := self.bee_convert_http_method("GET") + var bzz_method := self._bzz_convert_http_method("GET") # Compute the URL path to the API resource - var bzz_path := "/v2/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + var bzz_path := "/v2/pet/{petId}".replace("{" + "petId" + "}", _bzz_urlize_path_param(petId)) # Collect the headers var bzz_headers := Dictionary() @@ -229,10 +305,10 @@ func get_pet_by_id( var bzz_body = null - self.bee_request( + self.bzz_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - bzz_result = DemoPet.bee_denormalize_single(bzz_result) + bzz_result = DemoPet.bzz_denormalize_single(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): @@ -240,6 +316,24 @@ func get_pet_by_id( , # ざわ‥ ) + +func get_pet_by_id_threaded( + # petId: float Eg: 789 + # ID of pet to return + petId: float, + on_success: Callable = Callable(), # func(result: Pet) + on_failure: Callable = Callable(), # func(error: DemoApiError) +) -> Thread: + var bzz_thread := Thread.new() + var bzz_callable := Callable(self, "get_pet_by_id") + bzz_callable.bind( + petId, + on_success, + on_failure, + ) + bzz_thread.start(bzz_callable) + return bzz_thread + # Operation updatePet → PUT /pet # Update an existing pet func update_pet( @@ -249,10 +343,9 @@ func update_pet( on_success: Callable = Callable(), # func(result: Pet) on_failure: Callable = Callable(), # func(error: DemoApiError) ): - # CollectionFormat: NO # Convert the String HTTP method to a Constant Godot understands - var bzz_method := self.bee_convert_http_method("PUT") + var bzz_method := self._bzz_convert_http_method("PUT") # Compute the URL path to the API resource var bzz_path := "/v2/pet" @@ -267,7 +360,6 @@ func update_pet( bzz_found_producible_mime = true break if not bzz_found_producible_mime: - # This is a bit strict, perhaps we could just push a warning and send JSON anyway? var error := DemoApiError.new() error.identifier = "update_pet.headers.content_type" error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." @@ -286,10 +378,10 @@ func update_pet( var bzz_body = null bzz_body = demoPet - self.bee_request( + self.bzz_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - bzz_result = DemoPet.bee_denormalize_single(bzz_result) + bzz_result = DemoPet.bzz_denormalize_single(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): @@ -297,28 +389,45 @@ func update_pet( , # ざわ‥ ) + +func update_pet_threaded( + # demoPet: DemoPet + # Pet object that needs to be added to the store + demoPet: DemoPet, + on_success: Callable = Callable(), # func(result: Pet) + on_failure: Callable = Callable(), # func(error: DemoApiError) +) -> Thread: + var bzz_thread := Thread.new() + var bzz_callable := Callable(self, "update_pet") + bzz_callable.bind( + demoPet, + on_success, + on_failure, + ) + bzz_thread.start(bzz_callable) + return bzz_thread + # Operation updatePetWithForm → POST /pet/{petId} # Updates a pet in the store with form data func update_pet_with_form( # petId: float Eg: 789 # ID of pet that needs to be updated petId: float, - # name: String Eg: name_example + # name: String = "" Eg: name_example # Updated name of the pet - name = null, - # status: String Eg: status_example + name = "", + # status: String = "" Eg: status_example # Updated status of the pet - status = null, + status = "", on_success: Callable = Callable(), # func(result) on_failure: Callable = Callable(), # func(error: DemoApiError) ): - # CollectionFormat: NO # Convert the String HTTP method to a Constant Godot understands - var bzz_method := self.bee_convert_http_method("POST") + var bzz_method := self._bzz_convert_http_method("POST") # Compute the URL path to the API resource - var bzz_path := "/v2/pet/{petId}".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + var bzz_path := "/v2/pet/{petId}".replace("{" + "petId" + "}", _bzz_urlize_path_param(petId)) # Collect the headers var bzz_headers := Dictionary() @@ -330,7 +439,6 @@ func update_pet_with_form( bzz_found_producible_mime = true break if not bzz_found_producible_mime: - # This is a bit strict, perhaps we could just push a warning and send JSON anyway? var error := DemoApiError.new() error.identifier = "update_pet_with_form.headers.content_type" error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." @@ -346,7 +454,7 @@ func update_pet_with_form( bzz_body["name"] = name bzz_body["status"] = status - self.bee_request( + self.bzz_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): on_success.call(bzz_result) @@ -356,28 +464,53 @@ func update_pet_with_form( , # ざわ‥ ) + +func update_pet_with_form_threaded( + # petId: float Eg: 789 + # ID of pet that needs to be updated + petId: float, + # name: String = "" Eg: name_example + # Updated name of the pet + name = "", + # status: String = "" Eg: status_example + # Updated status of the pet + status = "", + on_success: Callable = Callable(), # func(result) + on_failure: Callable = Callable(), # func(error: DemoApiError) +) -> Thread: + var bzz_thread := Thread.new() + var bzz_callable := Callable(self, "update_pet_with_form") + bzz_callable.bind( + petId, + name, + status, + on_success, + on_failure, + ) + bzz_thread.start(bzz_callable) + return bzz_thread + # Operation uploadFile → POST /pet/{petId}/uploadImage # uploads an image func upload_file( # petId: float Eg: 789 # ID of pet to update petId: float, - # additionalMetadata: String Eg: additionalMetadata_example + # additionalMetadata: String = "" Eg: additionalMetadata_example # Additional data to pass to server - additionalMetadata = null, + additionalMetadata = "", # file: String Eg: BINARY_DATA_HERE # file to upload file = null, on_success: Callable = Callable(), # func(result: ApiResponse) on_failure: Callable = Callable(), # func(error: DemoApiError) ): - # CollectionFormat: NO # Convert the String HTTP method to a Constant Godot understands - var bzz_method := self.bee_convert_http_method("POST") + var bzz_method := self._bzz_convert_http_method("POST") # Compute the URL path to the API resource - var bzz_path := "/v2/pet/{petId}/uploadImage".replace("{" + "petId" + "}", bee_urlize_path_param(petId)) + var bzz_path := "/v2/pet/{petId}/uploadImage".replace("{" + "petId" + "}", _bzz_urlize_path_param(petId)) # Collect the headers var bzz_headers := Dictionary() @@ -389,7 +522,6 @@ func upload_file( bzz_found_producible_mime = true break if not bzz_found_producible_mime: - # This is a bit strict, perhaps we could just push a warning and send JSON anyway? var error := DemoApiError.new() error.identifier = "upload_file.headers.content_type" error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." @@ -410,10 +542,10 @@ func upload_file( bzz_body["additionalMetadata"] = additionalMetadata bzz_body["file"] = file - self.bee_request( + self.bzz_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - bzz_result = DemoApiResponse.bee_denormalize_single(bzz_result) + bzz_result = DemoApiResponse.bzz_denormalize_single(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): @@ -421,3 +553,29 @@ func upload_file( , # ざわ‥ ) + +func upload_file_threaded( + # petId: float Eg: 789 + # ID of pet to update + petId: float, + # additionalMetadata: String = "" Eg: additionalMetadata_example + # Additional data to pass to server + additionalMetadata = "", + # file: String Eg: BINARY_DATA_HERE + # file to upload + file = null, + on_success: Callable = Callable(), # func(result: ApiResponse) + on_failure: Callable = Callable(), # func(error: DemoApiError) +) -> Thread: + var bzz_thread := Thread.new() + var bzz_callable := Callable(self, "upload_file") + bzz_callable.bind( + petId, + additionalMetadata, + file, + on_success, + on_failure, + ) + bzz_thread.start(bzz_callable) + return bzz_thread + diff --git a/samples/client/petstore/gdscript/apis/DemoPetApi.md b/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoPetApi.md similarity index 59% rename from samples/client/petstore/gdscript/apis/DemoPetApi.md rename to samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoPetApi.md index 57602c757c2d..521184b9603a 100644 --- a/samples/client/petstore/gdscript/apis/DemoPetApi.md +++ b/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoPetApi.md @@ -30,30 +30,34 @@ Add a new pet to the store ```gdscript -# Customize configuration, if needed +# Customize configuration var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 +#config.tls_enabled = true +#config.trusted_chain = preload("res://my_cert_chain.crt") -var api = DemoPetApi.new() -api.config = config # optionally +# Instantiate the api +var api = DemoPetApi.new(config) +# You can also provide your own HTTPClient, to re-use it across apis. +#var api = DemoPetApi.new(config, client) var demoPet = DemoPet.new() -# … fill model with data +# … fill model demoPet with data +# Invoke an endpoint api.add_pet( # demoPet: DemoPet # Pet object that needs to be added to the store demoPet, # On Success func(result): # result is DemoPet - prints("Success!", result) - pass # do things + prints("Success!", "add_pet", result) + pass # do things, make stuff , # On Error func(error): # error is DemoApiError - printerr(str(error)) - pass # do things + push_error(str(error)) , ) @@ -62,7 +66,7 @@ api.add_pet( # **delete_pet** { #delete_pet } -> `delete_pet(petId: float,apiKey = null, on_success: Callable, on_failure: Callable)` +> `delete_pet(petId: float,apiKey = "", on_success: Callable, on_failure: Callable)` Deletes a pet @@ -74,31 +78,35 @@ Deletes a pet ```gdscript -# Customize configuration, if needed +# Customize configuration var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 +#config.tls_enabled = true +#config.trusted_chain = preload("res://my_cert_chain.crt") -var api = DemoPetApi.new() -api.config = config # optionally +# Instantiate the api +var api = DemoPetApi.new(config) +# You can also provide your own HTTPClient, to re-use it across apis. +#var api = DemoPetApi.new(config, client) +# Invoke an endpoint api.delete_pet( # petId: float Eg: 789 # Pet id to delete petId, - # apiKey: String Eg: apiKey_example + # apiKey: String = "" Eg: apiKey_example # apiKey, # On Success func(result): - prints("Success!", result) - pass # do things + prints("Success!", "delete_pet", result) + pass # do things, make stuff , # On Error func(error): # error is DemoApiError - printerr(str(error)) - pass # do things + push_error(str(error)) , ) @@ -119,28 +127,32 @@ Multiple status values can be provided with comma separated strings ```gdscript -# Customize configuration, if needed +# Customize configuration var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 +#config.tls_enabled = true +#config.trusted_chain = preload("res://my_cert_chain.crt") -var api = DemoPetApi.new() -api.config = config # optionally +# Instantiate the api +var api = DemoPetApi.new(config) +# You can also provide your own HTTPClient, to re-use it across apis. +#var api = DemoPetApi.new(config, client) +# Invoke an endpoint api.find_pets_by_status( # status: Array # Status values that need to be considered for filter status, # On Success func(result): # result is DemoPet - prints("Success!", result) - pass # do things + prints("Success!", "find_pets_by_status", result) + pass # do things, make stuff , # On Error func(error): # error is DemoApiError - printerr(str(error)) - pass # do things + push_error(str(error)) , ) @@ -161,28 +173,32 @@ Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 ```gdscript -# Customize configuration, if needed +# Customize configuration var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 +#config.tls_enabled = true +#config.trusted_chain = preload("res://my_cert_chain.crt") -var api = DemoPetApi.new() -api.config = config # optionally +# Instantiate the api +var api = DemoPetApi.new(config) +# You can also provide your own HTTPClient, to re-use it across apis. +#var api = DemoPetApi.new(config, client) +# Invoke an endpoint api.find_pets_by_tags( # tags: Array # Tags to filter by tags, # On Success func(result): # result is DemoPet - prints("Success!", result) - pass # do things + prints("Success!", "find_pets_by_tags", result) + pass # do things, make stuff , # On Error func(error): # error is DemoApiError - printerr(str(error)) - pass # do things + push_error(str(error)) , ) @@ -203,28 +219,32 @@ Returns a single pet ```gdscript -# Customize configuration, if needed +# Customize configuration var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 +#config.tls_enabled = true +#config.trusted_chain = preload("res://my_cert_chain.crt") -var api = DemoPetApi.new() -api.config = config # optionally +# Instantiate the api +var api = DemoPetApi.new(config) +# You can also provide your own HTTPClient, to re-use it across apis. +#var api = DemoPetApi.new(config, client) +# Invoke an endpoint api.get_pet_by_id( # petId: float Eg: 789 # ID of pet to return petId, # On Success func(result): # result is DemoPet - prints("Success!", result) - pass # do things + prints("Success!", "get_pet_by_id", result) + pass # do things, make stuff , # On Error func(error): # error is DemoApiError - printerr(str(error)) - pass # do things + push_error(str(error)) , ) @@ -245,30 +265,34 @@ Update an existing pet ```gdscript -# Customize configuration, if needed +# Customize configuration var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 +#config.tls_enabled = true +#config.trusted_chain = preload("res://my_cert_chain.crt") -var api = DemoPetApi.new() -api.config = config # optionally +# Instantiate the api +var api = DemoPetApi.new(config) +# You can also provide your own HTTPClient, to re-use it across apis. +#var api = DemoPetApi.new(config, client) var demoPet = DemoPet.new() -# … fill model with data +# … fill model demoPet with data +# Invoke an endpoint api.update_pet( # demoPet: DemoPet # Pet object that needs to be added to the store demoPet, # On Success func(result): # result is DemoPet - prints("Success!", result) - pass # do things + prints("Success!", "update_pet", result) + pass # do things, make stuff , # On Error func(error): # error is DemoApiError - printerr(str(error)) - pass # do things + push_error(str(error)) , ) @@ -277,7 +301,7 @@ api.update_pet( # **update_pet_with_form** { #update_pet_with_form } -> `update_pet_with_form(petId: float,name = null,status = null, on_success: Callable, on_failure: Callable)` +> `update_pet_with_form(petId: float,name = "",status = "", on_success: Callable, on_failure: Callable)` Updates a pet in the store with form data @@ -289,34 +313,38 @@ Updates a pet in the store with form data ```gdscript -# Customize configuration, if needed +# Customize configuration var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 +#config.tls_enabled = true +#config.trusted_chain = preload("res://my_cert_chain.crt") -var api = DemoPetApi.new() -api.config = config # optionally +# Instantiate the api +var api = DemoPetApi.new(config) +# You can also provide your own HTTPClient, to re-use it across apis. +#var api = DemoPetApi.new(config, client) +# Invoke an endpoint api.update_pet_with_form( # petId: float Eg: 789 # ID of pet that needs to be updated petId, - # name: String Eg: name_example + # name: String = "" Eg: name_example # Updated name of the pet name, - # status: String Eg: status_example + # status: String = "" Eg: status_example # Updated status of the pet status, # On Success func(result): - prints("Success!", result) - pass # do things + prints("Success!", "update_pet_with_form", result) + pass # do things, make stuff , # On Error func(error): # error is DemoApiError - printerr(str(error)) - pass # do things + push_error(str(error)) , ) @@ -325,7 +353,7 @@ api.update_pet_with_form( # **upload_file** { #upload_file } -> `upload_file(petId: float,additionalMetadata = null,file = null, on_success: Callable, on_failure: Callable)` +> `upload_file(petId: float,additionalMetadata = "",file = null, on_success: Callable, on_failure: Callable)` uploads an image @@ -337,20 +365,25 @@ uploads an image ```gdscript -# Customize configuration, if needed +# Customize configuration var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 +#config.tls_enabled = true +#config.trusted_chain = preload("res://my_cert_chain.crt") -var api = DemoPetApi.new() -api.config = config # optionally +# Instantiate the api +var api = DemoPetApi.new(config) +# You can also provide your own HTTPClient, to re-use it across apis. +#var api = DemoPetApi.new(config, client) +# Invoke an endpoint api.upload_file( # petId: float Eg: 789 # ID of pet to update petId, - # additionalMetadata: String Eg: additionalMetadata_example + # additionalMetadata: String = "" Eg: additionalMetadata_example # Additional data to pass to server additionalMetadata, # file: String Eg: BINARY_DATA_HERE @@ -358,13 +391,12 @@ api.upload_file( file, # On Success func(result): # result is DemoApiResponse - prints("Success!", result) - pass # do things + prints("Success!", "upload_file", result) + pass # do things, make stuff , # On Error func(error): # error is DemoApiError - printerr(str(error)) - pass # do things + push_error(str(error)) , ) diff --git a/samples/client/petstore/gdscript/apis/DemoStoreApi.gd b/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoStoreApi.gd similarity index 70% rename from samples/client/petstore/gdscript/apis/DemoStoreApi.gd rename to samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoStoreApi.gd index 410dce06afd1..df3a5da919d4 100644 --- a/samples/client/petstore/gdscript/apis/DemoStoreApi.gd +++ b/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoStoreApi.gd @@ -1,30 +1,35 @@ +extends DemoApiBee +class_name DemoStoreApi + # THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. # For more information on how to customize templates, see: # https://openapi-generator.tech # The OpenAPI Generator Community, © Public Domain, 2022 + # API DemoStoreApi +# Instantiate this object and use it to make requests to the API. + +func _bzz_get_api_name() -> String: + return "DemoStoreApi" -extends DemoApiBee -class_name DemoStoreApi # Operation deleteOrder → DELETE /store/order/{orderId} # Delete purchase order by ID # # For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors func delete_order( - # orderId: String Eg: orderId_example + # orderId: String = "" Eg: orderId_example # ID of the order that needs to be deleted orderId: String, on_success: Callable = Callable(), # func(result) on_failure: Callable = Callable(), # func(error: DemoApiError) ): - # CollectionFormat: NO # Convert the String HTTP method to a Constant Godot understands - var bzz_method := self.bee_convert_http_method("DELETE") + var bzz_method := self._bzz_convert_http_method("DELETE") # Compute the URL path to the API resource - var bzz_path := "/v2/store/order/{orderId}".replace("{" + "orderId" + "}", bee_urlize_path_param(orderId)) + var bzz_path := "/v2/store/order/{orderId}".replace("{" + "orderId" + "}", _bzz_urlize_path_param(orderId)) # Collect the headers var bzz_headers := Dictionary() @@ -35,7 +40,7 @@ func delete_order( var bzz_body = null - self.bee_request( + self.bzz_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): on_success.call(bzz_result) @@ -45,6 +50,24 @@ func delete_order( , # ざわ‥ ) + +func delete_order_threaded( + # orderId: String = "" Eg: orderId_example + # ID of the order that needs to be deleted + orderId: String, + on_success: Callable = Callable(), # func(result) + on_failure: Callable = Callable(), # func(error: DemoApiError) +) -> Thread: + var bzz_thread := Thread.new() + var bzz_callable := Callable(self, "delete_order") + bzz_callable.bind( + orderId, + on_success, + on_failure, + ) + bzz_thread.start(bzz_callable) + return bzz_thread + # Operation getInventory → GET /store/inventory # Returns pet inventories by status # @@ -53,10 +76,9 @@ func get_inventory( on_success: Callable = Callable(), # func(result: Dictionary) on_failure: Callable = Callable(), # func(error: DemoApiError) ): - # CollectionFormat: NO # Convert the String HTTP method to a Constant Godot understands - var bzz_method := self.bee_convert_http_method("GET") + var bzz_method := self._bzz_convert_http_method("GET") # Compute the URL path to the API resource var bzz_path := "/v2/store/inventory" @@ -75,7 +97,7 @@ func get_inventory( var bzz_body = null - self.bee_request( + self.bzz_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): on_success.call(bzz_result) @@ -85,10 +107,24 @@ func get_inventory( , # ざわ‥ ) + +func get_inventory_threaded( + on_success: Callable = Callable(), # func(result: Dictionary) + on_failure: Callable = Callable(), # func(error: DemoApiError) +) -> Thread: + var bzz_thread := Thread.new() + var bzz_callable := Callable(self, "get_inventory") + bzz_callable.bind( + on_success, + on_failure, + ) + bzz_thread.start(bzz_callable) + return bzz_thread + # Operation getOrderById → GET /store/order/{orderId} # Find purchase order by ID # -# For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions +# For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions func get_order_by_id( # orderId: float Eg: 789 # ID of pet that needs to be fetched @@ -96,7 +132,6 @@ func get_order_by_id( on_success: Callable = Callable(), # func(result: Order) on_failure: Callable = Callable(), # func(error: DemoApiError) ): - # CollectionFormat: NO # Validate param `orderId` constraints if orderId > 5: @@ -113,10 +148,10 @@ func get_order_by_id( return # Convert the String HTTP method to a Constant Godot understands - var bzz_method := self.bee_convert_http_method("GET") + var bzz_method := self._bzz_convert_http_method("GET") # Compute the URL path to the API resource - var bzz_path := "/v2/store/order/{orderId}".replace("{" + "orderId" + "}", bee_urlize_path_param(orderId)) + var bzz_path := "/v2/store/order/{orderId}".replace("{" + "orderId" + "}", _bzz_urlize_path_param(orderId)) # Collect the headers var bzz_headers := Dictionary() @@ -132,10 +167,10 @@ func get_order_by_id( var bzz_body = null - self.bee_request( + self.bzz_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - bzz_result = DemoOrder.bee_denormalize_single(bzz_result) + bzz_result = DemoOrder.bzz_denormalize_single(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): @@ -143,6 +178,24 @@ func get_order_by_id( , # ざわ‥ ) + +func get_order_by_id_threaded( + # orderId: float Eg: 789 + # ID of pet that needs to be fetched + orderId: float, + on_success: Callable = Callable(), # func(result: Order) + on_failure: Callable = Callable(), # func(error: DemoApiError) +) -> Thread: + var bzz_thread := Thread.new() + var bzz_callable := Callable(self, "get_order_by_id") + bzz_callable.bind( + orderId, + on_success, + on_failure, + ) + bzz_thread.start(bzz_callable) + return bzz_thread + # Operation placeOrder → POST /store/order # Place an order for a pet func place_order( @@ -152,10 +205,9 @@ func place_order( on_success: Callable = Callable(), # func(result: Order) on_failure: Callable = Callable(), # func(error: DemoApiError) ): - # CollectionFormat: NO # Convert the String HTTP method to a Constant Godot understands - var bzz_method := self.bee_convert_http_method("POST") + var bzz_method := self._bzz_convert_http_method("POST") # Compute the URL path to the API resource var bzz_path := "/v2/store/order" @@ -170,7 +222,6 @@ func place_order( bzz_found_producible_mime = true break if not bzz_found_producible_mime: - # This is a bit strict, perhaps we could just push a warning and send JSON anyway? var error := DemoApiError.new() error.identifier = "place_order.headers.content_type" error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." @@ -189,10 +240,10 @@ func place_order( var bzz_body = null bzz_body = demoOrder - self.bee_request( + self.bzz_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - bzz_result = DemoOrder.bee_denormalize_single(bzz_result) + bzz_result = DemoOrder.bzz_denormalize_single(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): @@ -200,3 +251,21 @@ func place_order( , # ざわ‥ ) + +func place_order_threaded( + # demoOrder: DemoOrder + # order placed for purchasing the pet + demoOrder: DemoOrder, + on_success: Callable = Callable(), # func(result: Order) + on_failure: Callable = Callable(), # func(error: DemoApiError) +) -> Thread: + var bzz_thread := Thread.new() + var bzz_callable := Callable(self, "place_order") + bzz_callable.bind( + demoOrder, + on_success, + on_failure, + ) + bzz_thread.start(bzz_callable) + return bzz_thread + diff --git a/samples/client/petstore/gdscript/apis/DemoStoreApi.md b/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoStoreApi.md similarity index 63% rename from samples/client/petstore/gdscript/apis/DemoStoreApi.md rename to samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoStoreApi.md index 31ed94ff4bfe..0bd1b8910e8f 100644 --- a/samples/client/petstore/gdscript/apis/DemoStoreApi.md +++ b/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoStoreApi.md @@ -25,28 +25,32 @@ For valid response try integer IDs with value < 1000. Anything above 1000 or non ```gdscript -# Customize configuration, if needed +# Customize configuration var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 +#config.tls_enabled = true +#config.trusted_chain = preload("res://my_cert_chain.crt") -var api = DemoStoreApi.new() -api.config = config # optionally +# Instantiate the api +var api = DemoStoreApi.new(config) +# You can also provide your own HTTPClient, to re-use it across apis. +#var api = DemoStoreApi.new(config, client) +# Invoke an endpoint api.delete_order( - # orderId: String Eg: orderId_example + # orderId: String = "" Eg: orderId_example # ID of the order that needs to be deleted orderId, # On Success func(result): - prints("Success!", result) - pass # do things + prints("Success!", "delete_order", result) + pass # do things, make stuff , # On Error func(error): # error is DemoApiError - printerr(str(error)) - pass # do things + push_error(str(error)) , ) @@ -67,25 +71,29 @@ Returns a map of status codes to quantities ```gdscript -# Customize configuration, if needed +# Customize configuration var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 +#config.tls_enabled = true +#config.trusted_chain = preload("res://my_cert_chain.crt") -var api = DemoStoreApi.new() -api.config = config # optionally +# Instantiate the api +var api = DemoStoreApi.new(config) +# You can also provide your own HTTPClient, to re-use it across apis. +#var api = DemoStoreApi.new(config, client) +# Invoke an endpoint api.get_inventory( # On Success func(result): # result is Demointeger - prints("Success!", result) - pass # do things + prints("Success!", "get_inventory", result) + pass # do things, make stuff , # On Error func(error): # error is DemoApiError - printerr(str(error)) - pass # do things + push_error(str(error)) , ) @@ -98,35 +106,39 @@ api.get_inventory( Find purchase order by ID -For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions +For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions ### Example ```gdscript -# Customize configuration, if needed +# Customize configuration var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 +#config.tls_enabled = true +#config.trusted_chain = preload("res://my_cert_chain.crt") -var api = DemoStoreApi.new() -api.config = config # optionally +# Instantiate the api +var api = DemoStoreApi.new(config) +# You can also provide your own HTTPClient, to re-use it across apis. +#var api = DemoStoreApi.new(config, client) +# Invoke an endpoint api.get_order_by_id( # orderId: float Eg: 789 # ID of pet that needs to be fetched orderId, # On Success func(result): # result is DemoOrder - prints("Success!", result) - pass # do things + prints("Success!", "get_order_by_id", result) + pass # do things, make stuff , # On Error func(error): # error is DemoApiError - printerr(str(error)) - pass # do things + push_error(str(error)) , ) @@ -146,30 +158,34 @@ Place an order for a pet ```gdscript -# Customize configuration, if needed +# Customize configuration var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 +#config.tls_enabled = true +#config.trusted_chain = preload("res://my_cert_chain.crt") -var api = DemoStoreApi.new() -api.config = config # optionally +# Instantiate the api +var api = DemoStoreApi.new(config) +# You can also provide your own HTTPClient, to re-use it across apis. +#var api = DemoStoreApi.new(config, client) var demoOrder = DemoOrder.new() -# … fill model with data +# … fill model demoOrder with data +# Invoke an endpoint api.place_order( # demoOrder: DemoOrder # order placed for purchasing the pet demoOrder, # On Success func(result): # result is DemoOrder - prints("Success!", result) - pass # do things + prints("Success!", "place_order", result) + pass # do things, make stuff , # On Error func(error): # error is DemoApiError - printerr(str(error)) - pass # do things + push_error(str(error)) , ) diff --git a/samples/client/petstore/gdscript/apis/DemoUserApi.gd b/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoUserApi.gd similarity index 69% rename from samples/client/petstore/gdscript/apis/DemoUserApi.gd rename to samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoUserApi.gd index ec1e9a3500b2..052b79e254f9 100644 --- a/samples/client/petstore/gdscript/apis/DemoUserApi.gd +++ b/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoUserApi.gd @@ -1,11 +1,17 @@ +extends DemoApiBee +class_name DemoUserApi + # THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. # For more information on how to customize templates, see: # https://openapi-generator.tech # The OpenAPI Generator Community, © Public Domain, 2022 + # API DemoUserApi +# Instantiate this object and use it to make requests to the API. + +func _bzz_get_api_name() -> String: + return "DemoUserApi" -extends DemoApiBee -class_name DemoUserApi # Operation createUser → POST /user # Create user @@ -18,10 +24,9 @@ func create_user( on_success: Callable = Callable(), # func(result) on_failure: Callable = Callable(), # func(error: DemoApiError) ): - # CollectionFormat: NO # Convert the String HTTP method to a Constant Godot understands - var bzz_method := self.bee_convert_http_method("POST") + var bzz_method := self._bzz_convert_http_method("POST") # Compute the URL path to the API resource var bzz_path := "/v2/user" @@ -36,7 +41,6 @@ func create_user( bzz_found_producible_mime = true break if not bzz_found_producible_mime: - # This is a bit strict, perhaps we could just push a warning and send JSON anyway? var error := DemoApiError.new() error.identifier = "create_user.headers.content_type" error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." @@ -50,7 +54,7 @@ func create_user( var bzz_body = null bzz_body = demoUser - self.bee_request( + self.bzz_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): on_success.call(bzz_result) @@ -60,6 +64,24 @@ func create_user( , # ざわ‥ ) + +func create_user_threaded( + # demoUser: DemoUser + # Created user object + demoUser: DemoUser, + on_success: Callable = Callable(), # func(result) + on_failure: Callable = Callable(), # func(error: DemoApiError) +) -> Thread: + var bzz_thread := Thread.new() + var bzz_callable := Callable(self, "create_user") + bzz_callable.bind( + demoUser, + on_success, + on_failure, + ) + bzz_thread.start(bzz_callable) + return bzz_thread + # Operation createUsersWithArrayInput → POST /user/createWithArray # Creates list of users with given input array func create_users_with_array_input( @@ -69,10 +91,9 @@ func create_users_with_array_input( on_success: Callable = Callable(), # func(result) on_failure: Callable = Callable(), # func(error: DemoApiError) ): - # CollectionFormat: NO # Convert the String HTTP method to a Constant Godot understands - var bzz_method := self.bee_convert_http_method("POST") + var bzz_method := self._bzz_convert_http_method("POST") # Compute the URL path to the API resource var bzz_path := "/v2/user/createWithArray" @@ -87,7 +108,6 @@ func create_users_with_array_input( bzz_found_producible_mime = true break if not bzz_found_producible_mime: - # This is a bit strict, perhaps we could just push a warning and send JSON anyway? var error := DemoApiError.new() error.identifier = "create_users_with_array_input.headers.content_type" error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." @@ -101,7 +121,7 @@ func create_users_with_array_input( var bzz_body = null bzz_body = user - self.bee_request( + self.bzz_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): on_success.call(bzz_result) @@ -111,6 +131,24 @@ func create_users_with_array_input( , # ざわ‥ ) + +func create_users_with_array_input_threaded( + # user: Array + # List of user object + user: Array, + on_success: Callable = Callable(), # func(result) + on_failure: Callable = Callable(), # func(error: DemoApiError) +) -> Thread: + var bzz_thread := Thread.new() + var bzz_callable := Callable(self, "create_users_with_array_input") + bzz_callable.bind( + user, + on_success, + on_failure, + ) + bzz_thread.start(bzz_callable) + return bzz_thread + # Operation createUsersWithListInput → POST /user/createWithList # Creates list of users with given input array func create_users_with_list_input( @@ -120,10 +158,9 @@ func create_users_with_list_input( on_success: Callable = Callable(), # func(result) on_failure: Callable = Callable(), # func(error: DemoApiError) ): - # CollectionFormat: NO # Convert the String HTTP method to a Constant Godot understands - var bzz_method := self.bee_convert_http_method("POST") + var bzz_method := self._bzz_convert_http_method("POST") # Compute the URL path to the API resource var bzz_path := "/v2/user/createWithList" @@ -138,7 +175,6 @@ func create_users_with_list_input( bzz_found_producible_mime = true break if not bzz_found_producible_mime: - # This is a bit strict, perhaps we could just push a warning and send JSON anyway? var error := DemoApiError.new() error.identifier = "create_users_with_list_input.headers.content_type" error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." @@ -152,7 +188,7 @@ func create_users_with_list_input( var bzz_body = null bzz_body = user - self.bee_request( + self.bzz_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): on_success.call(bzz_result) @@ -162,24 +198,41 @@ func create_users_with_list_input( , # ざわ‥ ) + +func create_users_with_list_input_threaded( + # user: Array + # List of user object + user: Array, + on_success: Callable = Callable(), # func(result) + on_failure: Callable = Callable(), # func(error: DemoApiError) +) -> Thread: + var bzz_thread := Thread.new() + var bzz_callable := Callable(self, "create_users_with_list_input") + bzz_callable.bind( + user, + on_success, + on_failure, + ) + bzz_thread.start(bzz_callable) + return bzz_thread + # Operation deleteUser → DELETE /user/{username} # Delete user # # This can only be done by the logged in user. func delete_user( - # username: String Eg: username_example + # username: String = "" Eg: username_example # The name that needs to be deleted username: String, on_success: Callable = Callable(), # func(result) on_failure: Callable = Callable(), # func(error: DemoApiError) ): - # CollectionFormat: NO # Convert the String HTTP method to a Constant Godot understands - var bzz_method := self.bee_convert_http_method("DELETE") + var bzz_method := self._bzz_convert_http_method("DELETE") # Compute the URL path to the API resource - var bzz_path := "/v2/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) + var bzz_path := "/v2/user/{username}".replace("{" + "username" + "}", _bzz_urlize_path_param(username)) # Collect the headers var bzz_headers := Dictionary() @@ -190,7 +243,7 @@ func delete_user( var bzz_body = null - self.bee_request( + self.bzz_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): on_success.call(bzz_result) @@ -200,22 +253,39 @@ func delete_user( , # ざわ‥ ) + +func delete_user_threaded( + # username: String = "" Eg: username_example + # The name that needs to be deleted + username: String, + on_success: Callable = Callable(), # func(result) + on_failure: Callable = Callable(), # func(error: DemoApiError) +) -> Thread: + var bzz_thread := Thread.new() + var bzz_callable := Callable(self, "delete_user") + bzz_callable.bind( + username, + on_success, + on_failure, + ) + bzz_thread.start(bzz_callable) + return bzz_thread + # Operation getUserByName → GET /user/{username} # Get user by user name func get_user_by_name( - # username: String Eg: username_example + # username: String = "" Eg: username_example # The name that needs to be fetched. Use user1 for testing. username: String, on_success: Callable = Callable(), # func(result: User) on_failure: Callable = Callable(), # func(error: DemoApiError) ): - # CollectionFormat: NO # Convert the String HTTP method to a Constant Godot understands - var bzz_method := self.bee_convert_http_method("GET") + var bzz_method := self._bzz_convert_http_method("GET") # Compute the URL path to the API resource - var bzz_path := "/v2/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) + var bzz_path := "/v2/user/{username}".replace("{" + "username" + "}", _bzz_urlize_path_param(username)) # Collect the headers var bzz_headers := Dictionary() @@ -231,10 +301,10 @@ func get_user_by_name( var bzz_body = null - self.bee_request( + self.bzz_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): - bzz_result = DemoUser.bee_denormalize_single(bzz_result) + bzz_result = DemoUser.bzz_denormalize_single(bzz_result) on_success.call(bzz_result) , # ざわ‥ func(bzz_error): @@ -242,19 +312,36 @@ func get_user_by_name( , # ざわ‥ ) + +func get_user_by_name_threaded( + # username: String = "" Eg: username_example + # The name that needs to be fetched. Use user1 for testing. + username: String, + on_success: Callable = Callable(), # func(result: User) + on_failure: Callable = Callable(), # func(error: DemoApiError) +) -> Thread: + var bzz_thread := Thread.new() + var bzz_callable := Callable(self, "get_user_by_name") + bzz_callable.bind( + username, + on_success, + on_failure, + ) + bzz_thread.start(bzz_callable) + return bzz_thread + # Operation loginUser → GET /user/login # Logs user into the system func login_user( - # username: String Eg: username_example + # username: String = "" Eg: username_example # The user name for login username: String, - # password: String Eg: password_example + # password: String = "" Eg: password_example # The password for login in clear text password: String, on_success: Callable = Callable(), # func(result: String) on_failure: Callable = Callable(), # func(error: DemoApiError) ): - # CollectionFormat: NO # Validate param `username` constraints var bzz_username_regex := RegEx.new() @@ -266,17 +353,8 @@ func login_user( on_failure.call(error) return - # Validate param `password` constraints - if (password is String) and password.length() > 7: - var error := DemoApiError.new() - #error.internal_code = ERR_INVALID_PARAMETER - error.identifier = "login_user.param.validation.max_length" - error.message = "Invalid length for `password`, must be smaller than or equal to 7." - on_failure.call(error) - return - # Convert the String HTTP method to a Constant Godot understands - var bzz_method := self.bee_convert_http_method("GET") + var bzz_method := self._bzz_convert_http_method("GET") # Compute the URL path to the API resource var bzz_path := "/v2/user/login" @@ -297,7 +375,7 @@ func login_user( var bzz_body = null - self.bee_request( + self.bzz_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): on_success.call(bzz_result) @@ -307,16 +385,37 @@ func login_user( , # ざわ‥ ) + +func login_user_threaded( + # username: String = "" Eg: username_example + # The user name for login + username: String, + # password: String = "" Eg: password_example + # The password for login in clear text + password: String, + on_success: Callable = Callable(), # func(result: String) + on_failure: Callable = Callable(), # func(error: DemoApiError) +) -> Thread: + var bzz_thread := Thread.new() + var bzz_callable := Callable(self, "login_user") + bzz_callable.bind( + username, + password, + on_success, + on_failure, + ) + bzz_thread.start(bzz_callable) + return bzz_thread + # Operation logoutUser → GET /user/logout # Logs out current logged in user session func logout_user( on_success: Callable = Callable(), # func(result) on_failure: Callable = Callable(), # func(error: DemoApiError) ): - # CollectionFormat: NO # Convert the String HTTP method to a Constant Godot understands - var bzz_method := self.bee_convert_http_method("GET") + var bzz_method := self._bzz_convert_http_method("GET") # Compute the URL path to the API resource var bzz_path := "/v2/user/logout" @@ -330,7 +429,7 @@ func logout_user( var bzz_body = null - self.bee_request( + self.bzz_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): on_success.call(bzz_result) @@ -340,12 +439,26 @@ func logout_user( , # ざわ‥ ) + +func logout_user_threaded( + on_success: Callable = Callable(), # func(result) + on_failure: Callable = Callable(), # func(error: DemoApiError) +) -> Thread: + var bzz_thread := Thread.new() + var bzz_callable := Callable(self, "logout_user") + bzz_callable.bind( + on_success, + on_failure, + ) + bzz_thread.start(bzz_callable) + return bzz_thread + # Operation updateUser → PUT /user/{username} # Updated user # # This can only be done by the logged in user. func update_user( - # username: String Eg: username_example + # username: String = "" Eg: username_example # name that need to be deleted username: String, # demoUser: DemoUser @@ -354,13 +467,12 @@ func update_user( on_success: Callable = Callable(), # func(result) on_failure: Callable = Callable(), # func(error: DemoApiError) ): - # CollectionFormat: NO # Convert the String HTTP method to a Constant Godot understands - var bzz_method := self.bee_convert_http_method("PUT") + var bzz_method := self._bzz_convert_http_method("PUT") # Compute the URL path to the API resource - var bzz_path := "/v2/user/{username}".replace("{" + "username" + "}", bee_urlize_path_param(username)) + var bzz_path := "/v2/user/{username}".replace("{" + "username" + "}", _bzz_urlize_path_param(username)) # Collect the headers var bzz_headers := Dictionary() @@ -372,7 +484,6 @@ func update_user( bzz_found_producible_mime = true break if not bzz_found_producible_mime: - # This is a bit strict, perhaps we could just push a warning and send JSON anyway? var error := DemoApiError.new() error.identifier = "update_user.headers.content_type" error.message = "That endpoint only accepts %s as content type(s) and none are supported by this client." @@ -386,7 +497,7 @@ func update_user( var bzz_body = null bzz_body = demoUser - self.bee_request( + self.bzz_request( bzz_method, bzz_path, bzz_headers, bzz_query, bzz_body, func(bzz_result, bzz_code, bzz_headers): on_success.call(bzz_result) @@ -396,3 +507,25 @@ func update_user( , # ざわ‥ ) + +func update_user_threaded( + # username: String = "" Eg: username_example + # name that need to be deleted + username: String, + # demoUser: DemoUser + # Updated user object + demoUser: DemoUser, + on_success: Callable = Callable(), # func(result) + on_failure: Callable = Callable(), # func(error: DemoApiError) +) -> Thread: + var bzz_thread := Thread.new() + var bzz_callable := Callable(self, "update_user") + bzz_callable.bind( + username, + demoUser, + on_success, + on_failure, + ) + bzz_thread.start(bzz_callable) + return bzz_thread + diff --git a/samples/client/petstore/gdscript/apis/DemoUserApi.md b/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoUserApi.md similarity index 60% rename from samples/client/petstore/gdscript/apis/DemoUserApi.md rename to samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoUserApi.md index be27c56a6a15..1db61300b06a 100644 --- a/samples/client/petstore/gdscript/apis/DemoUserApi.md +++ b/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoUserApi.md @@ -30,30 +30,34 @@ This can only be done by the logged in user. ```gdscript -# Customize configuration, if needed +# Customize configuration var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 +#config.tls_enabled = true +#config.trusted_chain = preload("res://my_cert_chain.crt") -var api = DemoUserApi.new() -api.config = config # optionally +# Instantiate the api +var api = DemoUserApi.new(config) +# You can also provide your own HTTPClient, to re-use it across apis. +#var api = DemoUserApi.new(config, client) var demoUser = DemoUser.new() -# … fill model with data +# … fill model demoUser with data +# Invoke an endpoint api.create_user( # demoUser: DemoUser # Created user object demoUser, # On Success func(result): - prints("Success!", result) - pass # do things + prints("Success!", "create_user", result) + pass # do things, make stuff , # On Error func(error): # error is DemoApiError - printerr(str(error)) - pass # do things + push_error(str(error)) , ) @@ -74,28 +78,32 @@ Creates list of users with given input array ```gdscript -# Customize configuration, if needed +# Customize configuration var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 +#config.tls_enabled = true +#config.trusted_chain = preload("res://my_cert_chain.crt") -var api = DemoUserApi.new() -api.config = config # optionally +# Instantiate the api +var api = DemoUserApi.new(config) +# You can also provide your own HTTPClient, to re-use it across apis. +#var api = DemoUserApi.new(config, client) +# Invoke an endpoint api.create_users_with_array_input( # user: Array # List of user object user, # On Success func(result): - prints("Success!", result) - pass # do things + prints("Success!", "create_users_with_array_input", result) + pass # do things, make stuff , # On Error func(error): # error is DemoApiError - printerr(str(error)) - pass # do things + push_error(str(error)) , ) @@ -116,28 +124,32 @@ Creates list of users with given input array ```gdscript -# Customize configuration, if needed +# Customize configuration var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 +#config.tls_enabled = true +#config.trusted_chain = preload("res://my_cert_chain.crt") -var api = DemoUserApi.new() -api.config = config # optionally +# Instantiate the api +var api = DemoUserApi.new(config) +# You can also provide your own HTTPClient, to re-use it across apis. +#var api = DemoUserApi.new(config, client) +# Invoke an endpoint api.create_users_with_list_input( # user: Array # List of user object user, # On Success func(result): - prints("Success!", result) - pass # do things + prints("Success!", "create_users_with_list_input", result) + pass # do things, make stuff , # On Error func(error): # error is DemoApiError - printerr(str(error)) - pass # do things + push_error(str(error)) , ) @@ -158,28 +170,32 @@ This can only be done by the logged in user. ```gdscript -# Customize configuration, if needed +# Customize configuration var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 +#config.tls_enabled = true +#config.trusted_chain = preload("res://my_cert_chain.crt") -var api = DemoUserApi.new() -api.config = config # optionally +# Instantiate the api +var api = DemoUserApi.new(config) +# You can also provide your own HTTPClient, to re-use it across apis. +#var api = DemoUserApi.new(config, client) +# Invoke an endpoint api.delete_user( - # username: String Eg: username_example + # username: String = "" Eg: username_example # The name that needs to be deleted username, # On Success func(result): - prints("Success!", result) - pass # do things + prints("Success!", "delete_user", result) + pass # do things, make stuff , # On Error func(error): # error is DemoApiError - printerr(str(error)) - pass # do things + push_error(str(error)) , ) @@ -199,28 +215,32 @@ Get user by user name ```gdscript -# Customize configuration, if needed +# Customize configuration var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 +#config.tls_enabled = true +#config.trusted_chain = preload("res://my_cert_chain.crt") -var api = DemoUserApi.new() -api.config = config # optionally +# Instantiate the api +var api = DemoUserApi.new(config) +# You can also provide your own HTTPClient, to re-use it across apis. +#var api = DemoUserApi.new(config, client) +# Invoke an endpoint api.get_user_by_name( - # username: String Eg: username_example + # username: String = "" Eg: username_example # The name that needs to be fetched. Use user1 for testing. username, # On Success func(result): # result is DemoUser - prints("Success!", result) - pass # do things + prints("Success!", "get_user_by_name", result) + pass # do things, make stuff , # On Error func(error): # error is DemoApiError - printerr(str(error)) - pass # do things + push_error(str(error)) , ) @@ -240,31 +260,35 @@ Logs user into the system ```gdscript -# Customize configuration, if needed +# Customize configuration var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 +#config.tls_enabled = true +#config.trusted_chain = preload("res://my_cert_chain.crt") -var api = DemoUserApi.new() -api.config = config # optionally +# Instantiate the api +var api = DemoUserApi.new(config) +# You can also provide your own HTTPClient, to re-use it across apis. +#var api = DemoUserApi.new(config, client) +# Invoke an endpoint api.login_user( - # username: String Eg: username_example + # username: String = "" Eg: username_example # The user name for login username, - # password: String Eg: password_example + # password: String = "" Eg: password_example # The password for login in clear text password, # On Success func(result): # result is Demostring - prints("Success!", result) - pass # do things + prints("Success!", "login_user", result) + pass # do things, make stuff , # On Error func(error): # error is DemoApiError - printerr(str(error)) - pass # do things + push_error(str(error)) , ) @@ -285,25 +309,29 @@ Logs out current logged in user session ```gdscript -# Customize configuration, if needed +# Customize configuration var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 +#config.tls_enabled = true +#config.trusted_chain = preload("res://my_cert_chain.crt") -var api = DemoUserApi.new() -api.config = config # optionally +# Instantiate the api +var api = DemoUserApi.new(config) +# You can also provide your own HTTPClient, to re-use it across apis. +#var api = DemoUserApi.new(config, client) +# Invoke an endpoint api.logout_user( # On Success func(result): - prints("Success!", result) - pass # do things + prints("Success!", "logout_user", result) + pass # do things, make stuff , # On Error func(error): # error is DemoApiError - printerr(str(error)) - pass # do things + push_error(str(error)) , ) @@ -324,19 +352,24 @@ This can only be done by the logged in user. ```gdscript -# Customize configuration, if needed +# Customize configuration var config := DemoApiConfig.new() config.host = "localhost" config.port = 8080 +#config.tls_enabled = true +#config.trusted_chain = preload("res://my_cert_chain.crt") -var api = DemoUserApi.new() -api.config = config # optionally +# Instantiate the api +var api = DemoUserApi.new(config) +# You can also provide your own HTTPClient, to re-use it across apis. +#var api = DemoUserApi.new(config, client) var demoUser = DemoUser.new() -# … fill model with data +# … fill model demoUser with data +# Invoke an endpoint api.update_user( - # username: String Eg: username_example + # username: String = "" Eg: username_example # name that need to be deleted username, # demoUser: DemoUser @@ -344,13 +377,12 @@ api.update_user( demoUser, # On Success func(result): - prints("Success!", result) - pass # do things + prints("Success!", "update_user", result) + pass # do things, make stuff , # On Error func(error): # error is DemoApiError - printerr(str(error)) - pass # do things + push_error(str(error)) , ) diff --git a/samples/client/petstore/gdscript/addons/oas.petstore.client/core/DemoApiBee.gd b/samples/client/petstore/gdscript/addons/oas.petstore.client/core/DemoApiBee.gd new file mode 100644 index 000000000000..5a86725de110 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/oas.petstore.client/core/DemoApiBee.gd @@ -0,0 +1,482 @@ +extends RefCounted +class_name DemoApiBee + +# Base class for all generated API endpoints. +# +# Every property/method defined here may collide with userland, +# so these are all listed and excluded in our CodeGen Java file. +# We want to keep the amount of renaming to a minimum, though. +# Therefore, we use the _bzz_ prefix, even if awkward. + + +const BEE_CONTENT_TYPE_TEXT := "text/plain" +const BEE_CONTENT_TYPE_HTML := "text/html" +const BEE_CONTENT_TYPE_JSON := "application/json" +const BEE_CONTENT_TYPE_FORM := "application/x-www-form-urlencoded" +const BEE_CONTENT_TYPE_JSONLD := "application/json+ld" # unsupported (for now) +const BEE_CONTENT_TYPE_XML := "application/xml" # unsupported (for now) + +# From this client's point of view. +# Adding a content type here won't magically make the client support it, but you may reorder. +# These are sorted by decreasing preference. (first → preferred) +const BEE_PRODUCIBLE_CONTENT_TYPES := [ + BEE_CONTENT_TYPE_JSON, + BEE_CONTENT_TYPE_FORM, +] + +# From this client's point of view. +# Adding a content type here won't magically make the client support it, but you may reorder. +# These are sorted by decreasing preference. (first → preferred) +const BEE_CONSUMABLE_CONTENT_TYPES := [ + BEE_CONTENT_TYPE_JSON, +] + + +# Godot's HTTP Client this Api instance is using. +# If none was set (by you), we'll lazily make one. +var _bzz_client: HTTPClient: + set(value): + _bzz_client = value + get: + if not _bzz_client: + _bzz_client = HTTPClient.new() + return _bzz_client + + +# General configuration that can be shared across Api instances for convenience. +# If no configuration was provided, we'll lazily make one with defaults, +# but you probably want to make your own with your own domain and scheme. +var _bzz_config: DemoApiConfig: + set(value): + _bzz_config = value + get: + if not _bzz_config: + _bzz_config = DemoApiConfig.new() + return _bzz_config + + +var _bzz_name: String: + get: + return _bzz_get_api_name() + + +# Constructor, where you probably want to inject your configuration, +# and as Godot recommends re-using HTTP clients, your client as well. +func _init(config : DemoApiConfig = null, client : HTTPClient = null): + if config != null: + self._bzz_config = config + if client != null: + self._bzz_client = client + + +func _bzz_get_api_name() -> String: + return "ApiBee" + + +func _bzz_next_loop_iteration(): + # I can't find `idle_frame` in 4.0, but we probably want idle_frame here + return Engine.get_main_loop().process_frame + + +func _bzz_connect_client_if_needed( + on_success: Callable, # func() + on_failure: Callable, # func(error: DemoApiError) + #finally: Callable, +): + if ( + self._bzz_client.get_status() == HTTPClient.STATUS_CONNECTED + or + self._bzz_client.get_status() == HTTPClient.STATUS_RESOLVING + or + self._bzz_client.get_status() == HTTPClient.STATUS_CONNECTING + or + self._bzz_client.get_status() == HTTPClient.STATUS_REQUESTING + or + self._bzz_client.get_status() == HTTPClient.STATUS_BODY + ): + on_success.call() + + var connecting := self._bzz_client.connect_to_host( + self._bzz_config.host, self._bzz_config.port, self._bzz_config.tls_options + ) + if connecting != OK: + var error := DemoApiError.new() + error.internal_code = connecting + error.identifier = "apibee.connect_to_host.failure" + error.message = "%s: failed to connect to `%s' port `%d' with error: %s" % [ + _bzz_name, self._bzz_config.host, self._bzz_config.port, + _bzz_httpclient_status_string(connecting), + ] + on_failure.call(error) + return + + # Wait until resolved and connected. + while ( + self._bzz_client.get_status() == HTTPClient.STATUS_CONNECTING + or + self._bzz_client.get_status() == HTTPClient.STATUS_RESOLVING + ): + self._bzz_client.poll() + self._bzz_config.log_debug("Connecting…") + if self._bzz_config.polling_interval_ms: + OS.delay_msec(self._bzz_config.polling_interval_ms) + await _bzz_next_loop_iteration() + + var connected := self._bzz_client.get_status() + if connected != HTTPClient.STATUS_CONNECTED: + var error := DemoApiError.new() + error.internal_code = connected as Error + error.identifier = "apibee.connect_to_host.wrong_status" + error.message = "%s: failed to connect to `%s' port `%d' : %s" % [ + _bzz_name, self._bzz_config.host, self._bzz_config.port, + _bzz_httpclient_status_string(connected), + ] + on_failure.call(error) + return + + on_success.call() + + +func bzz_request( + method: int, # one of HTTPClient.METHOD_XXXXX + path: String, + headers: Dictionary, + query: Dictionary, + body, # Variant that will be serialized and sent + on_success: Callable, # func(response: Variant, responseCode: int, responseHeaders: Dictionary) + on_failure: Callable, # func(error: DemoApiError) +): + # This method does not handle full deserialization, it only handles decode and not denormalization. + # Denormalization is handled in each generated API endpoint in the on_success callable of this method. + # This is because this method already has plethora of parameters and we don't want even more. + + _bzz_request_text( + method, path, headers, query, body, + func(responseText, responseCode, responseHeaders): + var mime: String = responseHeaders['Mime'] + var decodedResponse # Variant + + if BEE_CONTENT_TYPE_TEXT == mime: + decodedResponse = responseText + elif BEE_CONTENT_TYPE_HTML == mime: + decodedResponse = responseText + elif BEE_CONTENT_TYPE_JSON == mime: + var parser := JSON.new() + var parsing := parser.parse(responseText) + if OK != parsing: + var error := DemoApiError.new() + error.internal_code = parsing + error.identifier = "apibee.decode.cannot_parse_json" + error.message = "%s: failed to parse JSON response at line %d.\n%s" % [ + _bzz_name, parser.get_error_line(), parser.get_error_message() + ] + on_failure.call(error) + return + decodedResponse = parser.data + else: + var error := DemoApiError.new() + error.internal_code = ERR_INVALID_DATA + error.identifier = "apibee.decode.mime_type_unsupported" + error.message = "%s: mime type `%s' is not supported (yet)" % [ + _bzz_name, mime + ] + on_failure.call(error) + return + + on_success.call(decodedResponse, responseCode, responseHeaders) + , + func(error): + on_failure.call(error) + , + ) + + +func _bzz_request_text( + method: int, # one of HTTPClient.METHOD_XXXXX + path: String, + headers: Dictionary, + query: Dictionary, + body, # Variant that will be serialized + on_success: Callable, # func(responseText: String, responseCode: int, responseHeaders: Dictionary) + on_failure: Callable, # func(error: DemoApiError) +): + _bzz_connect_client_if_needed( + func(): + _bzz_do_request_text(method, path, headers, query, body, on_success, on_failure) + , + func(error): + on_failure.call(error) + , + ) + + +func _bzz_do_request_text( + method: int, # one of HTTPClient.METHOD_XXXXX + path: String, + headers: Dictionary, + query: Dictionary, + body, # Variant that will be serialized + on_success: Callable, # func(responseText: String, responseCode: int, responseHeaders: Dictionary) + on_failure: Callable, # func(error: DemoApiError) +): + + headers = headers.duplicate(true) + headers.merge(self._bzz_config.headers_base) + headers.merge(self._bzz_config.headers_override, true) + + var body_normalized = body + if body is Object: + if body.has_method('bzz_collect_missing_properties'): + var missing_properties : Array = body.bzz_collect_missing_properties() + if missing_properties: + var error := DemoApiError.new() + error.identifier = "apibee.request.body.missing_properties" + error.message = "%s: `%s' is missing required properties %s." % [ + _bzz_name, body.bzz_class_name, missing_properties + ] + on_failure.call(error) + return + if body.has_method('bzz_normalize'): + body_normalized = body.bzz_normalize() + + var body_serialized := "" + var content_type := self._bzz_get_content_type(headers) + if content_type == BEE_CONTENT_TYPE_JSON: + body_serialized = JSON.stringify(body_normalized) + elif content_type == BEE_CONTENT_TYPE_FORM: + body_serialized = self._bzz_client.query_string_from_dict(body_normalized) + else: + # TODO: Handle other serialization schemes (json+ld, xml…) + push_warning("Unsupported content-type `%s`." % content_type) + + var path_queried := path + var query_string := self._bzz_client.query_string_from_dict(query) + if query_string: + path_queried = "%s?%s" % [path, query_string] + + var headers_for_godot := Array() # of String + for key in headers: + headers_for_godot.append("%s: %s" % [key, headers[key]]) + + self._bzz_config.log_info("%s: REQUEST %s %s" % [_bzz_name, method, path_queried]) + if not headers.is_empty(): + self._bzz_config.log_debug("→ HEADERS: %s" % [str(headers)]) + if body_serialized: + self._bzz_config.log_debug("→ BODY: \n%s" % [body_serialized]) + + var requesting := self._bzz_client.request(method, path_queried, headers_for_godot, body_serialized) + if requesting != OK: + var error := DemoApiError.new() + error.internal_code = requesting + error.identifier = "apibee.request.failure" + error.message = "%s: failed to request to path `%s'." % [ + _bzz_name, path + ] + on_failure.call(error) + return + + while self._bzz_client.get_status() == HTTPClient.STATUS_REQUESTING: + # Keep polling for as long as the request is being processed. + self._bzz_client.poll() + self._bzz_config.log_debug("Requesting…") + if self._bzz_config.polling_interval_ms: + OS.delay_msec(self._bzz_config.polling_interval_ms) + await _bzz_next_loop_iteration() + + if not self._bzz_client.has_response(): + var error := DemoApiError.new() + error.identifier = "apibee.request.no_response" + error.message = "%s: request to `%s' returned no response whatsoever. (status=%d)" % [ + _bzz_name, path, self._bzz_client.get_status(), + ] + on_failure.call(error) + return + + var response_code := self._bzz_client.get_response_code() + var response_headers := self._bzz_client.get_response_headers_as_dictionary() + # FIXME: extract from headers "Content-Type": "application/json; charset=utf-8" + # This begs for a HttpResponse class ; wait for Godot? + var encoding := "utf-8" + var mime := "application/json" + response_headers['Encoding'] = encoding + response_headers['Mime'] = mime + + # TODO: cap the size of this, perhaps? + var response_bytes := PackedByteArray() + + while self._bzz_client.get_status() == HTTPClient.STATUS_BODY: + self._bzz_client.poll() + var chunk = self._bzz_client.read_response_body_chunk() + if chunk.size() == 0: # Got nothing, wait for buffers to fill a bit. + if self._bzz_config.polling_interval_ms: + OS.delay_usec(self._bzz_config.polling_interval_ms) + await _bzz_next_loop_iteration() + else: # Yummy data has arrived + response_bytes = response_bytes + chunk + + self._bzz_config.log_info("%s: RESPONSE %d (%d bytes)" % [ + _bzz_name, response_code, response_bytes.size() + ]) + if not response_headers.is_empty(): + self._bzz_config.log_debug("→ HEADERS: %s" % str(response_headers)) + + var response_text: String + if encoding == "utf-8": + response_text = response_bytes.get_string_from_utf8() + elif encoding == "utf-16": + response_text = response_bytes.get_string_from_utf16() + elif encoding == "utf-32": + response_text = response_bytes.get_string_from_utf32() + else: + response_text = response_bytes.get_string_from_ascii() + + if response_text: + self._bzz_config.log_debug("→ BODY: \n%s" % response_text) + + if response_code >= 500: + var error := DemoApiError.new() + error.internal_code = ERR_PRINTER_ON_FIRE + error.response_code = response_code + error.identifier = "apibee.response.5xx" + error.message = "%s: request to `%s' made the server hiccup with a %d." % [ + _bzz_name, path, response_code + ] + error.message += "\n%s" % [ + _bzz_format_error_response(response_text) + ] + on_failure.call(error) + return + elif response_code >= 400: + var error := DemoApiError.new() + error.identifier = "apibee.response.4xx" + error.response_code = response_code + error.message = "%s: request to `%s' was denied with a %d." % [ + _bzz_name, path, response_code + ] + error.message += "\n%s" % [ + _bzz_format_error_response(response_text) + ] + on_failure.call(error) + return + elif response_code >= 300: + var error := DemoApiError.new() + error.identifier = "apibee.response.3xx" + error.response_code = response_code + error.message = "%s: request to `%s' was redirected with a %d. We do not support redirects in that client yet." % [ + _bzz_name, path, response_code + ] + on_failure.call(error) + return + + # Should we close ? + #self._bzz_client.close() + + on_success.call(response_text, response_code, response_headers) + + +func _bzz_convert_http_method(method: String) -> int: + match method: + 'GET': return HTTPClient.METHOD_GET + 'POST': return HTTPClient.METHOD_POST + 'PUT': return HTTPClient.METHOD_PUT + 'PATCH': return HTTPClient.METHOD_PATCH + 'DELETE': return HTTPClient.METHOD_DELETE + 'CONNECT': return HTTPClient.METHOD_CONNECT + 'HEAD': return HTTPClient.METHOD_HEAD + 'MAX': return HTTPClient.METHOD_MAX + 'OPTIONS': return HTTPClient.METHOD_OPTIONS + 'TRACE': return HTTPClient.METHOD_TRACE + _: + push_error("%s: unknown http method `%s`, assuming GET." % [ + _bzz_name, method + ]) + return HTTPClient.METHOD_GET + + +func _bzz_urlize_path_param(anything) -> String: + var serialized := _bzz_escape_path_param(str(anything)) + return serialized + + +func _bzz_escape_path_param(value: String) -> String: + # TODO: escape for URL + return value + + +func _bzz_get_content_type(headers: Dictionary) -> String: + if headers.has("Content-Type"): + return headers["Content-Type"] + return BEE_PRODUCIBLE_CONTENT_TYPES[0] + + +func _bzz_format_error_response(response: String) -> String: + # TODO: handle other (de)serialization schemes + var parser := JSON.new() + var parsing := parser.parse(response) + if OK != parsing: + return response + if not (parser.data is Dictionary): + return response + var s := "ERROR" + if parser.data.has("code"): + s += " %d" % parser.data['code'] + if parser.data.has("message"): + s += "\n%s" % parser.data['message'] + else: + return response + return s + + +func _bzz_httpclient_status_info(status: int) -> Dictionary: + # At some point Godot ought to natively implement this and we won't need this "shim" anymore. + match status: + HTTPClient.STATUS_DISCONNECTED: return { + "name": "STATUS_DISCONNECTED", + "description": "Disconnected from the server." + } + HTTPClient.STATUS_RESOLVING: return { + "name": "STATUS_RESOLVING", + "description": "Currently resolving the hostname for the given URL into an IP." + } + HTTPClient.STATUS_CANT_RESOLVE: return { + "name": "STATUS_CANT_RESOLVE", + "description": "DNS failure: Can't resolve the hostname for the given URL." + } + HTTPClient.STATUS_CONNECTING: return { + "name": "STATUS_CONNECTING", + "description": "Currently connecting to server." + } + HTTPClient.STATUS_CANT_CONNECT: return { + "name": "STATUS_CANT_CONNECT", + "description": "Can't connect to the server." + } + HTTPClient.STATUS_CONNECTED: return { + "name": "STATUS_CONNECTED", + "description": "Connection established." + } + HTTPClient.STATUS_REQUESTING: return { + "name": "STATUS_REQUESTING", + "description": "Currently sending request." + } + HTTPClient.STATUS_BODY: return { + "name": "STATUS_BODY", + "description": "HTTP body received." + } + HTTPClient.STATUS_CONNECTION_ERROR: return { + "name": "STATUS_CONNECTION_ERROR", + "description": "Error in HTTP connection." + } + HTTPClient.STATUS_TLS_HANDSHAKE_ERROR: return { + "name": "STATUS_TLS_HANDSHAKE_ERROR", + "description": "Error in TLS handshake." + } + return { + "name": "UNKNOWN (%d)" % status, + "description": "Unknown HTTPClient status." + } + + +func _bzz_httpclient_status_string(status: int) -> String: + var info := _bzz_httpclient_status_info(status) + return "%s (%s)" % [info["description"], info["name"]] + diff --git a/samples/client/petstore/gdscript/addons/oas.petstore.client/core/DemoApiConfig.gd b/samples/client/petstore/gdscript/addons/oas.petstore.client/core/DemoApiConfig.gd new file mode 100644 index 000000000000..9e6b79b0dc04 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/oas.petstore.client/core/DemoApiConfig.gd @@ -0,0 +1,142 @@ +extends Resource +class_name DemoApiConfig + +# THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. +# For more information on how to customize templates, see: +# https://openapi-generator.tech +# The OpenAPI Generator Community, © Public Domain, 2022 + + +# Configuration options for Api endpoints +# ======================================= +# +# Helps share configuration customizations across Apis: +# - host, port & scheme +# - extra headers +# - security layer options (TLS certificates) +# - log level +# +# You probably want to make an instance of this class with your own values, +# and feed it to each Api's `bee_config` before calling the Api's methods. +# +# Since it is a Resource, you may use `ResourceSaver.save()` and `load()` +# to save it and load it from file, for convenience. +# + + +# These are constant, immutable default values. Best not edit them. +# To set different values at runtime, use the @export'ed properties below. +const BEE_DEFAULT_HOST := "petstore.swagger.io" +const BEE_DEFAULT_PORT_HTTP := 80 +const BEE_DEFAULT_PORT_HTTPS := 443 +const BEE_DEFAULT_POLLING_INTERVAL_MS := 333 # milliseconds + + +# Configuration also handles logging because it's convenient. +enum LogLevel { + SILENT, + ERROR, + WARNING, + INFO, + DEBUG, +} + + +# Log level to configure verbosity. +# @export_enum ain't working for ints yet (2023-03) +@export var log_level := LogLevel.WARNING + + +# The host to connect to, with or without the protocol scheme. +# Eg: "gitea.com", "https://gitea.com" +# We toggle TLS accordingly to the provided scheme, if any. +@export var host := BEE_DEFAULT_HOST: + set(value): + if value.begins_with("https://"): + tls_enabled = true + value = value.substr(8) # "https://".length() == 8 + elif value.begins_with("http://"): + tls_enabled = false + value = value.substr(7) # "http://".length() == 7 + host = value + + +# Port through which the connection will be established. +# Note: changing the host may change the port as well if the scheme was provided, see above. +@export var port := BEE_DEFAULT_PORT_HTTP + + +# Headers used as base for all requests made by Api instances using this config. +# Those are the lowest priority headers, and are merged with custom headers provided in the bee_request() method call +# as well as the headers override below, to compute the final, actually sent headers. +@export var headers_base := { + # Stigmergy: everyone does what is left to do (like ants do) + "User-Agent": "Stigmergiac/1.0 (Godot)", + # For my mental health's sake, only JSON is supported for now + "Accept": "application/json", + "Content-Type": "application/json", +} + + +# High-priority headers, they will always override other headers coming from the base above or the method call. +@export var headers_override := {} + + +# Duration of sleep between poll() calls. +@export var polling_interval_ms := BEE_DEFAULT_POLLING_INTERVAL_MS # milliseconds + + +# Enable the Transport Security Layer (packet encryption, HTTPS) +@export var tls_enabled := false: + set(value): + tls_enabled = value + port = BEE_DEFAULT_PORT_HTTPS if tls_enabled else BEE_DEFAULT_PORT_HTTP + + +# You should preload your *.crt file (the whole chain) in here if you want TLS. +# I usually concatenate my /etc/ssl/certs/ca-certificates.crt and webserver certs here. +# Remember to add the *.crt file to the exports, if necessary. +@export var trusted_chain: X509Certificate # only used if tls is enabled +@export var common_name_override := "" # for TLSOptions + + +# Dynamic accessor using the TLS properties above, but you may inject your own +# for example if you need to use TLSOptions.client_unsafe. Best not @export this. +var tls_options: TLSOptions: + set(value): + tls_options = value + get: + if not tls_enabled: + return null + if not tls_options: + tls_options = TLSOptions.client(trusted_chain, common_name_override) + return tls_options + + +func log_error(message: String): + if self.log_level >= LogLevel.ERROR: + push_error(message) + +func log_warning(message: String): + if self.log_level >= LogLevel.WARNING: + push_warning(message) + +func log_info(message: String): + if self.log_level >= LogLevel.INFO: + print(message) + +func log_debug(message: String): + if self.log_level >= LogLevel.DEBUG: + print(message) + + +# Authentication method `api_key`. +# Api Key Authentication `api_key` +func set_security_api_key(value: String): + self.headers_base["api_key"] = value + + +# Authentication method `petstore_auth`. +# → Skipped: not implemented in the gdscript templates. (contribs welcome) + + diff --git a/samples/client/petstore/gdscript/core/DemoApiError.gd b/samples/client/petstore/gdscript/addons/oas.petstore.client/core/DemoApiError.gd similarity index 100% rename from samples/client/petstore/gdscript/core/DemoApiError.gd rename to samples/client/petstore/gdscript/addons/oas.petstore.client/core/DemoApiError.gd diff --git a/samples/client/petstore/gdscript/models/DemoApiResponse.gd b/samples/client/petstore/gdscript/addons/oas.petstore.client/models/DemoApiResponse.gd similarity index 72% rename from samples/client/petstore/gdscript/models/DemoApiResponse.gd rename to samples/client/petstore/gdscript/addons/oas.petstore.client/models/DemoApiResponse.gd index a93a1011c9ac..92c309106adf 100644 --- a/samples/client/petstore/gdscript/models/DemoApiResponse.gd +++ b/samples/client/petstore/gdscript/addons/oas.petstore.client/models/DemoApiResponse.gd @@ -1,3 +1,6 @@ +extends Resource +class_name DemoApiResponse + # THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. # For more information on how to customize templates, see: # https://openapi-generator.tech @@ -5,50 +8,39 @@ # DemoApiResponse Model # Describes the result of uploading an image resource -# namespace: models - -extends RefCounted -class_name DemoApiResponse - -# It's convenient to know the class name, for error messages. -# https://github.com/godotengine/godot/issues/21789 -var bee_class_name := "DemoApiResponse" -# Type: int # Required: False # isArray: false -var code: int: +@export var code: int: set(value): __code__was__set = true code = value var __code__was__set := false -# Type: String # Required: False # isArray: false -var type: String: +@export var type: String = "": set(value): __type__was__set = true type = value var __type__was__set := false -# Type: String # Required: False # isArray: false -var message: String: +@export var message: String = "": set(value): __message__was__set = true message = value var __message__was__set := false -func bee_collect_missing_properties() -> Array: +func bzz_collect_missing_properties() -> Array: var bzz_missing_properties := Array() return bzz_missing_properties -func bee_normalize() -> Dictionary: +func bzz_normalize() -> Dictionary: var bzz_dictionary := Dictionary() if self.__code__was__set: bzz_dictionary["code"] = self.code @@ -60,7 +52,7 @@ func bee_normalize() -> Dictionary: # Won't work for JSON+LD -static func bee_denormalize_single(from_dict: Dictionary): +static func bzz_denormalize_single(from_dict: Dictionary): var me := new() if from_dict.has("code"): me.code = from_dict["code"] @@ -72,14 +64,14 @@ static func bee_denormalize_single(from_dict: Dictionary): # Won't work for JSON+LD -static func bee_denormalize_multiple(from_array: Array): +static func bzz_denormalize_multiple(from_array: Array): var mes := Array() for element in from_array: if element is Array: - mes.append(bee_denormalize_multiple(element)) + mes.append(bzz_denormalize_multiple(element)) elif element is Dictionary: # TODO: perhaps check first if it looks like a match or an intermediate container - mes.append(bee_denormalize_single(element)) + mes.append(bzz_denormalize_single(element)) else: mes.append(element) return mes diff --git a/samples/client/petstore/gdscript/models/DemoCategory.gd b/samples/client/petstore/gdscript/addons/oas.petstore.client/models/DemoCategory.gd similarity index 68% rename from samples/client/petstore/gdscript/models/DemoCategory.gd rename to samples/client/petstore/gdscript/addons/oas.petstore.client/models/DemoCategory.gd index c8513412d8e7..c95f71ad8b21 100644 --- a/samples/client/petstore/gdscript/models/DemoCategory.gd +++ b/samples/client/petstore/gdscript/addons/oas.petstore.client/models/DemoCategory.gd @@ -1,3 +1,6 @@ +extends Resource +class_name DemoCategory + # THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. # For more information on how to customize templates, see: # https://openapi-generator.tech @@ -5,41 +8,31 @@ # DemoCategory Model # A category for a pet -# namespace: models - -extends RefCounted -class_name DemoCategory - -# It's convenient to know the class name, for error messages. -# https://github.com/godotengine/godot/issues/21789 -var bee_class_name := "DemoCategory" -# Type: float # Required: False # isArray: false -var id: float: +@export var id: float: set(value): __id__was__set = true id = value var __id__was__set := false -# Type: String # Required: False # isArray: false -var name: String: +@export var name: String = "": set(value): __name__was__set = true name = value var __name__was__set := false -func bee_collect_missing_properties() -> Array: +func bzz_collect_missing_properties() -> Array: var bzz_missing_properties := Array() return bzz_missing_properties -func bee_normalize() -> Dictionary: +func bzz_normalize() -> Dictionary: var bzz_dictionary := Dictionary() if self.__id__was__set: bzz_dictionary["id"] = self.id @@ -49,7 +42,7 @@ func bee_normalize() -> Dictionary: # Won't work for JSON+LD -static func bee_denormalize_single(from_dict: Dictionary): +static func bzz_denormalize_single(from_dict: Dictionary): var me := new() if from_dict.has("id"): me.id = from_dict["id"] @@ -59,14 +52,14 @@ static func bee_denormalize_single(from_dict: Dictionary): # Won't work for JSON+LD -static func bee_denormalize_multiple(from_array: Array): +static func bzz_denormalize_multiple(from_array: Array): var mes := Array() for element in from_array: if element is Array: - mes.append(bee_denormalize_multiple(element)) + mes.append(bzz_denormalize_multiple(element)) elif element is Dictionary: # TODO: perhaps check first if it looks like a match or an intermediate container - mes.append(bee_denormalize_single(element)) + mes.append(bzz_denormalize_single(element)) else: mes.append(element) return mes diff --git a/samples/client/petstore/gdscript/models/DemoOrder.gd b/samples/client/petstore/gdscript/addons/oas.petstore.client/models/DemoOrder.gd similarity index 74% rename from samples/client/petstore/gdscript/models/DemoOrder.gd rename to samples/client/petstore/gdscript/addons/oas.petstore.client/models/DemoOrder.gd index 62c61f4739fd..84c0f7820003 100644 --- a/samples/client/petstore/gdscript/models/DemoOrder.gd +++ b/samples/client/petstore/gdscript/addons/oas.petstore.client/models/DemoOrder.gd @@ -1,3 +1,6 @@ +extends Resource +class_name DemoOrder + # THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. # For more information on how to customize templates, see: # https://openapi-generator.tech @@ -5,62 +8,49 @@ # DemoOrder Model # An order for a pets from the pet store -# namespace: models - -extends RefCounted -class_name DemoOrder - -# It's convenient to know the class name, for error messages. -# https://github.com/godotengine/godot/issues/21789 -var bee_class_name := "DemoOrder" -# Type: float # Required: False # isArray: false -var id: float: +@export var id: float: set(value): __id__was__set = true id = value var __id__was__set := false -# Type: float # Required: False # isArray: false -var petId: float: +@export var petId: float: set(value): __petId__was__set = true petId = value var __petId__was__set := false -# Type: int # Required: False # isArray: false -var quantity: int: +@export var quantity: int: set(value): __quantity__was__set = true quantity = value var __quantity__was__set := false -# Type: DateTime -# (but it's actually a DateTime ; no generated conversion because of lack of support for timezones in Godot) +# (but it's actually a DateTime ; no timezones support in Gdscript) # Required: False # isArray: false -var shipDate: DateTime: +@export var shipDate: String: set(value): __shipDate__was__set = true shipDate = value var __shipDate__was__set := false # Order Status -# Type: String # Required: False # isArray: false # Allowed values: "placed", "approved", "delivered" -var status: String: +@export var status: String = "": set(value): if str(value) != "" and not (str(value) in __status__allowable__values): - printerr("DemoOrder: tried to set property `status` to a value that is not allowed." + + push_error("DemoOrder: tried to set property `status` to a value that is not allowed." + " Allowed values: `placed`, `approved`, `delivered`") return __status__was__set = true @@ -68,22 +58,21 @@ var status: String: var __status__was__set := false var __status__allowable__values := ["placed", "approved", "delivered"] -# Type: bool # Required: False # isArray: false -var complete: bool = false: +@export var complete: bool = false: set(value): __complete__was__set = true complete = value var __complete__was__set := false -func bee_collect_missing_properties() -> Array: +func bzz_collect_missing_properties() -> Array: var bzz_missing_properties := Array() return bzz_missing_properties -func bee_normalize() -> Dictionary: +func bzz_normalize() -> Dictionary: var bzz_dictionary := Dictionary() if self.__id__was__set: bzz_dictionary["id"] = self.id @@ -101,7 +90,7 @@ func bee_normalize() -> Dictionary: # Won't work for JSON+LD -static func bee_denormalize_single(from_dict: Dictionary): +static func bzz_denormalize_single(from_dict: Dictionary): var me := new() if from_dict.has("id"): me.id = from_dict["id"] @@ -119,14 +108,14 @@ static func bee_denormalize_single(from_dict: Dictionary): # Won't work for JSON+LD -static func bee_denormalize_multiple(from_array: Array): +static func bzz_denormalize_multiple(from_array: Array): var mes := Array() for element in from_array: if element is Array: - mes.append(bee_denormalize_multiple(element)) + mes.append(bzz_denormalize_multiple(element)) elif element is Dictionary: # TODO: perhaps check first if it looks like a match or an intermediate container - mes.append(bee_denormalize_single(element)) + mes.append(bzz_denormalize_single(element)) else: mes.append(element) return mes diff --git a/samples/client/petstore/gdscript/models/DemoPet.gd b/samples/client/petstore/gdscript/addons/oas.petstore.client/models/DemoPet.gd similarity index 75% rename from samples/client/petstore/gdscript/models/DemoPet.gd rename to samples/client/petstore/gdscript/addons/oas.petstore.client/models/DemoPet.gd index 35bf0b88b1b4..78ff6b0e1d2d 100644 --- a/samples/client/petstore/gdscript/models/DemoPet.gd +++ b/samples/client/petstore/gdscript/addons/oas.petstore.client/models/DemoPet.gd @@ -1,3 +1,6 @@ +extends Resource +class_name DemoPet + # THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. # For more information on how to customize templates, see: # https://openapi-generator.tech @@ -5,57 +8,44 @@ # DemoPet Model # A pet for sale in the pet store -# namespace: models - -extends RefCounted -class_name DemoPet - -# It's convenient to know the class name, for error messages. -# https://github.com/godotengine/godot/issues/21789 -var bee_class_name := "DemoPet" -# Type: float # Required: False # isArray: false -var id: float: +@export var id: float: set(value): __id__was__set = true id = value var __id__was__set := false -# Type: DemoCategory # Required: False # isArray: false -var category: DemoCategory: +@export var category: DemoCategory: set(value): __category__was__set = true category = value var __category__was__set := false -# Type: String # Required: True # Example: doggie # isArray: false -var name: String: +@export var name: String = "": set(value): __name__was__set = true name = value var __name__was__set := false -# Type: Array # Required: True # isArray: true -var photoUrls: Array: +@export var photoUrls: Array: set(value): __photoUrls__was__set = true photoUrls = value var __photoUrls__was__set := false -# Type: Array # Required: False # isArray: true -var tags: Array: +@export var tags: Array: set(value): __tags__was__set = true tags = value @@ -63,16 +53,15 @@ var __tags__was__set := false # /!. DEPRECATED # pet status in the store -# Type: String # Required: False # isArray: false # Allowed values: "available", "pending", "sold" -var status: String: +@export var status: String = "": set(value): if str(value) != "": push_warning("DemoPet: property `status` is deprecated.") if str(value) != "" and not (str(value) in __status__allowable__values): - printerr("DemoPet: tried to set property `status` to a value that is not allowed." + + push_error("DemoPet: tried to set property `status` to a value that is not allowed." + " Allowed values: `available`, `pending`, `sold`") return __status__was__set = true @@ -81,7 +70,7 @@ var __status__was__set := false var __status__allowable__values := ["available", "pending", "sold"] -func bee_collect_missing_properties() -> Array: +func bzz_collect_missing_properties() -> Array: var bzz_missing_properties := Array() if not self.__name__was__set: bzz_missing_properties.append("name") @@ -90,7 +79,7 @@ func bee_collect_missing_properties() -> Array: return bzz_missing_properties -func bee_normalize() -> Dictionary: +func bzz_normalize() -> Dictionary: var bzz_dictionary := Dictionary() if self.__id__was__set: bzz_dictionary["id"] = self.id @@ -108,32 +97,32 @@ func bee_normalize() -> Dictionary: # Won't work for JSON+LD -static func bee_denormalize_single(from_dict: Dictionary): +static func bzz_denormalize_single(from_dict: Dictionary): var me := new() if from_dict.has("id"): me.id = from_dict["id"] if from_dict.has("category"): - me.category = DemoCategory.bee_denormalize_single(from_dict["category"]) + me.category = DemoCategory.bzz_denormalize_single(from_dict["category"]) if from_dict.has("name"): me.name = from_dict["name"] if from_dict.has("photoUrls"): me.photoUrls = from_dict["photoUrls"] if from_dict.has("tags"): - me.tags = DemoTag.bee_denormalize_multiple(from_dict["tags"]) + me.tags = DemoTag.bzz_denormalize_multiple(from_dict["tags"]) if from_dict.has("status"): me.status = from_dict["status"] return me # Won't work for JSON+LD -static func bee_denormalize_multiple(from_array: Array): +static func bzz_denormalize_multiple(from_array: Array): var mes := Array() for element in from_array: if element is Array: - mes.append(bee_denormalize_multiple(element)) + mes.append(bzz_denormalize_multiple(element)) elif element is Dictionary: # TODO: perhaps check first if it looks like a match or an intermediate container - mes.append(bee_denormalize_single(element)) + mes.append(bzz_denormalize_single(element)) else: mes.append(element) return mes diff --git a/samples/client/petstore/gdscript/models/DemoTag.gd b/samples/client/petstore/gdscript/addons/oas.petstore.client/models/DemoTag.gd similarity index 68% rename from samples/client/petstore/gdscript/models/DemoTag.gd rename to samples/client/petstore/gdscript/addons/oas.petstore.client/models/DemoTag.gd index e0a32f715b27..6ac9ded2eac9 100644 --- a/samples/client/petstore/gdscript/models/DemoTag.gd +++ b/samples/client/petstore/gdscript/addons/oas.petstore.client/models/DemoTag.gd @@ -1,3 +1,6 @@ +extends Resource +class_name DemoTag + # THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. # For more information on how to customize templates, see: # https://openapi-generator.tech @@ -5,41 +8,31 @@ # DemoTag Model # A tag for a pet -# namespace: models - -extends RefCounted -class_name DemoTag - -# It's convenient to know the class name, for error messages. -# https://github.com/godotengine/godot/issues/21789 -var bee_class_name := "DemoTag" -# Type: float # Required: False # isArray: false -var id: float: +@export var id: float: set(value): __id__was__set = true id = value var __id__was__set := false -# Type: String # Required: False # isArray: false -var name: String: +@export var name: String = "": set(value): __name__was__set = true name = value var __name__was__set := false -func bee_collect_missing_properties() -> Array: +func bzz_collect_missing_properties() -> Array: var bzz_missing_properties := Array() return bzz_missing_properties -func bee_normalize() -> Dictionary: +func bzz_normalize() -> Dictionary: var bzz_dictionary := Dictionary() if self.__id__was__set: bzz_dictionary["id"] = self.id @@ -49,7 +42,7 @@ func bee_normalize() -> Dictionary: # Won't work for JSON+LD -static func bee_denormalize_single(from_dict: Dictionary): +static func bzz_denormalize_single(from_dict: Dictionary): var me := new() if from_dict.has("id"): me.id = from_dict["id"] @@ -59,14 +52,14 @@ static func bee_denormalize_single(from_dict: Dictionary): # Won't work for JSON+LD -static func bee_denormalize_multiple(from_array: Array): +static func bzz_denormalize_multiple(from_array: Array): var mes := Array() for element in from_array: if element is Array: - mes.append(bee_denormalize_multiple(element)) + mes.append(bzz_denormalize_multiple(element)) elif element is Dictionary: # TODO: perhaps check first if it looks like a match or an intermediate container - mes.append(bee_denormalize_single(element)) + mes.append(bzz_denormalize_single(element)) else: mes.append(element) return mes diff --git a/samples/client/petstore/gdscript/models/DemoUser.gd b/samples/client/petstore/gdscript/addons/oas.petstore.client/models/DemoUser.gd similarity index 79% rename from samples/client/petstore/gdscript/models/DemoUser.gd rename to samples/client/petstore/gdscript/addons/oas.petstore.client/models/DemoUser.gd index c46125504813..422448651960 100644 --- a/samples/client/petstore/gdscript/models/DemoUser.gd +++ b/samples/client/petstore/gdscript/addons/oas.petstore.client/models/DemoUser.gd @@ -1,3 +1,6 @@ +extends Resource +class_name DemoUser + # THIS FILE WAS AUTOMATICALLY GENERATED by the OpenAPI Generator project. # For more information on how to customize templates, see: # https://openapi-generator.tech @@ -5,96 +8,80 @@ # DemoUser Model # A User who is purchasing from the pet store -# namespace: models - -extends RefCounted -class_name DemoUser - -# It's convenient to know the class name, for error messages. -# https://github.com/godotengine/godot/issues/21789 -var bee_class_name := "DemoUser" -# Type: float # Required: False # isArray: false -var id: float: +@export var id: float: set(value): __id__was__set = true id = value var __id__was__set := false -# Type: String # Required: False # isArray: false -var username: String: +@export var username: String = "": set(value): __username__was__set = true username = value var __username__was__set := false -# Type: String # Required: False # isArray: false -var firstName: String: +@export var firstName: String = "": set(value): __firstName__was__set = true firstName = value var __firstName__was__set := false -# Type: String # Required: False # isArray: false -var lastName: String: +@export var lastName: String = "": set(value): __lastName__was__set = true lastName = value var __lastName__was__set := false -# Type: String # Required: False # isArray: false -var email: String: +@export var email: String = "": set(value): __email__was__set = true email = value var __email__was__set := false -# Type: String # Required: False # isArray: false -var password: String: +@export var password: String = "": set(value): __password__was__set = true password = value var __password__was__set := false -# Type: String # Required: False # isArray: false -var phone: String: +@export var phone: String = "": set(value): __phone__was__set = true phone = value var __phone__was__set := false # User Status -# Type: int # Required: False # isArray: false -var userStatus: int: +@export var userStatus: int: set(value): __userStatus__was__set = true userStatus = value var __userStatus__was__set := false -func bee_collect_missing_properties() -> Array: +func bzz_collect_missing_properties() -> Array: var bzz_missing_properties := Array() return bzz_missing_properties -func bee_normalize() -> Dictionary: +func bzz_normalize() -> Dictionary: var bzz_dictionary := Dictionary() if self.__id__was__set: bzz_dictionary["id"] = self.id @@ -116,7 +103,7 @@ func bee_normalize() -> Dictionary: # Won't work for JSON+LD -static func bee_denormalize_single(from_dict: Dictionary): +static func bzz_denormalize_single(from_dict: Dictionary): var me := new() if from_dict.has("id"): me.id = from_dict["id"] @@ -138,14 +125,14 @@ static func bee_denormalize_single(from_dict: Dictionary): # Won't work for JSON+LD -static func bee_denormalize_multiple(from_array: Array): +static func bzz_denormalize_multiple(from_array: Array): var mes := Array() for element in from_array: if element is Array: - mes.append(bee_denormalize_multiple(element)) + mes.append(bzz_denormalize_multiple(element)) elif element is Dictionary: # TODO: perhaps check first if it looks like a match or an intermediate container - mes.append(bee_denormalize_single(element)) + mes.append(bzz_denormalize_single(element)) else: mes.append(element) return mes diff --git a/samples/client/petstore/gdscript/core/DemoApiBee.gd b/samples/client/petstore/gdscript/core/DemoApiBee.gd deleted file mode 100644 index ba773750e44e..000000000000 --- a/samples/client/petstore/gdscript/core/DemoApiBee.gd +++ /dev/null @@ -1,406 +0,0 @@ -extends RefCounted -class_name DemoApiBee - -# Base class for all generated API endpoints. -# -# Every property/method defined here may collide with userland, -# so these are all listed and excluded in our CodeGen Java file. -# We want to keep the amount of renaming to a minimum, though. -# Therefore, we use the bee_ prefix, even if awkward. - - -const BEE_CONTENT_TYPE_TEXT := "text/plain" -const BEE_CONTENT_TYPE_HTML := "text/html" -const BEE_CONTENT_TYPE_JSON := "application/json" -const BEE_CONTENT_TYPE_FORM := "application/x-www-form-urlencoded" -const BEE_CONTENT_TYPE_JSONLD := "application/json+ld" # unsupported (for now) -const BEE_CONTENT_TYPE_XML := "application/xml" # unsupported (for now) - -# From this client's point of view. -# Adding a content type here won't magically make the client support it, but you may reorder. -# These are sorted by decreasing preference. (first → preferred) -const BEE_PRODUCIBLE_CONTENT_TYPES := [ - BEE_CONTENT_TYPE_JSON, - BEE_CONTENT_TYPE_FORM, -] - -# From this client's point of view. -# Adding a content type here won't magically make the client support it, but you may reorder. -# These are sorted by decreasing preference. (first → preferred) -const BEE_CONSUMABLE_CONTENT_TYPES := [ - BEE_CONTENT_TYPE_JSON, -] - - -# We'll probably only use this for logging. -# Each Api child can define its own, and it should be similar to class_name. -var bee_name := "ApiBee" - - -# Godot's HTTP Client this Api instance is using. -# If none was set (by you), we'll lazily make one. -var bee_client: HTTPClient: - set(value): - bee_client = value - get: - if not bee_client: - bee_client = HTTPClient.new() - return bee_client - - -# General configuration that can be shared across Api instances for convenience. -# If no configuration was provided, we'll lazily make one with defaults as best we can. -var bee_config: DemoApiConfig: - set(value): - bee_config = value - # TODO: renew client (needs to invalidate on config's property change as well) - get: - if not bee_config: - bee_config = DemoApiConfig.new() - return bee_config - - -func bee_next_loop_iteration(): - # I can't find `idle_frame` in 4-beta3, but we probably want idle_frame here - return Engine.get_main_loop().process_frame - - -func bee_connect_client_if_needed( - on_success: Callable, # func() - on_failure: Callable, # func(error: DemoApiError) - #finally: Callable, -): - if ( - self.bee_client.get_status() == HTTPClient.STATUS_CONNECTED - or - self.bee_client.get_status() == HTTPClient.STATUS_RESOLVING - or - self.bee_client.get_status() == HTTPClient.STATUS_CONNECTING - or - self.bee_client.get_status() == HTTPClient.STATUS_REQUESTING - or - self.bee_client.get_status() == HTTPClient.STATUS_BODY - ): - on_success.call() - - var connecting := self.bee_client.connect_to_host( - self.bee_config.host, self.bee_config.port, - self.bee_config.ssl_enabled, self.bee_config.verify_host - ) - if connecting != OK: - var error := DemoApiError.new() - error.internal_code = connecting - error.identifier = "apibee.connect_to_host.failure" - error.message = "%s: failed to connect to `%s' port %d with error %d" % [ - self.bee_name, self.bee_config.host, self.bee_config.port, connecting - ] - on_failure.call(error) - return - - # Wait until resolved and connected. - while ( - self.bee_client.get_status() == HTTPClient.STATUS_CONNECTING - or - self.bee_client.get_status() == HTTPClient.STATUS_RESOLVING - ): - self.bee_client.poll() - print("Connecting...") - if self.bee_config.polling_interval_ms: - OS.delay_msec(self.bee_config.polling_interval_ms) - await bee_next_loop_iteration() - - if self.bee_client.get_status() != HTTPClient.STATUS_CONNECTED: - var error := DemoApiError.new() - error.internal_code = connecting - error.identifier = "apibee.connect_to_host.wrong_status" - error.message = "%s: failed to connect to `%s' port %d, with client status %d" % [ - self.bee_name, self.bee_config.host, self.bee_config.port, self.bee_client.get_status() - ] - on_failure.call(error) - return - - on_success.call() - - -# @protected -func bee_request( - method: int, # one of HTTPClient.METHOD_XXXXX - path: String, - headers: Dictionary, - query: Dictionary, - body, # Variant that will be serialized - on_success: Callable, # func(response: Variant, responseCode: int, responseHeaders: Dictionary) - on_failure: Callable, # func(error: DemoApiError) -): - - bee_request_text( - method, path, headers, query, body, - func(responseText, responseCode, responseHeaders): - var mime: String = responseHeaders['Mime'] - var deserializedResponse # Variant - var denormalizedResponse # Variant - - if BEE_CONTENT_TYPE_TEXT == mime: - deserializedResponse = responseText - elif BEE_CONTENT_TYPE_HTML == mime: - deserializedResponse = responseText - elif BEE_CONTENT_TYPE_JSON == mime: - var parser := JSON.new() - var parsing := parser.parse(responseText) - if OK != parsing: - var error := DemoApiError.new() - error.internal_code = parsing - error.identifier = "apibee.deserialize.cannot_parse_json" - error.message = "%s: failed to parse JSON at line %d.\n%s" % [ - self.bee_name, parser.get_error_line(), parser.get_error_message() - ] - on_failure.call(error) - return - deserializedResponse = parser.data - else: - var error := DemoApiError.new() - error.internal_code = ERR_INVALID_DATA - error.identifier = "apibee.deserialize.mime_type_unsupported" - error.message = "%s: mime type `%s' is not supported (yet)" % [ - self.bee_name, mime - ] - on_failure.call(error) - return - - denormalizedResponse = deserializedResponse # FIXME - - on_success.call(denormalizedResponse, responseCode, responseHeaders) - , - func(error): - on_failure.call(error) - , - ) - - -# @protected -func bee_request_text( - method: int, # one of HTTPClient.METHOD_XXXXX - path: String, - headers: Dictionary, - query: Dictionary, - body, # Variant that will be serialized - on_success: Callable, # func(responseText: String, responseCode: int, responseHeaders: Dictionary) - on_failure: Callable, # func(error: DemoApiError) -): - bee_connect_client_if_needed( - func(): - bee_do_request_text(method, path, headers, query, body, on_success, on_failure) - , - func(error): - on_failure.call(error) - , - ) - - -# @protected -func bee_do_request_text( - method: int, # one of HTTPClient.METHOD_XXXXX - path: String, - headers: Dictionary, - query: Dictionary, - body, # Variant that will be serialized - on_success: Callable, # func(responseText: String, responseCode: int, responseHeaders: Dictionary) - on_failure: Callable, # func(error: DemoApiError) -): - - headers = headers.duplicate(true) - headers.merge(self.bee_config.headers_base) - headers.merge(self.bee_config.headers_override, true) - - var body_normalized = body - if body is Object: - if body.has_method('bee_collect_missing_properties'): - var missing_properties : Array = body.bee_collect_missing_properties() - if missing_properties: - var error := DemoApiError.new() - error.identifier = "apibee.request.body.missing_properties" - error.message = "%s: `%s' is missing required properties %s." % [ - self.bee_name, body.bee_class_name, missing_properties - ] - on_failure.call(error) - return - if body.has_method('bee_normalize'): - body_normalized = body.bee_normalize() - - var body_serialized := "" - var content_type := self.bee_get_content_type(headers) - if content_type == BEE_CONTENT_TYPE_JSON: - body_serialized = JSON.stringify(body_normalized) - elif content_type == BEE_CONTENT_TYPE_FORM: - body_serialized = self.bee_client.query_string_from_dict(body_normalized) - else: - # TODO: Handle other serialization schemes (json+ld, xml…) - push_warning("Unsupported content-type `%s`." % content_type) - - var path_queried := path - var query_string := self.bee_client.query_string_from_dict(query) - if query_string: - path_queried = "%s?%s" % [path, query_string] - - var headers_for_godot := Array() # of String - for key in headers: - headers_for_godot.append("%s: %s" % [key, headers[key]]) - - var requesting := self.bee_client.request(method, path_queried, headers_for_godot, body_serialized) - if requesting != OK: - var error := DemoApiError.new() - error.internal_code = requesting - error.identifier = "apibee.request.failure" - error.message = "%s: failed to request to path `%s'." % [ - self.bee_name, path - ] - on_failure.call(error) - return - - while self.bee_client.get_status() == HTTPClient.STATUS_REQUESTING: - # Keep polling for as long as the request is being processed. - self.bee_client.poll() - print("Requesting...") - if self.bee_config.polling_interval_ms: - OS.delay_msec(self.bee_config.polling_interval_ms) - await bee_next_loop_iteration() -# if OS.has_feature("web") or async: - - if not self.bee_client.has_response(): - var error := DemoApiError.new() - error.identifier = "apibee.request.no_response" - error.message = "%s: request to `%s' yielded no response whatsoever." % [ - self.bee_name, path - ] - on_failure.call(error) - return - - var response_code := self.bee_client.get_response_code() - var response_headers := self.bee_client.get_response_headers_as_dictionary() - # FIXME: extract from headers "Content-Type": "application/json; charset=utf-8" - # This begs for a HttpResponse class ; wait for Godot? - var encoding := "utf-8" - var mime := "application/json" - response_headers['Encoding'] = encoding - response_headers['Mime'] = mime - - # TODO: cap the size of this, perhaps? - var response_bytes := PackedByteArray() - - while self.bee_client.get_status() == HTTPClient.STATUS_BODY: - self.bee_client.poll() - var chunk = self.bee_client.read_response_body_chunk() - if chunk.size() == 0: # Got nothing, wait for buffers to fill a bit. - if self.bee_config.polling_interval_ms: - OS.delay_usec(self.bee_config.polling_interval_ms) - await bee_next_loop_iteration() - else: # Yummy data has arrived - response_bytes = response_bytes + chunk - - print("REQUEST %s %s" % [method, path_queried]) - print("Headers: %s" % [str(headers)]) - prints(body_serialized) - - prints("RESPONSE CODE:", response_code) - prints("RESPONSE HEADERS:", response_headers) - print("RESPONSE SIZE: %d bytes " % response_bytes.size()) - - var response_text: String - if encoding == "utf-8": - response_text = response_bytes.get_string_from_utf8() - elif encoding == "utf-16": - response_text = response_bytes.get_string_from_utf16() - elif encoding == "utf-32": - response_text = response_bytes.get_string_from_utf32() - else: - response_text = response_bytes.get_string_from_ascii() - - if response_code >= 500: - var error := DemoApiError.new() - error.internal_code = ERR_PRINTER_ON_FIRE - error.identifier = "apibee.response.5xx" - error.message = "%s: request to `%s' made the server hiccup with a %d." % [ - self.bee_name, path, response_code - ] - error.message += "\n%s" % [ - bee_format_error_response(response_text) - ] - on_failure.call(error) - return - elif response_code >= 400: - var error := DemoApiError.new() - error.identifier = "apibee.response.4xx" - error.message = "%s: request to `%s' was denied with a %d." % [ - self.bee_name, path, response_code - ] - error.message += "\n%s" % [ - bee_format_error_response(response_text) - ] - on_failure.call(error) - return - elif response_code >= 300: - var error := DemoApiError.new() - error.identifier = "apibee.response.3xx" - error.message = "%s: request to `%s' was redirected with a %d. We do not support redirects in that client yet." % [ - self.bee_name, path, response_code - ] - on_failure.call(error) - return - - # Should we close ? - #self.bee_client.close() - - on_success.call(response_text, response_code, response_headers) - - -func bee_convert_http_method(method: String) -> int: - match method: - 'GET': return HTTPClient.METHOD_GET - 'POST': return HTTPClient.METHOD_POST - 'PUT': return HTTPClient.METHOD_PUT - 'PATCH': return HTTPClient.METHOD_PATCH - 'DELETE': return HTTPClient.METHOD_DELETE - 'CONNECT': return HTTPClient.METHOD_CONNECT - 'HEAD': return HTTPClient.METHOD_HEAD - 'MAX': return HTTPClient.METHOD_MAX - 'OPTIONS': return HTTPClient.METHOD_OPTIONS - 'TRACE': return HTTPClient.METHOD_TRACE - _: - printerr("%s: unknown http method `%s`, assuming GET." % [ - self.bee_name, method - ]) - return HTTPClient.METHOD_GET - - -func bee_urlize_path_param(anything) -> String: - var serialized := bee_escape_path_param(str(anything)) - return serialized - - -func bee_escape_path_param(value: String) -> String: - # TODO: escape for URL - return value - - -func bee_get_content_type(headers: Dictionary) -> String: - if headers.has("Content-Type"): - return headers["Content-Type"] - return BEE_PRODUCIBLE_CONTENT_TYPES[0] - - -func bee_format_error_response(response: String) -> String: - # TODO: handle other (de)serialization schemes - var parser := JSON.new() - var parsing := parser.parse(response) - if OK != parsing: - return response - if not (parser.data is Dictionary): - return response - var s := "ERROR" - if parser.data.has("code"): - s += " %d" % parser.data['code'] - if parser.data.has("message"): - s += "\n%s" % parser.data['message'] - else: - return response - return s diff --git a/samples/client/petstore/gdscript/core/DemoApiConfig.gd b/samples/client/petstore/gdscript/core/DemoApiConfig.gd deleted file mode 100644 index 590a96c51a30..000000000000 --- a/samples/client/petstore/gdscript/core/DemoApiConfig.gd +++ /dev/null @@ -1,69 +0,0 @@ -extends Resource -class_name DemoApiConfig - -# Configuration options for Api endpoints. -# -# Its purpose is to help you share configuration customizations across Apis. -# Since it is a Resource, you may use `ResourceSaver.save()` and `load()` -# to save it and load it from file, if you want. -# -# Not sure if this should hold the HTTPClient instance or not. Not for now. - -# These are constant, immutable default values. -# To set different values at runtime, use the public properties below. -const BEE_DEFAULT_HOST := "petstore.swagger.io" -const BEE_DEFAULT_PORT_HTTP := 80 -const BEE_DEFAULT_PORT_HTTPS := 443 -const BEE_DEFAULT_POLLING_INTERVAL_MS := 500 # milliseconds - - -# The host to connect to, with or without the protocol scheme. -# Eg: "gitea.com", "https://gitea.com" -# We toggle TLS accordingly to the provided scheme, if any. -var host := BEE_DEFAULT_HOST: - set(value): - if value.begins_with("https://"): - ssl_enabled = true - value = value.substr(8) # "https://".length() == 8 - elif value.begins_with("http://"): - ssl_enabled = false - value = value.substr(7) # "http://".length() == 7 - host = value - - -# Port through which the connection will be established. -# Note: changing the host may change the port as well if the scheme was provided, see above. -var port := BEE_DEFAULT_PORT_HTTP - - -# Headers used as base for all requests made by Api instances using this config. -# Those are the lowest priority headers, and are merged with custom headers provided in the bee_request() method call -# as well as the headers override below, to compute the final, actually sent headers. -var headers_base := { - # Stigmergy: everyone does what is left to do (like ants do) - "User-Agent": "Stigmergiac/1.0 (Godot)", - # For my mental health's sake, only JSON is supported for now - "Accept": "application/json", - "Content-Type": "application/json", - # FIXME: Remove demo cheat code - "api_key": "special-key", -} - - -# High-priority headers, they will always override other headers coming from the base above or the method call. -var headers_override := {} - - -# Duration of sleep between poll() calls. -var polling_interval_ms := BEE_DEFAULT_POLLING_INTERVAL_MS # milliseconds - - -# Should we encrypt packets ? Yes. Let's encrypt ! -var ssl_enabled := false: - set(value): - ssl_enabled = value - port = BEE_DEFAULT_PORT_HTTPS if ssl_enabled else BEE_DEFAULT_PORT_HTTP - - -var verify_host := true # only used if ssl is enabled, disable if trouble - diff --git a/samples/client/petstore/gdscript/demo/main.gd b/samples/client/petstore/gdscript/demo/main.gd index 7015162a94b2..6354e3dd1aea 100644 --- a/samples/client/petstore/gdscript/demo/main.gd +++ b/samples/client/petstore/gdscript/demo/main.gd @@ -6,6 +6,7 @@ signal test_ended @onready var log_text_edit := $HBoxContainer/LogDump +var cfg := DemoApiConfig.new() var failed := false @@ -36,7 +37,7 @@ func is_headless() -> bool: # I have no shame, and no other idea how to detect --headless #print(OS.get_cmdline_args()) # empty #print(OS.get_cmdline_user_args()) # empty - #print(OS.get_environment("HEADLESS")) # works, but cumbersome + #print(OS.get_environment("HEADLESS")) # would work, but cumbersome return "" == RenderingServer.get_video_adapter_name() @@ -47,12 +48,13 @@ func fail(msg: String): gtfo(1) -var cfg := DemoApiConfig.new() +func configure(): + cfg.port = 8081 + cfg.headers_base['api_key'] = "special-key" func run_all_tests(on_done := Callable()): - cfg.port = 8081 - cfg.headers_base['api_key'] = "special-key" + configure() log_text_edit.text = "" var started_at := Time.get_ticks_msec() @@ -73,13 +75,11 @@ func run_all_tests(on_done := Callable()): func run_test_01(): Logger.inform("Running test 01…") - var rick := DemoUser.new() rick.username = "Rick" rick.password = "ytrom&" - var user_api := DemoUserApi.new() - user_api.bee_config = cfg + var user_api := DemoUserApi.new(cfg) user_api.create_user( rick, func(result): @@ -106,8 +106,7 @@ func run_test_01(): func authenticate(username: String, password: String, on_done: Callable): - var user_api := DemoUserApi.new() - user_api.bee_config = cfg + var user_api := DemoUserApi.new(cfg) user_api.login_user( username, password, func(result): @@ -130,8 +129,7 @@ func add_monkey(on_done: Callable): monkey.status = "shenaniganing" #monkey.tags = ['tree', 'fur'] - var pet_api := DemoPetApi.new() - pet_api.bee_config = cfg + var pet_api := DemoPetApi.new(cfg) pet_api.add_pet( monkey, func(result): @@ -154,8 +152,7 @@ func add_monkey(on_done: Callable): func update_monkey(monkey, new_name, on_done: Callable): - var pet_api := DemoPetApi.new() - pet_api.bee_config = cfg + var pet_api := DemoPetApi.new(cfg) pet_api.update_pet_with_form( monkey.id, new_name, "available", func(result): @@ -179,8 +176,7 @@ func update_monkey(monkey, new_name, on_done: Callable): func run_test_02(): Logger.inform("Running test 02…") - var pet_api := DemoPetApi.new() - pet_api.bee_config = cfg + var pet_api := DemoPetApi.new(cfg) pet_api.find_pets_by_status( ['available'], func(result): diff --git a/samples/client/petstore/gdscript/demo/main.tscn b/samples/client/petstore/gdscript/demo/main.tscn index e2dbb73e9684..797cca917571 100644 --- a/samples/client/petstore/gdscript/demo/main.tscn +++ b/samples/client/petstore/gdscript/demo/main.tscn @@ -27,31 +27,19 @@ grow_vertical = 2 [node name="VBoxContainer" type="VBoxContainer" parent="HBoxContainer"] layout_mode = 2 -offset_right = 100.0 -offset_bottom = 648.0 [node name="RunTestsButton" type="Button" parent="HBoxContainer/VBoxContainer"] layout_mode = 2 -offset_right = 100.0 -offset_bottom = 322.0 size_flags_vertical = 3 text = " Run Tests " [node name="ExitButton" type="Button" parent="HBoxContainer/VBoxContainer"] layout_mode = 2 -offset_top = 326.0 -offset_right = 100.0 -offset_bottom = 648.0 size_flags_vertical = 3 text = " Exit " [node name="LogDump" type="TextEdit" parent="HBoxContainer"] layout_mode = 2 -offset_left = 104.0 -offset_right = 1152.0 -offset_bottom = 648.0 -grow_horizontal = 2 -grow_vertical = 2 size_flags_horizontal = 3 editable = false virtual_keyboard_enabled = false diff --git a/samples/client/petstore/gdscript/icon.svg b/samples/client/petstore/gdscript/icon.svg index adc26df6c2cd..1699dd1a5ddd 100644 --- a/samples/client/petstore/gdscript/icon.svg +++ b/samples/client/petstore/gdscript/icon.svg @@ -1 +1,119 @@ - + + + + + + + + + + + + + + + + + + + + + + diff --git a/samples/client/petstore/gdscript/project.godot b/samples/client/petstore/gdscript/project.godot index 6101e9b51455..d54fb3ad9672 100644 --- a/samples/client/petstore/gdscript/project.godot +++ b/samples/client/petstore/gdscript/project.godot @@ -8,82 +8,6 @@ config_version=5 -_global_script_classes=[{ -"base": "RefCounted", -"class": &"DemoApiBee", -"language": &"GDScript", -"path": "res://core/DemoApiBee.gd" -}, { -"base": "Resource", -"class": &"DemoApiConfig", -"language": &"GDScript", -"path": "res://core/DemoApiConfig.gd" -}, { -"base": "Resource", -"class": &"DemoApiError", -"language": &"GDScript", -"path": "res://core/DemoApiError.gd" -}, { -"base": "RefCounted", -"class": &"DemoApiResponse", -"language": &"GDScript", -"path": "res://models/DemoApiResponse.gd" -}, { -"base": "RefCounted", -"class": &"DemoCategory", -"language": &"GDScript", -"path": "res://models/DemoCategory.gd" -}, { -"base": "RefCounted", -"class": &"DemoOrder", -"language": &"GDScript", -"path": "res://models/DemoOrder.gd" -}, { -"base": "RefCounted", -"class": &"DemoPet", -"language": &"GDScript", -"path": "res://models/DemoPet.gd" -}, { -"base": "DemoApiBee", -"class": &"DemoPetApi", -"language": &"GDScript", -"path": "res://apis/DemoPetApi.gd" -}, { -"base": "DemoApiBee", -"class": &"DemoStoreApi", -"language": &"GDScript", -"path": "res://apis/DemoStoreApi.gd" -}, { -"base": "RefCounted", -"class": &"DemoTag", -"language": &"GDScript", -"path": "res://models/DemoTag.gd" -}, { -"base": "RefCounted", -"class": &"DemoUser", -"language": &"GDScript", -"path": "res://models/DemoUser.gd" -}, { -"base": "DemoApiBee", -"class": &"DemoUserApi", -"language": &"GDScript", -"path": "res://apis/DemoUserApi.gd" -}] -_global_script_class_icons={ -"DemoApiBee": "", -"DemoApiConfig": "", -"DemoApiError": "", -"DemoApiResponse": "", -"DemoCategory": "", -"DemoOrder": "", -"DemoPet": "", -"DemoPetApi": "", -"DemoStoreApi": "", -"DemoTag": "", -"DemoUser": "", -"DemoUserApi": "" -} - [application] config/name="GDScript Petstore Client" From 206cef9d3511a6cea99449b2f933b77f3a15a8eb Mon Sep 17 00:00:00 2001 From: Goutte Date: Fri, 14 Apr 2023 19:38:56 +0200 Subject: [PATCH 41/56] docs(gdscript): document petstore server ADR --- bin/configs/gdscript-petstore.yaml | 15 +++++++++++++++ .../codegen/languages/GdscriptClientCodegen.java | 12 +++++------- samples/client/petstore/gdscript/README.md | 14 ++++++++++++++ .../.openapi-generator/VERSION | 2 +- .../gdscript/addons/oas.petstore.client/README.md | 14 +++++++------- .../addons/oas.petstore.client/apis/DemoPetApi.md | 4 ++-- .../oas.petstore.client/apis/DemoStoreApi.md | 4 ++-- .../oas.petstore.client/apis/DemoUserApi.md | 4 ++-- .../oas.petstore.client/core/DemoApiConfig.gd | 8 ++++---- 9 files changed, 52 insertions(+), 25 deletions(-) diff --git a/bin/configs/gdscript-petstore.yaml b/bin/configs/gdscript-petstore.yaml index 02f3aa82940e..5025bb6687a7 100644 --- a/bin/configs/gdscript-petstore.yaml +++ b/bin/configs/gdscript-petstore.yaml @@ -2,18 +2,33 @@ # bin/generate-samples.sh bin/configs/gdscript-petstore.yaml generatorName: gdscript + +# We output straight into an addon directory. (any addon name will work) +# The addon need not be enabled in Project Settings to be used, for now, +# but that may change, so as best practice you should enable it anyway. outputDir: samples/client/petstore/gdscript/addons/oas.petstore.client + # We have two test servers available. # See https://github.com/OpenAPITools/openapi-generator/wiki/Integration-Tests + # A: Newer, recommended echo server OAS, that we're failing for now: # Exception: Could not process model 'Bird'. Please make sure that your schema is correct! # Caused by: java.lang.RuntimeException: reserved word color not allowed +# Perhaps try this again later, using another config file like gdscript-echo.yaml #inputSpec: modules/openapi-generator/src/test/resources/3_0/echo_api.yaml + # B: Older (legacy, deprecated) petstore server OAS inputSpec: modules/openapi-generator/src/test/resources/3_0/petstore.yaml + templateDir: modules/openapi-generator/src/main/resources/gdscript + additionalProperties: + # Timestamping the generated sample project would only add noise to git hideGenerationTimestamp: "true" + # Since we're polluting the global namespace with class_name (it's really convenient), + # we can use these prefixes to namespace the generated classes. + # Best make sure the words you use here are not part of the domain of Godot. + # It's a bit cumbersome to have to add all three (idea: globalNamePrefix as sugar?) apiNamePrefix: Demo modelNamePrefix: Demo coreNamePrefix: Demo \ No newline at end of file diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java index 71c869a691b0..8832c0a0e1bb 100644 --- a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java +++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GdscriptClientCodegen.java @@ -281,7 +281,7 @@ public String modelDocFileFolder() { @Override public String escapeUnsafeCharacters(String input) { // There might be ways to inject code in Gdscript, but I don't see any for now. (no /* */ comments) - // TODO: review this with someone knowledgeable + // TODO: review this can of worms with someone knowledgeable return input; } @@ -377,14 +377,12 @@ public Map updateAllModels(Map objs) { protected List getReservedWords() { return Arrays.asList( - // Local properties used in Model classes - "bee_class_name", // Local method names used in base API class - "bee_connect_client_if_needed", "bee_request", "_bee_request_text", "_bee_do_request_text", - "_bee_convert_http_method", "_bee_urlize_path_param", "_bee_escape_path_param", - "_bee_next_loop_iteration", "_bee_get_content_type", "_bee_format_error_response", + "_bzz_connect_client_if_needed", "bzz_request", "_bzz_request_text", "_bzz_do_request_text", + "_bzz_convert_http_method", "_bzz_urlize_path_param", "_bzz_escape_path_param", + "_bzz_next_loop_iteration", "_bzz_get_content_type", "_bzz_format_error_response", // Local properties used in base API class - "bee_config", "bee_client", "bee_name", + "_bzz_config", "_bzz_client", "_bzz_name", // Local variable names used in API methods (endpoints) "bzz_method", "bzz_path", "bzz_query", "bzz_result", "bzz_code", "bzz_headers", diff --git a/samples/client/petstore/gdscript/README.md b/samples/client/petstore/gdscript/README.md index 9adaba961af3..ec821c0c982a 100644 --- a/samples/client/petstore/gdscript/README.md +++ b/samples/client/petstore/gdscript/README.md @@ -7,10 +7,24 @@ - Returns non-zero exit code upon test failure - Uses [GUT] as test engine + +## Prepare the test server + +See https://github.com/OpenAPITools/openapi-generator/wiki/Integration-Tests + +> We are using the petstore docker, not the echo server for now. +> Feel free to refactor or duplicate the sample demo to use the new echo server. +> See `bin/configs/gdscript-petstore.yaml`. + + ## Run godot --headless samples/client/petstore/gdscript +The command should return a zero exit code if all tests passed. +You may want to add `--verbose` for more logs when debugging. + + ## Update Refresh the generated files, after modifying the gdscript templates or java generator: diff --git a/samples/client/petstore/gdscript/addons/oas.petstore.client/.openapi-generator/VERSION b/samples/client/petstore/gdscript/addons/oas.petstore.client/.openapi-generator/VERSION index ed829dbcddec..ba8a874deab9 100644 --- a/samples/client/petstore/gdscript/addons/oas.petstore.client/.openapi-generator/VERSION +++ b/samples/client/petstore/gdscript/addons/oas.petstore.client/.openapi-generator/VERSION @@ -1 +1 @@ -6.2.1-SNAPSHOT \ No newline at end of file +6.6.0-SNAPSHOT \ No newline at end of file diff --git a/samples/client/petstore/gdscript/addons/oas.petstore.client/README.md b/samples/client/petstore/gdscript/addons/oas.petstore.client/README.md index 9c453fc19bfa..f471b4f90664 100644 --- a/samples/client/petstore/gdscript/addons/oas.petstore.client/README.md +++ b/samples/client/petstore/gdscript/addons/oas.petstore.client/README.md @@ -100,13 +100,6 @@ Class | Method | HTTP request | Description ## Documentation For Authorization -## api_key - -- **Type**: API key -- **API key parameter name**: api_key -- **Location**: HTTP header - - Authentication schemes defined for the API: ## petstore_auth - **Type**: OAuth @@ -116,6 +109,13 @@ Class | Method | HTTP request | Description - **write:pets**: modify pets in your account - **read:pets**: read your pets + Authentication schemes defined for the API: +## api_key + +- **Type**: API key +- **API key parameter name**: api_key +- **Location**: HTTP header + ## Troubleshooting diff --git a/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoPetApi.md b/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoPetApi.md index 521184b9603a..272f9d6a9e09 100644 --- a/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoPetApi.md +++ b/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoPetApi.md @@ -405,8 +405,8 @@ api.upload_file( ### Authorization -[api_key](../README.md#api_key), -[petstore_auth](../README.md#petstore_auth) +[petstore_auth](../README.md#petstore_auth), +[api_key](../README.md#api_key) [[Back to top]](#__pageTop) \ [[Back to API list]](../README.md#documentation-for-api-endpoints) \ diff --git a/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoStoreApi.md b/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoStoreApi.md index 0bd1b8910e8f..9492ca64ed73 100644 --- a/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoStoreApi.md +++ b/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoStoreApi.md @@ -194,8 +194,8 @@ api.place_order( ### Authorization -[api_key](../README.md#api_key), -[petstore_auth](../README.md#petstore_auth) +[petstore_auth](../README.md#petstore_auth), +[api_key](../README.md#api_key) [[Back to top]](#__pageTop) \ [[Back to API list]](../README.md#documentation-for-api-endpoints) \ diff --git a/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoUserApi.md b/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoUserApi.md index 1db61300b06a..95f6ae490ee5 100644 --- a/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoUserApi.md +++ b/samples/client/petstore/gdscript/addons/oas.petstore.client/apis/DemoUserApi.md @@ -391,8 +391,8 @@ api.update_user( ### Authorization -[api_key](../README.md#api_key), -[petstore_auth](../README.md#petstore_auth) +[petstore_auth](../README.md#petstore_auth), +[api_key](../README.md#api_key) [[Back to top]](#__pageTop) \ [[Back to API list]](../README.md#documentation-for-api-endpoints) \ diff --git a/samples/client/petstore/gdscript/addons/oas.petstore.client/core/DemoApiConfig.gd b/samples/client/petstore/gdscript/addons/oas.petstore.client/core/DemoApiConfig.gd index 9e6b79b0dc04..be0ab1c9526b 100644 --- a/samples/client/petstore/gdscript/addons/oas.petstore.client/core/DemoApiConfig.gd +++ b/samples/client/petstore/gdscript/addons/oas.petstore.client/core/DemoApiConfig.gd @@ -130,13 +130,13 @@ func log_debug(message: String): print(message) +# Authentication method `petstore_auth`. +# → Skipped: not implemented in the gdscript templates. (contribs welcome) + + # Authentication method `api_key`. # Api Key Authentication `api_key` func set_security_api_key(value: String): self.headers_base["api_key"] = value -# Authentication method `petstore_auth`. -# → Skipped: not implemented in the gdscript templates. (contribs welcome) - - From a0b1e4d6da309b4eaf5c9af324d8498981f00691 Mon Sep 17 00:00:00 2001 From: Goutte Date: Sat, 15 Apr 2023 00:47:35 +0200 Subject: [PATCH 42/56] test(gdscript): add GUT and an integration test We used the latest stable GUT, but a feature we're going to need was merged today, so we'll need to update it either to master or to the next release at some point. --- .../src/main/resources/gdscript/README.md | 6 +- .../petstore/gdscript/.gut_editor_config.json | 42 + .../gdscript/.gut_editor_shortcuts.cfg | 17 + .../client/petstore/gdscript/.gutconfig.json | 32 + samples/client/petstore/gdscript/README.md | 2 +- .../petstore/gdscript/addons/gut/GutScene.gd | 124 ++ .../gdscript/addons/gut/GutScene.tscn | 16 + .../petstore/gdscript/addons/gut/LICENSE.md | 22 + .../gdscript/addons/gut/UserFileViewer.gd | 52 + .../gdscript/addons/gut/UserFileViewer.tscn | 92 + .../petstore/gdscript/addons/gut/autofree.gd | 59 + .../petstore/gdscript/addons/gut/awaiter.gd | 67 + .../gdscript/addons/gut/comparator.gd | 123 ++ .../gdscript/addons/gut/compare_result.gd | 70 + .../gdscript/addons/gut/diff_formatter.gd | 64 + .../petstore/gdscript/addons/gut/diff_tool.gd | 158 ++ .../double_templates/function_template.txt | 6 + .../gut/double_templates/init_template.txt | 4 + .../gut/double_templates/script_template.txt | 31 + .../gdscript/addons/gut/double_tools.gd | 52 + .../petstore/gdscript/addons/gut/doubler.gd | 321 ++++ .../addons/gut/fonts/AnonymousPro-Bold.ttf | Bin 0 -> 107624 bytes .../gut/fonts/AnonymousPro-BoldItalic.ttf | Bin 0 -> 95872 bytes .../addons/gut/fonts/AnonymousPro-Italic.ttf | Bin 0 -> 98424 bytes .../addons/gut/fonts/AnonymousPro-Regular.ttf | Bin 0 -> 112072 bytes .../addons/gut/fonts/CourierPrime-Bold.ttf | Bin 0 -> 69768 bytes .../gut/fonts/CourierPrime-BoldItalic.ttf | Bin 0 -> 77384 bytes .../addons/gut/fonts/CourierPrime-Italic.ttf | Bin 0 -> 76496 bytes .../addons/gut/fonts/CourierPrime-Regular.ttf | Bin 0 -> 68128 bytes .../addons/gut/fonts/LobsterTwo-Bold.ttf | Bin 0 -> 222040 bytes .../gut/fonts/LobsterTwo-BoldItalic.ttf | Bin 0 -> 216036 bytes .../addons/gut/fonts/LobsterTwo-Italic.ttf | Bin 0 -> 229404 bytes .../addons/gut/fonts/LobsterTwo-Regular.ttf | Bin 0 -> 234956 bytes .../gdscript/addons/gut/fonts/OFL.txt | 94 + .../addons/gut/gui/BottomPanelShortcuts.gd | 82 + .../addons/gut/gui/BottomPanelShortcuts.tscn | 150 ++ .../gdscript/addons/gut/gui/GutBottomPanel.gd | 367 ++++ .../addons/gut/gui/GutBottomPanel.tscn | 249 +++ .../gdscript/addons/gut/gui/GutRunner.gd | 121 ++ .../gdscript/addons/gut/gui/GutRunner.tscn | 12 + .../addons/gut/gui/GutSceneTheme.tres | 505 ++++++ .../gdscript/addons/gut/gui/MinGui.tscn | 161 ++ .../gdscript/addons/gut/gui/NormalGui.tscn | 216 +++ .../gdscript/addons/gut/gui/OutputText.gd | 341 ++++ .../gdscript/addons/gut/gui/OutputText.tscn | 114 ++ .../gdscript/addons/gut/gui/ResizeHandle.gd | 108 ++ .../gdscript/addons/gut/gui/ResizeHandle.tscn | 8 + .../gdscript/addons/gut/gui/ResultsTree.gd | 348 ++++ .../gdscript/addons/gut/gui/ResultsTree.tscn | 32 + .../gdscript/addons/gut/gui/RunAtCursor.gd | 158 ++ .../gdscript/addons/gut/gui/RunAtCursor.tscn | 65 + .../gdscript/addons/gut/gui/RunResults.gd | 255 +++ .../gdscript/addons/gut/gui/RunResults.tscn | 116 ++ .../gdscript/addons/gut/gui/Settings.tscn | 7 + .../gdscript/addons/gut/gui/ShortcutButton.gd | 144 ++ .../addons/gut/gui/ShortcutButton.tscn | 55 + .../gdscript/addons/gut/gui/arrow.png | Bin 0 -> 122 bytes .../gdscript/addons/gut/gui/gut_config_gui.gd | 468 +++++ .../gdscript/addons/gut/gui/gut_gui.gd | 232 +++ .../petstore/gdscript/addons/gut/gui/play.png | Bin 0 -> 143 bytes .../gut/gui/script_text_editor_controls.gd | 239 +++ .../petstore/gdscript/addons/gut/gut.gd | 1328 ++++++++++++++ .../petstore/gdscript/addons/gut/gut_cmdln.gd | 319 ++++ .../gdscript/addons/gut/gut_config.gd | 179 ++ .../gdscript/addons/gut/gut_plugin.gd | 24 + .../gdscript/addons/gut/gut_to_move.gd | 75 + .../gdscript/addons/gut/hook_script.gd | 41 + .../petstore/gdscript/addons/gut/icon.png | Bin 0 -> 129 bytes .../gdscript/addons/gut/images/green.png | Bin 0 -> 213 bytes .../gdscript/addons/gut/images/red.png | Bin 0 -> 213 bytes .../gdscript/addons/gut/images/yellow.png | Bin 0 -> 213 bytes .../addons/gut/inner_class_registry.gd | 67 + .../gdscript/addons/gut/input_factory.gd | 142 ++ .../gdscript/addons/gut/input_sender.gd | 378 ++++ .../gdscript/addons/gut/junit_xml_export.gd | 94 + .../petstore/gdscript/addons/gut/logger.gd | 365 ++++ .../gdscript/addons/gut/method_maker.gd | 255 +++ .../gdscript/addons/gut/one_to_many.gd | 38 + .../petstore/gdscript/addons/gut/optparse.gd | 252 +++ .../gdscript/addons/gut/orphan_counter.gd | 55 + .../gdscript/addons/gut/parameter_factory.gd | 75 + .../gdscript/addons/gut/parameter_handler.gd | 37 + .../petstore/gdscript/addons/gut/plugin.cfg | 7 + .../petstore/gdscript/addons/gut/printers.gd | 182 ++ .../gdscript/addons/gut/result_exporter.gd | 112 ++ .../gdscript/addons/gut/script_parser.gd | 348 ++++ .../gdscript/addons/gut/signal_watcher.gd | 187 ++ .../gdscript/addons/gut/source_code_pro.fnt | Bin 0 -> 26499 bytes .../petstore/gdscript/addons/gut/spy.gd | 108 ++ .../petstore/gdscript/addons/gut/strutils.gd | 171 ++ .../gdscript/addons/gut/stub_params.gd | 135 ++ .../petstore/gdscript/addons/gut/stubber.gd | 233 +++ .../petstore/gdscript/addons/gut/summary.gd | 267 +++ .../petstore/gdscript/addons/gut/test.gd | 1603 +++++++++++++++++ .../gdscript/addons/gut/test_collector.gd | 314 ++++ .../gdscript/addons/gut/thing_counter.gd | 43 + .../petstore/gdscript/addons/gut/utils.gd | 485 +++++ .../client/petstore/gdscript/project.godot | 4 + .../gdscript/test/integration/test_basic.gd | 125 ++ .../test/integration/test_template.gd | 17 + .../client/petstore/gdscript/test/test.tscn | 8 + 101 files changed, 14078 insertions(+), 2 deletions(-) create mode 100644 samples/client/petstore/gdscript/.gut_editor_config.json create mode 100644 samples/client/petstore/gdscript/.gut_editor_shortcuts.cfg create mode 100644 samples/client/petstore/gdscript/.gutconfig.json create mode 100644 samples/client/petstore/gdscript/addons/gut/GutScene.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/GutScene.tscn create mode 100644 samples/client/petstore/gdscript/addons/gut/LICENSE.md create mode 100644 samples/client/petstore/gdscript/addons/gut/UserFileViewer.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/UserFileViewer.tscn create mode 100644 samples/client/petstore/gdscript/addons/gut/autofree.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/awaiter.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/comparator.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/compare_result.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/diff_formatter.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/diff_tool.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/double_templates/function_template.txt create mode 100644 samples/client/petstore/gdscript/addons/gut/double_templates/init_template.txt create mode 100644 samples/client/petstore/gdscript/addons/gut/double_templates/script_template.txt create mode 100644 samples/client/petstore/gdscript/addons/gut/double_tools.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/doubler.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/fonts/AnonymousPro-Bold.ttf create mode 100644 samples/client/petstore/gdscript/addons/gut/fonts/AnonymousPro-BoldItalic.ttf create mode 100644 samples/client/petstore/gdscript/addons/gut/fonts/AnonymousPro-Italic.ttf create mode 100644 samples/client/petstore/gdscript/addons/gut/fonts/AnonymousPro-Regular.ttf create mode 100644 samples/client/petstore/gdscript/addons/gut/fonts/CourierPrime-Bold.ttf create mode 100644 samples/client/petstore/gdscript/addons/gut/fonts/CourierPrime-BoldItalic.ttf create mode 100644 samples/client/petstore/gdscript/addons/gut/fonts/CourierPrime-Italic.ttf create mode 100644 samples/client/petstore/gdscript/addons/gut/fonts/CourierPrime-Regular.ttf create mode 100644 samples/client/petstore/gdscript/addons/gut/fonts/LobsterTwo-Bold.ttf create mode 100644 samples/client/petstore/gdscript/addons/gut/fonts/LobsterTwo-BoldItalic.ttf create mode 100644 samples/client/petstore/gdscript/addons/gut/fonts/LobsterTwo-Italic.ttf create mode 100644 samples/client/petstore/gdscript/addons/gut/fonts/LobsterTwo-Regular.ttf create mode 100644 samples/client/petstore/gdscript/addons/gut/fonts/OFL.txt create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/BottomPanelShortcuts.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/BottomPanelShortcuts.tscn create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/GutBottomPanel.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/GutBottomPanel.tscn create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/GutRunner.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/GutRunner.tscn create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/GutSceneTheme.tres create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/MinGui.tscn create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/NormalGui.tscn create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/OutputText.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/OutputText.tscn create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/ResizeHandle.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/ResizeHandle.tscn create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/ResultsTree.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/ResultsTree.tscn create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/RunAtCursor.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/RunAtCursor.tscn create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/RunResults.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/RunResults.tscn create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/Settings.tscn create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/ShortcutButton.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/ShortcutButton.tscn create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/arrow.png create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/gut_config_gui.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/gut_gui.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/play.png create mode 100644 samples/client/petstore/gdscript/addons/gut/gui/script_text_editor_controls.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/gut.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/gut_cmdln.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/gut_config.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/gut_plugin.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/gut_to_move.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/hook_script.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/icon.png create mode 100644 samples/client/petstore/gdscript/addons/gut/images/green.png create mode 100644 samples/client/petstore/gdscript/addons/gut/images/red.png create mode 100644 samples/client/petstore/gdscript/addons/gut/images/yellow.png create mode 100644 samples/client/petstore/gdscript/addons/gut/inner_class_registry.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/input_factory.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/input_sender.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/junit_xml_export.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/logger.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/method_maker.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/one_to_many.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/optparse.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/orphan_counter.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/parameter_factory.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/parameter_handler.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/plugin.cfg create mode 100644 samples/client/petstore/gdscript/addons/gut/printers.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/result_exporter.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/script_parser.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/signal_watcher.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/source_code_pro.fnt create mode 100644 samples/client/petstore/gdscript/addons/gut/spy.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/strutils.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/stub_params.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/stubber.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/summary.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/test.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/test_collector.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/thing_counter.gd create mode 100644 samples/client/petstore/gdscript/addons/gut/utils.gd create mode 100644 samples/client/petstore/gdscript/test/integration/test_basic.gd create mode 100644 samples/client/petstore/gdscript/test/integration/test_template.gd create mode 100644 samples/client/petstore/gdscript/test/test.tscn diff --git a/modules/openapi-generator/src/main/resources/gdscript/README.md b/modules/openapi-generator/src/main/resources/gdscript/README.md index 3ff666f3c92b..ab3e35b721eb 100644 --- a/modules/openapi-generator/src/main/resources/gdscript/README.md +++ b/modules/openapi-generator/src/main/resources/gdscript/README.md @@ -7,13 +7,17 @@ You can copy them all (or parts) and override them as needed. ## Domain Overview - ### ApiBee Base class for all Api endpoints classes. Holds most of the nitty-gritty. +### ApiConfig + +Reusable configuration (host, port, etc.) for Apis, injected into their constructor. + + ### ApiError Godot does not have an `Exception` (`try / catch`) mechanism, by design. diff --git a/samples/client/petstore/gdscript/.gut_editor_config.json b/samples/client/petstore/gdscript/.gut_editor_config.json new file mode 100644 index 000000000000..a334f8296b1c --- /dev/null +++ b/samples/client/petstore/gdscript/.gut_editor_config.json @@ -0,0 +1,42 @@ +{ + "background_color": "262626ff", + "compact_mode": false, + "config_file": "res://.gutconfig.json", + "dirs": [ + "res://test/integration" + ], + "disable_colors": false, + "double_strategy": "partial", + "font_color": "ccccccff", + "font_name": "CourierPrime", + "font_size": 16, + "gut_on_top": true, + "hide_orphans": false, + "ignore_pause": false, + "include_subdirs": false, + "inner_class": null, + "junit_xml_file": "", + "junit_xml_timestamp": false, + "log_level": 1, + "opacity": 100, + "paint_after": 0.5, + "panel_options": { + "font_name": "CourierPrime", + "font_size": 30, + "hide_output_text": false, + "hide_result_tree": false, + "hide_settings": false, + "use_colors": false + }, + "post_run_script": "", + "pre_run_script": "", + "prefix": "test_", + "selected": null, + "should_exit": false, + "should_exit_on_success": false, + "should_maximize": false, + "show_help": false, + "suffix": ".gd", + "tests": [], + "unit_test_name": null +} \ No newline at end of file diff --git a/samples/client/petstore/gdscript/.gut_editor_shortcuts.cfg b/samples/client/petstore/gdscript/.gut_editor_shortcuts.cfg new file mode 100644 index 000000000000..b7d0aa99782c --- /dev/null +++ b/samples/client/petstore/gdscript/.gut_editor_shortcuts.cfg @@ -0,0 +1,17 @@ +[main] + +run_all=Object(Shortcut,"resource_local_to_scene":false,"resource_name":"","events":[Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":0,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":0,"key_label":0,"unicode":0,"echo":false,"script":null) +],"script":null) + +run_current_script=Object(Shortcut,"resource_local_to_scene":false,"resource_name":"","events":[Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":0,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":0,"key_label":0,"unicode":0,"echo":false,"script":null) +],"script":null) + +run_current_inner=Object(Shortcut,"resource_local_to_scene":false,"resource_name":"","events":[Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":0,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":0,"key_label":0,"unicode":0,"echo":false,"script":null) +],"script":null) + +run_current_test=Object(Shortcut,"resource_local_to_scene":false,"resource_name":"","events":[Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":0,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":0,"key_label":0,"unicode":0,"echo":false,"script":null) +],"script":null) + +panel_button=Object(Shortcut,"resource_local_to_scene":false,"resource_name":"","events":[Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":0,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":0,"key_label":0,"unicode":0,"echo":false,"script":null) +],"script":null) + diff --git a/samples/client/petstore/gdscript/.gutconfig.json b/samples/client/petstore/gdscript/.gutconfig.json new file mode 100644 index 000000000000..d2513053f089 --- /dev/null +++ b/samples/client/petstore/gdscript/.gutconfig.json @@ -0,0 +1,32 @@ +{ + "background_color": null, + "compact_mode": null, + "dirs": [ + "res://test/integration" + ], + "disable_colors": null, + "double_strategy": null, + "font_color": null, + "font_name": null, + "font_size": null, + "gut_on_top": null, + "hide_orphans": null, + "ignore_pause": null, + "include_subdirs": null, + "inner_class": null, + "junit_xml_file": null, + "junit_xml_timestamp": null, + "log_level": null, + "opacity": null, + "paint_after": null, + "post_run_script": null, + "pre_run_script": null, + "prefix": null, + "selected": null, + "should_exit": null, + "should_exit_on_success": null, + "should_maximize": null, + "suffix": null, + "tests": null, + "unit_test_name": null +} diff --git a/samples/client/petstore/gdscript/README.md b/samples/client/petstore/gdscript/README.md index ec821c0c982a..54f24668fed8 100644 --- a/samples/client/petstore/gdscript/README.md +++ b/samples/client/petstore/gdscript/README.md @@ -19,7 +19,7 @@ See https://github.com/OpenAPITools/openapi-generator/wiki/Integration-Tests ## Run - godot --headless samples/client/petstore/gdscript + godot --path samples/client/petstore/gdscript -d -s addons/gut/gut_cmdln.gd The command should return a zero exit code if all tests passed. You may want to add `--verbose` for more logs when debugging. diff --git a/samples/client/petstore/gdscript/addons/gut/GutScene.gd b/samples/client/petstore/gdscript/addons/gut/GutScene.gd new file mode 100644 index 000000000000..619eba7a7986 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/GutScene.gd @@ -0,0 +1,124 @@ +extends Node2D +# ############################################################################## +# This is a wrapper around the normal and compact gui controls and serves as +# the interface between gut.gd and the gui. The GutRunner creates an instance +# of this and then this takes care of managing the different GUI controls. +# ############################################################################## +@onready var _normal_gui = $Normal +@onready var _compact_gui = $Compact +var gut = null : + set(val): + gut = val + _set_gut(val) + + +func _ready(): + _normal_gui.switch_modes.connect(use_compact_mode.bind(true)) + _compact_gui.switch_modes.connect(use_compact_mode.bind(false)) + + _normal_gui.set_title("GUT") + _compact_gui.set_title("GUT") + + _normal_gui.align_right() + _compact_gui.to_bottom_right() + + use_compact_mode(false) + + if(get_parent() == get_tree().root): + _test_running_setup() + +func _test_running_setup(): + _normal_gui.get_textbox().text = "hello world, how are you doing?" + +# ------------------------ +# Private +# ------------------------ +func _set_gut(val): + _normal_gui.set_gut(val) + _compact_gui.set_gut(val) + + val.start_run.connect(_on_gut_start_run) + val.end_run.connect(_on_gut_end_run) + val.start_pause_before_teardown.connect(_on_gut_pause) + val.end_pause_before_teardown.connect(_on_pause_end) + +func _set_both_titles(text): + _normal_gui.set_title(text) + _compact_gui.set_title(text) + + +# ------------------------ +# Events +# ------------------------ +func _on_gut_start_run(): + _set_both_titles('Running') + +func _on_gut_end_run(): + _set_both_titles('Finished') + +func _on_gut_pause(): + _set_both_titles('-- Paused --') + +func _on_pause_end(): + _set_both_titles('Running') + + +# ------------------------ +# Public +# ------------------------ +func get_textbox(): + return _normal_gui.get_textbox() + + +func set_font_size(new_size): + return + var rtl = _normal_gui.get_textbox() + if(rtl.get('custom_fonts/normal_font') != null): + rtl.get('custom_fonts/bold_italics_font').size = new_size + rtl.get('custom_fonts/bold_font').size = new_size + rtl.get('custom_fonts/italics_font').size = new_size + rtl.get('custom_fonts/normal_font').size = new_size + + +func set_font(font_name): + _set_all_fonts_in_rtl(_normal_gui.get_textbox(), font_name) + + +func _set_font(rtl, font_name, custom_name): + if(font_name == null): + rtl.add_theme_font_override(custom_name, null) + else: + var dyn_font = FontFile.new() + dyn_font.load_dynamic_font('res://addons/gut/fonts/' + font_name + '.ttf') + rtl.add_theme_font_override(custom_name, dyn_font) + + +func _set_all_fonts_in_rtl(rtl, base_name): + if(base_name == 'Default'): + _set_font(rtl, null, 'normal_font') + _set_font(rtl, null, 'bold_font') + _set_font(rtl, null, 'italics_font') + _set_font(rtl, null, 'bold_italics_font') + else: + _set_font(rtl, base_name + '-Regular', 'normal_font') + _set_font(rtl, base_name + '-Bold', 'bold_font') + _set_font(rtl, base_name + '-Italic', 'italics_font') + _set_font(rtl, base_name + '-BoldItalic', 'bold_italics_font') + + +func set_default_font_color(color): + _normal_gui.get_textbox().set('custom_colors/default_color', color) + + +func set_background_color(color): + _normal_gui.set_bg_color(color) + + +func use_compact_mode(should=true): + _compact_gui.visible = should + _normal_gui.visible = !should + + +func set_opacity(val): + _normal_gui.modulate.a = val + _compact_gui.modulate.a = val diff --git a/samples/client/petstore/gdscript/addons/gut/GutScene.tscn b/samples/client/petstore/gdscript/addons/gut/GutScene.tscn new file mode 100644 index 000000000000..57d7f036e392 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/GutScene.tscn @@ -0,0 +1,16 @@ +[gd_scene load_steps=4 format=3 uid="uid://m28heqtswbuq"] + +[ext_resource type="Script" path="res://addons/gut/GutScene.gd" id="1_b4m8y"] +[ext_resource type="PackedScene" uid="uid://duxblir3vu8x7" path="res://addons/gut/gui/NormalGui.tscn" id="2_j6ywb"] +[ext_resource type="PackedScene" uid="uid://cnqqdfsn80ise" path="res://addons/gut/gui/MinGui.tscn" id="3_3glw1"] + +[node name="GutScene" type="Node2D"] +script = ExtResource("1_b4m8y") + +[node name="Normal" parent="." instance=ExtResource("2_j6ywb")] + +[node name="Compact" parent="." instance=ExtResource("3_3glw1")] +offset_left = 5.0 +offset_top = 273.0 +offset_right = 265.0 +offset_bottom = 403.0 diff --git a/samples/client/petstore/gdscript/addons/gut/LICENSE.md b/samples/client/petstore/gdscript/addons/gut/LICENSE.md new file mode 100644 index 000000000000..a38ac231fed3 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/LICENSE.md @@ -0,0 +1,22 @@ +The MIT License (MIT) +===================== + +Copyright (c) 2018 Tom "Butch" Wesley + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/samples/client/petstore/gdscript/addons/gut/UserFileViewer.gd b/samples/client/petstore/gdscript/addons/gut/UserFileViewer.gd new file mode 100644 index 000000000000..73b6a004a947 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/UserFileViewer.gd @@ -0,0 +1,52 @@ +extends Window + +@onready var rtl = $TextDisplay/RichTextLabel + +func _get_file_as_text(path): + var to_return = null + var f = FileAccess.open(path, FileAccess.READ) + if(f != null): + to_return = f.get_as_text() + else: + to_return = str('ERROR: Could not open file. Error code ', FileAccess.get_open_error()) + return to_return + +func _ready(): + rtl.clear() + +func _on_OpenFile_pressed(): + $FileDialog.popup_centered() + +func _on_FileDialog_file_selected(path): + show_file(path) + +func _on_Close_pressed(): + self.hide() + +func show_file(path): + var text = _get_file_as_text(path) + if(text == ''): + text = '' + rtl.set_text(text) + self.window_title = path + +func show_open(): + self.popup_centered() + $FileDialog.popup_centered() + +func get_rich_text_label(): + return $TextDisplay/RichTextLabel + +func _on_Home_pressed(): + rtl.scroll_to_line(0) + +func _on_End_pressed(): + rtl.scroll_to_line(rtl.get_line_count() -1) + +func _on_Copy_pressed(): + return + # OS.clipboard = rtl.text + +func _on_file_dialog_visibility_changed(): + if rtl.text.length() == 0 and not $FileDialog.visible: + self.hide() diff --git a/samples/client/petstore/gdscript/addons/gut/UserFileViewer.tscn b/samples/client/petstore/gdscript/addons/gut/UserFileViewer.tscn new file mode 100644 index 000000000000..eb37c9acc434 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/UserFileViewer.tscn @@ -0,0 +1,92 @@ +[gd_scene load_steps=2 format=3 uid="uid://bsm7wtt1gie4v"] + +[ext_resource type="Script" path="res://addons/gut/UserFileViewer.gd" id="1"] + +[node name="UserFileViewer" type="Window"] +exclusive = true +script = ExtResource("1") + +[node name="FileDialog" type="FileDialog" parent="."] +access = 1 +show_hidden_files = true +__meta__ = { +"_edit_use_anchors_": false +} + +[node name="TextDisplay" type="ColorRect" parent="."] +anchor_right = 1.0 +anchor_bottom = 1.0 +offset_left = 8.0 +offset_right = -10.0 +offset_bottom = -65.0 +color = Color(0.2, 0.188235, 0.188235, 1) + +[node name="RichTextLabel" type="RichTextLabel" parent="TextDisplay"] +anchor_right = 1.0 +anchor_bottom = 1.0 +focus_mode = 2 +text = "In publishing and graphic design, Lorem ipsum is a placeholder text commonly used to demonstrate the visual form of a document or a typeface without relying on meaningful content. Lorem ipsum may be used before final copy is available, but it may also be used to temporarily replace copy in a process called greeking, which allows designers to consider form without the meaning of the text influencing the design. + +Lorem ipsum is typically a corrupted version of De finibus bonorum et malorum, a first-century BCE text by the Roman statesman and philosopher Cicero, with words altered, added, and removed to make it nonsensical, improper Latin. + +Versions of the Lorem ipsum text have been used in typesetting at least since the 1960s, when it was popularized by advertisements for Letraset transfer sheets. Lorem ipsum was introduced to the digital world in the mid-1980s when Aldus employed it in graphic and word-processing templates for its desktop publishing program PageMaker. Other popular word processors including Pages and Microsoft Word have since adopted Lorem ipsum as well." +selection_enabled = true + +[node name="OpenFile" type="Button" parent="."] +anchor_left = 1.0 +anchor_top = 1.0 +anchor_right = 1.0 +anchor_bottom = 1.0 +offset_left = -158.0 +offset_top = -50.0 +offset_right = -84.0 +offset_bottom = -30.0 +text = "Open File" + +[node name="Home" type="Button" parent="."] +anchor_left = 1.0 +anchor_top = 1.0 +anchor_right = 1.0 +anchor_bottom = 1.0 +offset_left = -478.0 +offset_top = -50.0 +offset_right = -404.0 +offset_bottom = -30.0 +text = "Home" + +[node name="Copy" type="Button" parent="."] +anchor_top = 1.0 +anchor_bottom = 1.0 +offset_left = 160.0 +offset_top = -50.0 +offset_right = 234.0 +offset_bottom = -30.0 +text = "Copy" + +[node name="End" type="Button" parent="."] +anchor_left = 1.0 +anchor_top = 1.0 +anchor_right = 1.0 +anchor_bottom = 1.0 +offset_left = -318.0 +offset_top = -50.0 +offset_right = -244.0 +offset_bottom = -30.0 +text = "End" + +[node name="Close" type="Button" parent="."] +anchor_top = 1.0 +anchor_bottom = 1.0 +offset_left = 10.0 +offset_top = -50.0 +offset_right = 80.0 +offset_bottom = -30.0 +text = "Close" + +[connection signal="file_selected" from="FileDialog" to="." method="_on_FileDialog_file_selected"] +[connection signal="visibility_changed" from="FileDialog" to="." method="_on_file_dialog_visibility_changed"] +[connection signal="pressed" from="OpenFile" to="." method="_on_OpenFile_pressed"] +[connection signal="pressed" from="Home" to="." method="_on_Home_pressed"] +[connection signal="pressed" from="Copy" to="." method="_on_Copy_pressed"] +[connection signal="pressed" from="End" to="." method="_on_End_pressed"] +[connection signal="pressed" from="Close" to="." method="_on_Close_pressed"] diff --git a/samples/client/petstore/gdscript/addons/gut/autofree.gd b/samples/client/petstore/gdscript/addons/gut/autofree.gd new file mode 100644 index 000000000000..b82676bcfae2 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/autofree.gd @@ -0,0 +1,59 @@ +# ############################################################################## +#(G)odot (U)nit (T)est class +# +# ############################################################################## +# The MIT License (MIT) +# ===================== +# +# Copyright (c) 2020 Tom "Butch" Wesley +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# ############################################################################## +# Class used to keep track of objects to be freed and utilities to free them. +# ############################################################################## +var _to_free = [] +var _to_queue_free = [] + +func add_free(thing): + if(typeof(thing) == TYPE_OBJECT): + if(!thing is RefCounted): + _to_free.append(thing) + +func add_queue_free(thing): + _to_queue_free.append(thing) + +func get_queue_free_count(): + return _to_queue_free.size() + +func get_free_count(): + return _to_free.size() + +func free_all(): + for i in range(_to_free.size()): + if(is_instance_valid(_to_free[i])): + _to_free[i].free() + _to_free.clear() + + for i in range(_to_queue_free.size()): + if(is_instance_valid(_to_queue_free[i])): + _to_queue_free[i].queue_free() + _to_queue_free.clear() + + diff --git a/samples/client/petstore/gdscript/addons/gut/awaiter.gd b/samples/client/petstore/gdscript/addons/gut/awaiter.gd new file mode 100644 index 000000000000..4d568a2ffc6b --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/awaiter.gd @@ -0,0 +1,67 @@ +extends Node + +signal timeout +signal wait_started + +var _wait_time = 0.0 +var _wait_frames = 0 +var _signal_to_wait_on = null + +var _elapsed_time = 0.0 +var _elapsed_frames = 0 + + +func _physics_process(delta): + if(_wait_time != 0.0): + _elapsed_time += delta + if(_elapsed_time >= _wait_time): + _end_wait() + + if(_wait_frames != 0): + _elapsed_frames += 1 + if(_elapsed_frames >= _wait_frames): + _end_wait() + + +func _end_wait(): + _wait_time = 0.0 + _wait_frames = 0 + _signal_to_wait_on = null + _elapsed_time = 0.0 + _elapsed_frames = 0 + timeout.emit() + + +const ARG_NOT_SET = '_*_argument_*_is_*_not_set_*_' +func _signal_callback( + arg1=ARG_NOT_SET, arg2=ARG_NOT_SET, arg3=ARG_NOT_SET, + arg4=ARG_NOT_SET, arg5=ARG_NOT_SET, arg6=ARG_NOT_SET, + arg7=ARG_NOT_SET, arg8=ARG_NOT_SET, arg9=ARG_NOT_SET): + + _signal_to_wait_on.disconnect(_signal_callback) + # DO NOT _end_wait here. For other parts of the test to get the signal that + # was waited on, we have to wait for a couple more frames. For example, the + # signal_watcher doesn't get the signal in time if we don't do this. + _wait_frames = 2 + + +func wait_for(x): + _wait_time = x + wait_started.emit() + + +func wait_frames(x): + _wait_frames = x + wait_started.emit() + + +func wait_for_signal(the_signal, x): + the_signal.connect(_signal_callback) + _signal_to_wait_on = the_signal + _wait_time = x + wait_started.emit() + + +func is_waiting(): + return _wait_time != 0.0 || _wait_frames != 0 + diff --git a/samples/client/petstore/gdscript/addons/gut/comparator.gd b/samples/client/petstore/gdscript/addons/gut/comparator.gd new file mode 100644 index 000000000000..48776c4188f4 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/comparator.gd @@ -0,0 +1,123 @@ +var _utils = load('res://addons/gut/utils.gd').get_instance() +var _strutils = _utils.Strutils.new() +var _max_length = 100 +var _should_compare_int_to_float = true + +const MISSING = '|__missing__gut__compare__value__|' + +func _cannot_compare_text(v1, v2): + return str('Cannot compare ', _strutils.types[typeof(v1)], ' with ', + _strutils.types[typeof(v2)], '.') + +func _make_missing_string(text): + return '' + +func _create_missing_result(v1, v2, text): + var to_return = null + var v1_str = format_value(v1) + var v2_str = format_value(v2) + + if(typeof(v1) == TYPE_STRING and v1 == MISSING): + v1_str = _make_missing_string(text) + to_return = _utils.CompareResult.new() + elif(typeof(v2) == TYPE_STRING and v2 == MISSING): + v2_str = _make_missing_string(text) + to_return = _utils.CompareResult.new() + + if(to_return != null): + to_return.summary = str(v1_str, ' != ', v2_str) + to_return.are_equal = false + + return to_return + + +func simple(v1, v2, missing_string=''): + var missing_result = _create_missing_result(v1, v2, missing_string) + if(missing_result != null): + return missing_result + + var result = _utils.CompareResult.new() + var cmp_str = null + var extra = '' + + var tv1 = typeof(v1) + var tv2 = typeof(v2) + + # print(tv1, '::', tv2, ' ', _strutils.types[tv1], '::', _strutils.types[tv2]) + if(_should_compare_int_to_float and [TYPE_INT, TYPE_FLOAT].has(tv1) and [TYPE_INT, TYPE_FLOAT].has(tv2)): + result.are_equal = v1 == v2 + elif([TYPE_STRING, TYPE_STRING_NAME].has(tv1) and [TYPE_STRING, TYPE_STRING_NAME].has(tv2)): + result.are_equal = v1 == v2 + elif(_utils.are_datatypes_same(v1, v2)): + result.are_equal = v1 == v2 + + if(typeof(v1) == TYPE_DICTIONARY or typeof(v1) == TYPE_ARRAY): + var sub_result = _utils.DiffTool.new(v1, v2, _utils.DIFF.DEEP) + result.summary = sub_result.get_short_summary() + if(!sub_result.are_equal): + extra = ".\n" + sub_result.get_short_summary() + else: + cmp_str = '!=' + result.are_equal = false + extra = str('. ', _cannot_compare_text(v1, v2)) + + cmp_str = get_compare_symbol(result.are_equal) + result.summary = str(format_value(v1), ' ', cmp_str, ' ', format_value(v2), extra) + + return result + + +func shallow(v1, v2): + var result = null + if(_utils.are_datatypes_same(v1, v2)): + if(typeof(v1) in [TYPE_ARRAY, TYPE_DICTIONARY]): + result = _utils.DiffTool.new(v1, v2, _utils.DIFF.DEEP) + else: + result = simple(v1, v2) + else: + result = simple(v1, v2) + + return result + + +func deep(v1, v2): + var result = null + + if(_utils.are_datatypes_same(v1, v2)): + if(typeof(v1) in [TYPE_ARRAY, TYPE_DICTIONARY]): + result = _utils.DiffTool.new(v1, v2, _utils.DIFF.DEEP) + else: + result = simple(v1, v2) + else: + result = simple(v1, v2) + + return result + + +func format_value(val, max_val_length=_max_length): + return _strutils.truncate_string(_strutils.type2str(val), max_val_length) + + +func compare(v1, v2, diff_type=_utils.DIFF.SIMPLE): + var result = null + if(diff_type == _utils.DIFF.SIMPLE): + result = simple(v1, v2) + elif(diff_type == _utils.DIFF.DEEP): + result = deep(v1, v2) + + return result + + +func get_should_compare_int_to_float(): + return _should_compare_int_to_float + + +func set_should_compare_int_to_float(should_compare_int_float): + _should_compare_int_to_float = should_compare_int_float + + +func get_compare_symbol(is_equal): + if(is_equal): + return '==' + else: + return '!=' diff --git a/samples/client/petstore/gdscript/addons/gut/compare_result.gd b/samples/client/petstore/gdscript/addons/gut/compare_result.gd new file mode 100644 index 000000000000..1a8afb5da234 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/compare_result.gd @@ -0,0 +1,70 @@ +var _are_equal = false +var are_equal = false : + get: + return get_are_equal() + set(val): + set_are_equal(val) + +var _summary = null +var summary = null : + get: + return get_summary() + set(val): + set_summary(val) + +var _max_differences = 30 +var max_differences = 30 : + get: + return get_max_differences() + set(val): + set_max_differences(val) + +var _differences = {} +var differences : + get: + return get_differences() + set(val): + set_differences(val) + +func _block_set(which, val): + push_error(str('cannot set ', which, ', value [', val, '] ignored.')) + +func _to_string(): + return str(get_summary()) # could be null, gotta str it. + +func get_are_equal(): + return _are_equal + +func set_are_equal(r_eq): + _are_equal = r_eq + +func get_summary(): + return _summary + +func set_summary(smry): + _summary = smry + +func get_total_count(): + pass + +func get_different_count(): + pass + +func get_short_summary(): + return summary + +func get_max_differences(): + return _max_differences + +func set_max_differences(max_diff): + _max_differences = max_diff + +func get_differences(): + return _differences + +func set_differences(diffs): + _block_set('differences', diffs) + +func get_brackets(): + return null + diff --git a/samples/client/petstore/gdscript/addons/gut/diff_formatter.gd b/samples/client/petstore/gdscript/addons/gut/diff_formatter.gd new file mode 100644 index 000000000000..fd954affb7aa --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/diff_formatter.gd @@ -0,0 +1,64 @@ +var _utils = load('res://addons/gut/utils.gd').get_instance() +var _strutils = _utils.Strutils.new() +const INDENT = ' ' +var _max_to_display = 30 +const ABSOLUTE_MAX_DISPLAYED = 10000 +const UNLIMITED = -1 + + +func _single_diff(diff, depth=0): + var to_return = "" + var brackets = diff.get_brackets() + + if(brackets != null and !diff.are_equal): + to_return = '' + to_return += str(brackets.open, "\n", + _strutils.indent_text(differences_to_s(diff.differences, depth), depth+1, INDENT), "\n", + brackets.close) + else: + to_return = str(diff) + + return to_return + + +func make_it(diff): + var to_return = '' + if(diff.are_equal): + to_return = diff.summary + else: + if(_max_to_display == ABSOLUTE_MAX_DISPLAYED): + to_return = str(diff.get_value_1(), ' != ', diff.get_value_2()) + else: + to_return = diff.get_short_summary() + to_return += str("\n", _strutils.indent_text(_single_diff(diff, 0), 1, ' ')) + return to_return + + +func differences_to_s(differences, depth=0): + var to_return = '' + var keys = differences.keys() + keys.sort() + var limit = min(_max_to_display, differences.size()) + + for i in range(limit): + var key = keys[i] + to_return += str(key, ": ", _single_diff(differences[key], depth)) + + if(i != limit -1): + to_return += "\n" + + if(differences.size() > _max_to_display): + to_return += str("\n\n... ", differences.size() - _max_to_display, " more.") + + return to_return + + +func get_max_to_display(): + return _max_to_display + + +func set_max_to_display(max_to_display): + _max_to_display = max_to_display + if(_max_to_display == UNLIMITED): + _max_to_display = ABSOLUTE_MAX_DISPLAYED + diff --git a/samples/client/petstore/gdscript/addons/gut/diff_tool.gd b/samples/client/petstore/gdscript/addons/gut/diff_tool.gd new file mode 100644 index 000000000000..bc33a9024c30 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/diff_tool.gd @@ -0,0 +1,158 @@ +extends 'res://addons/gut/compare_result.gd' +const INDENT = ' ' +enum { + DEEP, + SIMPLE +} + +var _utils = load('res://addons/gut/utils.gd').get_instance() +var _strutils = _utils.Strutils.new() +var _compare = _utils.Comparator.new() +var DiffTool = load('res://addons/gut/diff_tool.gd') + +var _value_1 = null +var _value_2 = null +var _total_count = 0 +var _diff_type = null +var _brackets = null +var _valid = true +var _desc_things = 'somethings' + +# -------- comapre_result.gd "interface" --------------------- +func set_are_equal(val): + _block_set('are_equal', val) + +func get_are_equal(): + if(!_valid): + return null + else: + return differences.size() == 0 + + +func set_summary(val): + _block_set('summary', val) + +func get_summary(): + return summarize() + +func get_different_count(): + return differences.size() + +func get_total_count(): + return _total_count + +func get_short_summary(): + var text = str(_strutils.truncate_string(str(_value_1), 50), + ' ', _compare.get_compare_symbol(are_equal), ' ', + _strutils.truncate_string(str(_value_2), 50)) + if(!are_equal): + text += str(' ', get_different_count(), ' of ', get_total_count(), + ' ', _desc_things, ' do not match.') + return text + +func get_brackets(): + return _brackets +# -------- comapre_result.gd "interface" --------------------- + + +func _invalidate(): + _valid = false + differences = null + + +func _init(v1,v2,diff_type=DEEP): + _value_1 = v1 + _value_2 = v2 + _diff_type = diff_type + _compare.set_should_compare_int_to_float(false) + _find_differences(_value_1, _value_2) + + +func _find_differences(v1, v2): + if(_utils.are_datatypes_same(v1, v2)): + if(typeof(v1) == TYPE_ARRAY): + _brackets = {'open':'[', 'close':']'} + _desc_things = 'indexes' + _diff_array(v1, v2) + elif(typeof(v2) == TYPE_DICTIONARY): + _brackets = {'open':'{', 'close':'}'} + _desc_things = 'keys' + _diff_dictionary(v1, v2) + else: + _invalidate() + _utils.get_logger().error('Only Arrays and Dictionaries are supported.') + else: + _invalidate() + _utils.get_logger().error('Only Arrays and Dictionaries are supported.') + + +func _diff_array(a1, a2): + _total_count = max(a1.size(), a2.size()) + for i in range(a1.size()): + var result = null + if(i < a2.size()): + if(_diff_type == DEEP): + result = _compare.deep(a1[i], a2[i]) + else: + result = _compare.simple(a1[i], a2[i]) + else: + result = _compare.simple(a1[i], _compare.MISSING, 'index') + + if(!result.are_equal): + differences[i] = result + + if(a1.size() < a2.size()): + for i in range(a1.size(), a2.size()): + differences[i] = _compare.simple(_compare.MISSING, a2[i], 'index') + + +func _diff_dictionary(d1, d2): + var d1_keys = d1.keys() + var d2_keys = d2.keys() + + # Process all the keys in d1 + _total_count += d1_keys.size() + for key in d1_keys: + if(!d2.has(key)): + differences[key] = _compare.simple(d1[key], _compare.MISSING, 'key') + else: + d2_keys.remove_at(d2_keys.find(key)) + + var result = null + if(_diff_type == DEEP): + result = _compare.deep(d1[key], d2[key]) + else: + result = _compare.simple(d1[key], d2[key]) + + if(!result.are_equal): + differences[key] = result + + # Process all the keys in d2 that didn't exist in d1 + _total_count += d2_keys.size() + for i in range(d2_keys.size()): + differences[d2_keys[i]] = _compare.simple(_compare.MISSING, d2[d2_keys[i]], 'key') + + +func summarize(): + var summary = '' + + if(are_equal): + summary = get_short_summary() + else: + var formatter = load('res://addons/gut/diff_formatter.gd').new() + formatter.set_max_to_display(max_differences) + summary = formatter.make_it(self) + + return summary + + +func get_diff_type(): + return _diff_type + + +func get_value_1(): + return _value_1 + + +func get_value_2(): + return _value_2 diff --git a/samples/client/petstore/gdscript/addons/gut/double_templates/function_template.txt b/samples/client/petstore/gdscript/addons/gut/double_templates/function_template.txt new file mode 100644 index 000000000000..a22ff063a34e --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/double_templates/function_template.txt @@ -0,0 +1,6 @@ +{func_decleration} + __gutdbl.spy_on('{method_name}', {param_array}) + if(__gutdbl.should_call_super('{method_name}', {param_array})): + return {super_call} + else: + return __gutdbl.get_stubbed_return('{method_name}', {param_array}) diff --git a/samples/client/petstore/gdscript/addons/gut/double_templates/init_template.txt b/samples/client/petstore/gdscript/addons/gut/double_templates/init_template.txt new file mode 100644 index 000000000000..9b43474d0878 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/double_templates/init_template.txt @@ -0,0 +1,4 @@ +{func_decleration}: + super({super_params}) + __gutdbl.spy_on('{method_name}', {param_array}) + diff --git a/samples/client/petstore/gdscript/addons/gut/double_templates/script_template.txt b/samples/client/petstore/gdscript/addons/gut/double_templates/script_template.txt new file mode 100644 index 000000000000..bb597387b414 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/double_templates/script_template.txt @@ -0,0 +1,31 @@ +# ############################################################################## +# Gut Doubled Script +# ############################################################################## +{extends} + +{constants} + +{properties} + +# ------------------------------------------------------------------------------ +# GUT stuff +# ------------------------------------------------------------------------------ +var __gutdbl_values = { + double = self, + thepath = '{path}', + subpath = '{subpath}', + stubber = {stubber_id}, + spy = {spy_id}, + gut = {gut_id}, + from_singleton = '{singleton_name}', + is_partial = {is_partial}, +} +var __gutdbl = load('res://addons/gut/double_tools.gd').new(__gutdbl_values) + +# Here so other things can check for a method to know if this is a double. +func __gutdbl_check_method__(): + pass + +# ------------------------------------------------------------------------------ +# Doubled Methods +# ------------------------------------------------------------------------------ diff --git a/samples/client/petstore/gdscript/addons/gut/double_tools.gd b/samples/client/petstore/gdscript/addons/gut/double_tools.gd new file mode 100644 index 000000000000..ab75cc7950d1 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/double_tools.gd @@ -0,0 +1,52 @@ +var thepath = '' +var subpath = '' +var stubber = null +var spy = null +var gut = null +var from_singleton = null +var is_partial = null +var double = null + +const NO_DEFAULT_VALUE = '!__gut__no__default__value__!' +func from_id(inst_id): + if(inst_id == -1): + return null + else: + return instance_from_id(inst_id) + +func should_call_super(method_name, called_with): + if(stubber != null): + return stubber.should_call_super(double, method_name, called_with) + else: + return false + +func spy_on(method_name, called_with): + if(spy != null): + spy.add_call(double, method_name, called_with) + +func get_stubbed_return(method_name, called_with): + if(stubber != null): + return stubber.get_return(double, method_name, called_with) + else: + return null + +func default_val(method_name, p_index, default_val=NO_DEFAULT_VALUE): + if(stubber != null): + return stubber.get_default_value(double, method_name, p_index) + else: + return null + +func _init(values=null): + if(values != null): + double = values.double + thepath = values.thepath + subpath = values.subpath + stubber = from_id(values.stubber) + spy = from_id(values.spy) + gut = from_id(values.gut) + from_singleton = values.from_singleton + is_partial = values.is_partial + + if(gut != null): + gut.get_autofree().add_free(double) + diff --git a/samples/client/petstore/gdscript/addons/gut/doubler.gd b/samples/client/petstore/gdscript/addons/gut/doubler.gd new file mode 100644 index 000000000000..e4b984db3c2a --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/doubler.gd @@ -0,0 +1,321 @@ +# ############################################################################## +#(G)odot (U)nit (T)est class +# +# ############################################################################## +# The MIT License (MIT) +# ===================== +# +# Copyright (c) 2020 Tom "Butch" Wesley +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# ############################################################################## +# Description +# ----------- +# ############################################################################## + + + +# ------------------------------------------------------------------------------ +# A stroke of genius if I do say so. This allows for doubling a scene without +# having to write any files. By overloading the "instantiate" method we can +# make whatever we want. +# ------------------------------------------------------------------------------ +class PackedSceneDouble: + extends PackedScene + var _script = null + var _scene = null + + func set_script_obj(obj): + _script = obj + + func instantiate(edit_state=0): + var inst = _scene.instantiate(edit_state) + if(_script != null): + inst.set_script(_script) + return inst + + func load_scene(path): + _scene = load(path) + + + + +# ------------------------------------------------------------------------------ +# START Doubler +# ------------------------------------------------------------------------------ +var _utils = load('res://addons/gut/utils.gd').get_instance() +var _base_script_text = _utils.get_file_as_text('res://addons/gut/double_templates/script_template.txt') +var _script_collector = _utils.ScriptCollector.new() +# used by tests for debugging purposes. +var print_source = false +var inner_class_registry = _utils.InnerClassRegistry.new() + +# ############### +# Properties +# ############### +var _stubber = _utils.Stubber.new() +func get_stubber(): + return _stubber +func set_stubber(stubber): + _stubber = stubber + +var _lgr = _utils.get_logger() +func get_logger(): + return _lgr +func set_logger(logger): + _lgr = logger + _method_maker.set_logger(logger) + +var _spy = null +func get_spy(): + return _spy +func set_spy(spy): + _spy = spy + +var _gut = null +func get_gut(): + return _gut +func set_gut(gut): + _gut = gut + +var _strategy = null +func get_strategy(): + return _strategy +func set_strategy(strategy): + _strategy = strategy + + +var _method_maker = _utils.MethodMaker.new() +func get_method_maker(): + return _method_maker + +var _ignored_methods = _utils.OneToMany.new() +func get_ignored_methods(): + return _ignored_methods + +# ############### +# Private +# ############### +func _init(strategy=_utils.DOUBLE_STRATEGY.SCRIPT_ONLY): + set_logger(_utils.get_logger()) + _strategy = strategy + + +func _get_indented_line(indents, text): + var to_return = '' + for _i in range(indents): + to_return += "\t" + return str(to_return, text, "\n") + + +func _stub_to_call_super(parsed, method_name): + if(_utils.non_super_methods.has(method_name)): + return + + var params = _utils.StubParams.new(parsed.script_path, method_name, parsed.subpath) + params.to_call_super() + _stubber.add_stub(params) + + +func _get_base_script_text(parsed, override_path, partial): + var path = parsed.script_path + if(override_path != null): + path = override_path + + var stubber_id = -1 + if(_stubber != null): + stubber_id = _stubber.get_instance_id() + + var spy_id = -1 + if(_spy != null): + spy_id = _spy.get_instance_id() + + var gut_id = -1 + if(_gut != null): + gut_id = _gut.get_instance_id() + + var extends_text = parsed.get_extends_text() + + var values = { + # Top sections + "extends":extends_text, + "constants":'',#obj_info.get_constants_text(), + "properties":'',#obj_info.get_properties_text(), + + # metadata values + "path":path, + "subpath":_utils.nvl(parsed.subpath, ''), + "stubber_id":stubber_id, + "spy_id":spy_id, + "gut_id":gut_id, + "singleton_name":'',#_utils.nvl(obj_info.get_singleton_name(), ''), + "is_partial":partial, + } + + return _base_script_text.format(values) + + +func _is_valid_double_method(parsed_script, parsed_method): + return !parsed_method.is_accessor() and \ + !parsed_method.is_black_listed() and \ + !_ignored_methods.has(parsed_script.resource, parsed_method.meta.name) + +func _create_double(parsed, strategy, override_path, partial): + var base_script = _get_base_script_text(parsed, override_path, partial) + var super_name = "" + var path = "" + + path = parsed.script_path + var dbl_src = "" + dbl_src += base_script + + for method in parsed.get_local_methods(): + if(_is_valid_double_method(parsed, method)): + var mthd = parsed.get_local_method(method.meta.name) + if(parsed.is_native): + dbl_src += _get_func_text(method.meta, parsed.resource, super_name) + else: + dbl_src += _get_func_text(method.meta, path, super_name) + + if(strategy == _utils.DOUBLE_STRATEGY.INCLUDE_SUPER): + for method in parsed.get_super_methods(): + if(_is_valid_double_method(parsed, method)): + _stub_to_call_super(parsed, method.meta.name) + if(parsed.is_native): + dbl_src += _get_func_text(method.meta, parsed.resource, super_name) + else: + dbl_src += _get_func_text(method.meta, path, super_name) + + if(print_source): + print(_utils.add_line_numbers(dbl_src)) + + var DblClass = _utils.create_script_from_source(dbl_src) + if(_stubber != null): + _stub_method_default_values(DblClass, parsed, strategy) + + return DblClass + + +func _stub_method_default_values(which, parsed, strategy): + for method in parsed.get_local_methods(): + if(!method.is_black_listed() && !_ignored_methods.has(parsed.resource, method.meta.name)): + _stubber.stub_defaults_from_meta(parsed.script_path, method.meta) + + + +func _double_scene_and_script(scene, strategy, partial): + var to_return = PackedSceneDouble.new() + to_return.load_scene(scene.get_path()) + + var script_obj = _utils.get_scene_script_object(scene) + if(script_obj != null): + var script_dbl = null + if(partial): + script_dbl = _partial_double(script_obj, strategy, scene.get_path()) + else: + script_dbl = _double(script_obj, strategy, scene.get_path()) + to_return.set_script_obj(script_dbl) + + return to_return + + +func _get_inst_id_ref_str(inst): + var ref_str = 'null' + if(inst): + ref_str = str('instance_from_id(', inst.get_instance_id(),')') + return ref_str + + +func _get_func_text(method_hash, path, super_=""): + var override_count = null; + if(_stubber != null): + override_count = _stubber.get_parameter_count(path, method_hash.name) + + var text = _method_maker.get_function_text(method_hash, path, override_count, super_) + "\n" + + return text + + +func _parse_script(obj): + var parsed = null + + if(_utils.is_inner_class(obj)): + if(inner_class_registry.has(obj)): + parsed = _script_collector.parse(inner_class_registry.get_base_resource(obj), obj) + else: + _lgr.error('Doubling Inner Classes requires you register them first. Call register_inner_classes passing the script that contains the inner class.') + else: + parsed = _script_collector.parse(obj) + + return parsed + + +# Override path is used with scenes. +func _double(obj, strategy, override_path=null): + var parsed = _parse_script(obj) + if(parsed != null): + return _create_double(parsed, strategy, override_path, false) + + +func _partial_double(obj, strategy, override_path=null): + var parsed = _parse_script(obj) + if(parsed != null): + return _create_double(parsed, strategy, override_path, true) + + +# ------------------------- +# Public +# ------------------------- + +# double a script/object +func double(obj, strategy=_strategy): + return _double(obj, strategy) + +func partial_double(obj, strategy=_strategy): + return _partial_double(obj, strategy) + + +# double a scene +func double_scene(scene, strategy=_strategy): + return _double_scene_and_script(scene, strategy, false) + +func partial_double_scene(scene, strategy=_strategy): + return _double_scene_and_script(scene, strategy, true) + + +func double_gdnative(which): + return _double(which, _utils.DOUBLE_STRATEGY.INCLUDE_SUPER) + +func partial_double_gdnative(which): + return _partial_double(which, _utils.DOUBLE_STRATEGY.INCLUDE_SUPER) + + +func double_inner(parent, inner, strategy=_strategy): + var parsed = _script_collector.parse(parent, inner) + return _create_double(parsed, strategy, null, false) + + +func partial_double_inner(parent, inner, strategy=_strategy): + var parsed = _script_collector.parse(parent, inner) + return _create_double(parsed, strategy, null, true) + + +func add_ignored_method(obj, method_name): + _ignored_methods.add(obj, method_name) diff --git a/samples/client/petstore/gdscript/addons/gut/fonts/AnonymousPro-Bold.ttf b/samples/client/petstore/gdscript/addons/gut/fonts/AnonymousPro-Bold.ttf new file mode 100644 index 0000000000000000000000000000000000000000..1d4bf2b5265bfc9dcb92eeabd5d3691035361a9a GIT binary patch literal 107624 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 PH|o@)X;BICzq{yv!e16k literal 0 HcmV?d00001 diff --git a/samples/client/petstore/gdscript/addons/gut/fonts/AnonymousPro-Italic.ttf b/samples/client/petstore/gdscript/addons/gut/fonts/AnonymousPro-Italic.ttf new file mode 100644 index 0000000000000000000000000000000000000000..f6870b7c4e5af796982cc026e159e844c5ad8233 GIT binary patch literal 98424 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≺`{ReJ=xB61ni;WZBNY2Q_gY=S5D_ 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 S6E|)CSBUoGWXG@WbN>SdkO*x6 literal 0 HcmV?d00001 diff --git a/samples/client/petstore/gdscript/addons/gut/fonts/AnonymousPro-Regular.ttf b/samples/client/petstore/gdscript/addons/gut/fonts/AnonymousPro-Regular.ttf new file mode 100644 index 0000000000000000000000000000000000000000..57aa893826db03a74c98480093e5c9942798391b GIT binary patch literal 112072 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 AjsO4v literal 0 HcmV?d00001 diff --git a/samples/client/petstore/gdscript/addons/gut/fonts/CourierPrime-Bold.ttf b/samples/client/petstore/gdscript/addons/gut/fonts/CourierPrime-Bold.ttf new file mode 100644 index 0000000000000000000000000000000000000000..91d6de4f34673fd3030df55c98016ba84e5c8283 GIT binary patch literal 69768 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 literal 0 HcmV?d00001 diff --git a/samples/client/petstore/gdscript/addons/gut/fonts/CourierPrime-Italic.ttf b/samples/client/petstore/gdscript/addons/gut/fonts/CourierPrime-Italic.ttf new file mode 100644 index 0000000000000000000000000000000000000000..f8a20bd097284f65ea89f88f742f6d2278df9215 GIT binary patch literal 76496 zcmb@v2Yj2=y+3@;Gc-J9NtP_jL(7u)w&Zw4v17+cY$vv}oaNYLlVP%e5P}Iw*qZ`@ zgpmMkpcDvYgj))2fzm?hEp2aGZr3esX>S+py>JV}Pu}l2=h3j^0R4a7HdxZpc^*CI zx7Ya{LJ1)j{80#*GrO}(*=Bf@P(MDA`Z8X+I;+qiCIt@}`24sTzf;~)ONos*Ni$gm^^d)hTcOFQeOP^QhV{Z{WfSsPJR2dg;ekD+^5-_S6*ZDY_sfH7iXuX=}C3 zrVOi%F4i8iWnzGyAQJuZ*$?H_$_FHa0=&1n;@PM6CmeXI72tH67YFQ5M* zXV21o(i_SOJiDKyoW;}PSyIUF@hXw#v;VF9OgT*!kU=sU9iBf+GN&|15;2#iOA__F zBw12=Ea|DTIm09oY9<@AGL14dD3T-t@o6+ArI@d{MDAO-kdTFg3kL`Kal5{`b2?|w zY;B(54Ho&beL-)~YAO`C$BO($fnoMGhFn|HJC1EExh^6Q&)xzcoGRp`cQoQRDlg^A zM!)anP0zdW#^?L_bs3fUCCX(J`s=YgmxS-Xx#_4>0{DJxYESxAP+D0wPc zBvE3_FsibNxF|J^EbGWsRN79>YPhOGmdvG8mW-ey59p|z$dY_Gm6|9q4H+Pqs7mN2 zqM9XjD2EPL`L&$x_b4U9Br8%4%2j|?nK|bXxWHVlLEp8Mu-uD;S9P^iCQg^!DwW4?7 z4ND&M6>8U)&MGPl*i7$FtgfHqEw0EmX@4UsX$P0Q1un@XUQ$J7l3vCukO?Z4)Nvx4 z3?|ty&h&^;A)C^uF`b%CM)Rgrs;YD(1yZ57mzYe35n?cu82X~o>S~{lkZ5nTXHIAJ z%<8tru&>HjSrT%)tQP!8MlgfP0s(F?fPkh_R|_%9L?=Wdmxcij+qzl~S^w1e84>^= z`;z|8_UM8ehi3D?(s!LX*;$@5a;`JimgSYtOgMVV+GkXWe6G>)H=6-nL% z8EqUfgJFt$O;l0T5d$#dSNq)Jw`)IhKEZT;X$*JnDD?4pe}u5#;MXLfdkCVQkly)N zb*De<4>ko$QaGn^Y$g~e==X7aI&I+y#2x28CLaw(XX1k|6k^%|=r0mfK^S}0)kb95 zccdjlatfZY%-+&8G9%ah$A)@a@q|WC(~S1IKF15c;g+pd;S%DzdJgz zVa3VK6Q!3gY9F|mdKhR%r8nf=Tu-(=n*x-^)g%lZLWd=$BMHQp74I+rGXt+9ct`q& zqA8febfJ8%E|ho6hfT!=`Gr!BT=fvwcUoI+US2N!Cc`7G*1jZ9sB6KYp08%%cjs}M zcm_8N;pd*l>z<*n<~XRyQAPky4t#?I91lZx=_$*PtUgY?r`5H&_Uv3=$};VLwI{yzy7up@OzG*KjC6~!^-XHK|806BZCTFN z^O1H^eobA+pU7pF$XqVw*%Or}p2$ud_KLnZ3AbiacM$#btS|?Zl=8m&OT|$l7_QFs}k@mZLY&C9I zsblzw%useguFv~N?W1sdUZvIX*HkH7shsxYr)6os-(#*S@mCqEf8=%q^Rw#z@{eq% zBi|p$dn24$mE&$p-Al7etAU%>$#u$XMFMTKMVkQxHQ$WC4sf>I10g}wLlE!MVTGA_ zWGP+^B{J{eaXvdU? z)g4fp;b&9CLknXnjorMomtzaGn!;%mW;mn(moiMt##g~W#b}R)>y*7^#xwoamOzhSEifMT~0%RE}A$=AL{Jnfj zo->adUtCiDZ-@E3^ z+Fc*87rN<#JHDm;?ABY3ev5`~z4;g*@CwZNKPX=#MWi8GYlV%-aVPZ<80fM@VV=ma z&=t1+HFz=s>LL^3)=r$(ml>} zFa1h(wl#--m0GV6SZ2;uQK7u>E>pS7R+#m-G>6Tso{{mS`{9Y^18!lmJDO2N6&cPq z&4s9zVF0H=%mg4!Ab#-7jNiuaBI+eh%iMgSKYIyY1gQ>lYTuHmZ-l#3POWUgc%^L zl5yd1)!H>%w%LTHXLdh+c;P7dSuNd_3MUrFHI95vMX7Z-lI@8bH)eP-&^6iZ0YJ3 zE}z|G%W=Bxxf#`wzKdrrTAZDuT8j#2t#6*)6Y3Cv+TqAGmzIFX?gXtssKeT>C9|S! zwV)D1$OI9cXM=?(_ZT6vDYGs%nh;7T?uBylPlwU!67U zzNKsKT(s@&8~2{*`vKiQq1E5KbjP}p!|fYJlotwueNx8%z8URUaO>)=ukT-fa>M`8 zeea}A+!VcJ;j&Hr@ctg)^puQabD;KMC)AyZ;rX+oxO3sv_}xyKoo zEV}0(lPmJv+Xr^9>0Z3`hqr7zvEr6pGiI-S>B^NmTdEdCI(E)pKX~e@uKJN#ORt)< zYg9Sib70}RJF5bhFI@Arz5O>0UGh}5e``no$&2o2yP%=GtGIb>Q&+#H&fPt;enENn z?&yLwOfSE1_K!+4R;$xnCPi$r2O?8K+!8BQ)i}LD7wTGiGQ9=-K|yceA4xG9m`xA} zL^yKTLc?{FoN9RwZ0d|C7vPX#%72yC_|&%-TWChOQwQudeGF_aM}6n=y% zGctk}L)Ap3wA^Da@LIDbnrv1{$#cuSinYd;Rc6<|slA%zcI20((92U?Rwd0r94$0C2D;$5T-|BVeaI0D1 zOPABJ5T{q-Pddqt?t{AV`x16^=@h$K9*Aiera`qa@k#t;0J)azQ!Y|$0!~=~6X1lu z-2BZeiF*jl7GfY`0HTzG3E-p3Fo(*Sr)`-GUeenWj|g~4uSo}VsAyN2YwVUXJ8h%Q z0%F=#jB?hU{ZOff_aB11xip$u2$@+|Dk-X@$I6441EC4Y2>ne|XgMmlGSJI7R2hLT z@GCIb15+kKQ{Xz8az>6#8;aVC5%ejZQQTNl#oV$$S#g|!S)kJIV@6zL8q1EEb{z7P zijc`LUyF7Cg0W2O+fFyt~He)?FL+702B#t2>_Ey@QSmknJ1 z)$Z%7t6vMI=lN$XX=&{$T_mi#gV}D=l287g<2ETfeEBZ7k-ac#3ZC7doKnJME?G*x zIseIQ*uI(h4k=Yip-O5CH5p{M;(SC-jKCLX6B~$;7!WBKM_8Arl3CpZ%P^g$DpKku zOa?I`2)UUU5N{lUb~KF;geUvm(H8J-D!ha7bFL?!efdx{ciucg<}IDKq<;Y(yE{}{ zR8$J{1CdG=)dvZ4AsN#37}L~B<&aC5XT zqj_s<`;tpuSh*yp)NIYLd8GqZPk!eGwT~ZtSbP88M~-z~+h|f;X4%zrwEx;yH@r+2 zzIoNyg1nsOv2IVk65jUOmE(W7rDJBt>=g@F|L*>^Gt*4z4x^&IUG6RL?S8!fu1DX{ zzJ2VDhwNEWc}9vSB`0tFO9x)3d;VKnx&7G8!h+q$YQ26Uo&6rH(raN8M35otjJDTM zqbZngF(Nzw^UVwaX_hw-qtP^+LQN)LFR~;u*l`$k5A{k` zIc;&nG+~W~ywlmJG;XYW;l#*tb(!JmsBW6xCrr~DiZ%D;yY#VBVyuDw<#}P}(Jc+y z@8~tll@o=&Gr^b)VgA}*|C;7j{G)Te%yos8Sg zWw`^tSAOu}k;Q{6*1vk~#7kmrdyntcm-Z*^&F?SX+xE?$9jE3Sj&9ke{X;o%=as8( ztjND&<%N&0)!kBkVVWT_I`f`0TMvva9)M)L0d~@JupAmlM>JZ4#Fv`Nq!d#w5bVq( zM_fo^!b%-6!h}+}r_ZHOiGt-dllx+xeuC(+PDotPJYtc| zA61SNNKHb}D3@Gv-4A!%ea*;=i!!qO&WylM|8VHlP4`jH3&YnIr^3ThPBX7kdsc{< z?7U^$9@qYK=Y3DLMp7#B>;=y8-9Nec6}s|AvsJO7q^2zU>r|AbCe2nQY_PnR@ymKjux;uc6)Knk>1~~Cj zqgsjdVl7?C$H?jQ=B=P?Ld)hMYOSP~|6I1M-Q^_pRA zo7Nyg?>DhbfCaZ`opcLe8uw6*%J}EJNwn?Lt~c!etfxSVzyT_nOXkd)+13*AXJv=j zf9bJ|X+lSNWu8^z;l?`4+dsA#LnXdKsZk7BKJJ#v zO2qpH__}8f2n?=2zFuHZ-YlFAO%UA++Knsl&Y5n~z9~jlXd8bg-f2G(@eYK6bbixu z`V-)EHhC|a(*~TTByg&zFcORgRYz#UBxsHi#6VPK2LmE}78Dy$nlhY<%(D-v8Q3tx z5V?M2L7)SpTt|r z*IiPTK#PCkkDcdWt@95+4+}_X0$&G@vtR|BL-`sVU;h+Hc}2VQ9E9zgPUr(ymqH#s z26@;?7Djt#0ar#QE=s)!N-=5A3|$t5;@LHm#L{a305Wa*dr69=%P`zYW(SLcVPCK~ zl)@F>d4wbU#z-RD9}lRbC;+*cbA;uM1yY@WioAc%tv|VF&f!&094`JpUD!M>UOhEx zj_uT+4u5Cs2^x4|_?i-PLU#UAK*gH1VAYe_UvAxWq<_Y{0vh74_UD{{dFjRP-1<#A z^!CigFyyF^OB0~sK{6O!*c**V3Ne@a9qEX!LRq8|1!mZWv=kGxzIiw!T{4?}y~zC| zaUcyFpd3*V0*DNf{`qse=XA|(Yt~HxZ!j}PFW_FkJRM1ZeBw!lnD3A*gkxVq79^9; zZ#gk^AMX}qqP-@_WM#LO(Y^loiq^5+=G z>rlLr>Ip+Y?+cLX8vwl!(?MQD%2fv|GGQJRya516Rei`VF<`;R6tD`BA|A$zr&>6C z;?xlrbl#+NivsrvPyFF=S|AoU(JmHEQ;usNiseXmPQRSk<1;NZ|LlK52b>_~q&3j92M+~5i3dmQk&b{RN|>RCYfAmW5?^rgb4z$$?rpK8jF90V`*3ou zNck&&`0rfNrd_e)biG-s5n{Ts>-MXz&%RW9On?5b#-4woRy($|E6uKEP$y`b3FLpy z-*u_GC=_edt_9=aphe4 z;Y{(C&W?dpyO35jl&qVVx+u?IB*54{H@L#w(d+dE3i9){AAJhNub~elLtYu;6oeQy zqaZ^TsM`%&22e-v8urRK++boDh9hneCRieh&4|bwgf)Pmlx|fD>Q7M5`Eyd4#G`8e3Tj^Y#dUl?pya_$~Um)}>tfYr5i1t8x6LWV_KGMH+ zrCj=9IUpg(zi|{VLH4DloJaQcka?Z$jBo-hI3L%N=aqUQFp8p~PZfTQ;%p$iI^~~y z-L=<*b-e51Zu@20_ifeqQRBu(wom>l{BJb^|KH1T$vbIxR`t&kK$(Q+x{25P1qFVo z>CE>gjq5g!C2Qh-X~fIzS6yuAred6Ob#&hRkCQ{**z+ih3c7+o(#6 zDxgpWSwKvVFv$qv;*J)c`>i0FULk&lqFInYZKNdt5Qh=djO$$vX8b`^YpAt-UCdKWE$X`D5Z_~jp z@5~A5?>gInF~(qjJP7;423>Lf3@fWKwTJA%f;>#L7AG>S!dzzF6|;(&{lII`n4}d& zXnuLiceX6-8T|X5hxON;kG8hWnsaE?M*USeeepZDT&;bwdDlVqhN^gT$LQiE?`(yo z5PQXwGEe1U@I?u!C(&rDpDJn&kj&FLpacWi0MA%a;S`^%-0Ew~OL1X{DY#-YuO(n{ z6!!F=fgLYgW3d#>{L&Yf)Hk%gIQ~Jy`vN5sKNZ3*!R9XQ)PFoN+-=Rr&_Li`CyAOiF8yqCc*i0z}-1e>Y`Qfs< z*~MG-nN8k2XZkO8U&$wLeV}>v+y`zNy}x;O_x(32r+56|hMToNY*@ZtI^Z^$Gjj`7 zr`757TFL`vb81SB9P;Mc(tl9*^LuWlPRzPvL0A9Jx8L(9UjB3J2s~s#cbhz@mqkFvlcqVn{F|8pX1QstlPTvI;yHwV<~f>0;8s$gdf*|q!B*tk1x)dm zrb`>qrEQX4cO!)P#DTh!4J!{Hk@m;5 zDJ559bsfN86{(NblmKs7T>yey>OnjOuBtqYm?mFg%zLRK6+Q&0SvEAu@Qm4F)2z&v zWTUGhTQzUuJ?o6}vP#3L1^SZqh}T>0q(2zZhx+2Cmc?IC=#$?UPc8nQxk28QSjA4P zVkuV9LN-M+!~R^XLa8au#9joJTXI3Oz-q$&6QVG)Nl}0>gQ2Jw^eU{T0%T1nG0^cT zv-AnVXlfx%u$RLAsYVlDdI-OTwI^dQ;dBeP$CiXywN2Qf+AC?5p+VDt_Dj!T$WJR8 z^tCS&ueX&@Z_W%)fxPI$efl?X9G|fS@@Gk%6aO}=z&`~x?@HZOcKgJmazF%t!l@;O0$V*Irnv59t|gFZw6F^%0Fma0pF6w`sRc`uu15Me$ku)xJer#XBYiPU}8S8)=Wu zY%KQ!erjC-gqt%1Dg!k~1{Av@PyzBf*O+7Wb_`~d>}@)&eEUrB2uCKWwY2?Nz+&PN z0iK^m|976gZXFaOr|9ffeW*IdP!n%x$0sfQLP-aWzVr?Bh`w}6c7bwk1#eZ5?r0~L zss>SImI=x3Ldac#Zx=7igLT2{?eu63{EVbvO$90QJ0pH)BItoM)pX8kB&p1WeeYE+ zaY<_0nO{pO)k2Q9F!3&7#cG!9*6ig_XQ;eu1h%DLizT`;&Mc(qLXK-s2%ptym%scG z8$x2L6{4MzA8Jo4CUqsrCw0+kpi+*9oPbIylMT>b5?u=2&(=XDR^XaX+;E%{)j6PR zWS}OIIN!7;|CR42(oTOw=ZLLE8jC8>Y(|s!sVl`!qK_{YuMF4*FV{D8hjvUph^o~r zRIR4LEJJ?&^Hr^85lcu^tvXqO0~1FmaDeGhM}Om2=w2H3xP6Ltm^OIS9a)(lT`wDQ z3bQf|yV)zF@xK8cffziTEV6^WeLMt*fEKKGzys45JXrEh6#N1n2t&l-!DL~a(I>^- zQeBevCoEnY72u$AKGII>ZvhVmfscMwR4Cw~UMpVlD~LsXs8HBvc_j3dVeRZ_9;>sW zJute6bO?_^_5dw;#GPHDz}$MuKxVVNDFXmE+98*@?auTr!;GAjYkX5KblM#u(>>bD zCa>LUb>yeeqZ!^j<+Rl{@s!bIEil2G`L*UrPg4ypOL~U1z=moKdiFK#V&(hVS>Q&0 z7QGgFDqwaZv|z(hGV5hFu-JR%pi zkFbHudQAqSj7qUlh8E$~v7ZP|GXpro<{3Vnj$+L$cp-k-mo%IC$7EE@1s-E2mK(Q} zWVF! z?pw5H%PnGW;Ht$JtQ&rE_q8Iy%8W_3~ z7+S1)NDwiD7X?5p9&n;!RVC0OlFTeRG-*h}5OBeE3HksQ1@S^f3Gnn6cdyHYbs95v z#7#Yzgg7-aH7rdw-MnaE+9|LFlC50^;82K=P<^PbvK)^cC@KoV?2YZ}U=Rf_^1}8| z!q15t0Cm<$MVj0HiNIk=ayd6^NcS(d~*49yDxlT(WPUm zhlvcW`QG6t_FSiZ@WjXfEaYS$mZicHb0D@^hjj$BP1LQ`H`@So4;{)MbG9Z;z@dmOPstC`TYJu zq^OEY0)>*a|I)E%H_h6+XvL|1o7L;g2(9|BeA*e2Q&b)R2{O zxRi|4?EckbU%RmHl8zaX^kSDi;A)<|@wuJ1Q}w>?nO)2)lgL$A>k&{<1!<;6v7ap~ zgk`9{Y-}X5vh6I4jHZk+rWPSdKb9-vQUPSd5sn`LVU_jreWxRgkPsvQyE2li_>`%` zU~E6XinA$7lW`H-*jI*-7idpakg%P6_h~MPmP|Jr7@}e_O!?UD8NWL!D+#G=u54qOG`V(o+$Fs-AZ)GsVR&R7`??^}kt5Yzdc6Fj zi6JI{eH>8Mk${EAmRk}m_WM<~Hlxa71`(zRgyxH_i;L6oH;|k8{7Bfid(4q$kr3fw6l@&u}$ml+vuQA=gfGouEf}wo#`w{4b`kTx$7aC zd93H);3h+LW&7d<*RNn2@osIsnx+WX;V7?e*4u8<+ zccijxX?zP=knPz>7-*bV#a0IfDh9J8q%+B{tiP`L837EV1P|^GZ`Y zR}9Nmv7zCzN1kW=*{`iv)&tjNWCnRDY6TO(q%jyhR5934^cahtmZF0K+p9XxxP*+D zSl}O8PhY*i7fi`jVntke7RRoDLyLwC3W9veS0>GmmQS4u!Ybn2u44O$szUH3rZc`O zFGuQfMmfs9@!X|F0Y^yZD_)``GL}r#CBVz!d;SV(dMC6dm+udHKKRaez8ElP7iFZ( z{qmx#PuRTk9va^A$jZzAbl+vi`uFbG^T?tb_sFMKFVThknVnC+)Rj?W%ZaES-@%Js znmc#J$+25MzUz+dPmOLFzv#&oJH|mrQz7ztsU@0 z%|+o7sFH*l0r7ENnUwq#Ldq6XEWB_`A4_OZdd4L!9e8f_f}O3#MY@nW2_ZGCcC;`0 z;w83LL#SASgY=r7t$$iqoz^vLqr3Y;K}|3AV{|LIJlXB@E`0Vv?P1|6#k47-+7BS1 z%G5#FrA_2u6j1`G&w4w68e{ho7Jo-58L%gG1a;PIlO2ODvoS!p2}SBgWL z#Qdk7ITX#|mC{Yt#@gz#5}zmEjR&wGTBvsmi5nG+dwJDvJe0-&8j}Q5;%?Ia1hF5w zB2vv>DkD~xw8j|insHHEW~L?2YziK^{mL7RizWn%(?#lFwoA=80J}}RXmc5~CVp9( zGjm2!$efd7xBIh~9@05d#Sg#NUFFto# zcqL}W;1#ykSC*HA{64qqv*E?G#T2$pu9=`yVf8@aS5FQ;-IbS>>#=6GUEeV}YQIez z(t)K-53DoWpL%j;t=*knP@Y!auz80Z)d2-QeGPni6nwgf{4ko`CrKu=Ed|7dlo6Rz zimm=kAToVY16$2NWWzWyDEPM@b$VuGFqjg7Nh1sb&>7ol&nm_fyZNi8T*#D)35^&w zo$s<}-RHdmWD7~mtIWXLa1*hL0mj>n2>ArLHiAkv$~4ZgadpJ&Aw(*`IVqnK5B!T_ z2uRg)xL$I(q=WQ&mdj=#1s3iB79-lI)za7O_S-Fv%-m288}<3h<`;WQ99CymPDiL{ zFyD%rF(DDI5?8+?B*H{C^$VN`6{fu{&&uy=D5=US6a&THzUImryW5?UovwX2MLYT#XN3_4`P}?XLer9>Ovuz3=%j?9NL7nqJosUCX zFD9=F^VNpZb-JZ^aP>g4gih3Evk`c7YiFwJ)CJymA zV(VrZOUU7ZVd(mErbmlewm&wJOU=YIURBL^JVJ5l^thNT3WUN%;bQ!s(PL~^uTE3Y zE-WvVtX!rUic_z!pv8VWXOhlR?%=fc1!$g4YERWjZx)g=oXjqq{P9Yrqd>D?z)M!- z>S)JOC30;?ZGV+`T@>a)EY05Sp}V%I9As=3cOB&FZDgS5&W>6$niH znQ8uefwN`6Squ59?*D`~H})CunYbUT1s zU<@zvL)T0(1ll{24S_3lZ~AEzlB)?*MZv^ zgfro>Osd1+9y2$iVmsXnEd@D_^X_z?v@;M}-78<-e8ZUs_KCk=8EL;_*%tm+KDFtE z-M4Gnz3hcb_uet~!sdmSc8I@tqO%Wa`;^sqq8c)jyrW~CMe5b66v?RY(hH7tjF~2l z=~xe>u-uS3VrEtRz@=WEP?D%S48@JXDn3_KGL-d-3w08h{<3I!qAURrV*a(DhH0mR zCY-fsT~a%AY>ZP#SGQ?q_Ce}Sa z*~Psf9&C|M=~0&DecBEo7wyi}jG{utqJQEp?j6Yy7m3^kd@wJEMH|PX7Ut!6zz{~4 zg{MqJAj&`4L(zR39p-DmKn&)ve$H`Drkx2lWm32gRhHqRbKR6UW5snvosHQ*FcQ&v zVbVTM>Hp4&LZM)g3$QQGjzy|2ihKU@sdymjllv2}DJrB_@<PU!QAGc>QIGiZW;9cif*TGPcr{FV7GtQ~ZV9o_E zU5%G!2peruWd_1|K9-^~=iR-3{>Hk-hNji?MynqjeC_y_BXyHImf7#RVf2#P#`?M~ z3s+XL#${KH++EGuo{3-|>rpn)QPP3dc&X`Tb5>@}4GihY~5kNV{N*3~Cp-#{U{4=;)%n{}t5_pAv!ZQOj z8%ZQsRE!FSqImg2QjTjH?~1Vwt6oV+9+tS1_7zAC^j<~|2%xNsnmha2kM-&P)v{L> z-+V(#^bJ89Z=hTywsA?XpVjWDEb8irRO-G}ZQG&!rEPS(pb%DG9QbXWJAHn!<MyZk5T>Ppk^VIUM{1f~le0T&=R3!({=dYB>se_(P+7|lTWDRc;Sp-1Gz zqGJUG{^Z)J7%xoxX!-5O$L4tR*X+A=_%Bl#;yF6DSYK|OAivx%T- zQrjjr6;4;8JY@1*cuMCfBbhW0A~XZAoVJuiC};#)SUgatujEn^_Ptk`iH<3@iP`k$ z=p@QIrIZ=Hz6l2`6*WtGQEN}`pYo<4mi(-V)n8^Fs3GHhQAm<+kxqO;jQot(k-Uz& ziQVc-?EBst&4iv+t1}V&$Y-ink6XD>N6Nw)tgab_B>cj1=p2SJM|$a?Yv#4eHTQA}9 z??)}m5>?c)=%o@OkoQ>~*b=oYSced-czRyH(O4j9?~0Niie|5+>JC=Y^U>oXN?<_c zDwFVAfD;dJ(!y|(4?qGZ3SufM9Dnf$ZUp!MZj`1Y`i!Q2>vV8SrEDLC7alGwCA8R$ z&r((N?bQ)SR2?VGYfr|BRfjSPcma3($39O+fbi2NqlqKXf3=R2Iq4Sb4TtG7rqq<3 z`vgu-y^x-gvgI;?liTmNSX}S_SbJK>$z>Pp89xD>obpw)HWjTM7C3qESj#N5s9C1t zTgMC4z3l02)Hi ztlJc$M_?smVy+-2OBx5b{=F$KUo)T>JBaLvcQS;7^|-7 zYg*ghI4_tqApNSe*ymYf%gV{iNbOlsTI}`4Ki~mSw)aKZBR_(kGI?bAGnouYz^Lf8 z4UWV18En0ylm{S0hn$cMgtE3v{7VFt<%5YC6#XczymwAsMy}qfhVK>$GWaiR6L^extUd!n@#usenx(AOeH+Ck=%i=s|Q z3uS&`Zce62H6qX$srN9@$0<~QWQ0u*0_1QD=_VdMWr^UkK6H@wvWieyJaUTuOir;h@YbZ_g^(OiA#-^W7a*1BekTZ8@514<$-#W7VCDsd ztUv*RG*->9YWeP)58AU>9m9f`M?IonvuERx{wv=50&C6u-t7ZhM|O#p%qP>^t5L8p zskp)3xgu?1lXXZ`Hq^~Be^oSRelBzCqZ_XKzZ01cp%e4i?vukCuCq$FVWs5Ov;V0? z;Ond->!PE;YYJ}|yrd9m=z36f2+ge2o^EQG%K!-Ri)1P~T(Pt&q%lnyVVlKK)Q=Wo zBP@!~6IOaNW&m#;S-Wz1MW6x}UvaQR>`CLEazeU-#CfrR)8UL;dR~LRp9CzyVd@a> zHH39A&J=jZMRLO0sbgPqmr|bha8sgVZ`ZEQwe=Q@O{L93w`+e&e`a=TVFM!K&Ol#P zN@_-4N}9WUQ%zodu(UI@alhG=(zt~zYEMO?8~NwL{hox0?lKE9os8a%BPO;%w6 zy>y?`oPstvg$8?;!|t(``Ay~&>^jNL%5}Ta*FV2mOv}h?>?<33Y#S(glx#-7nt9Mp zbIGBoEnI_GTgYct&}ShByWkD}WW$CXhjaUd<6V0yk2vf(`8kPkrz1Y@ z$~*J^?hQ*1b@M;+N4Vy|+@*u}wjCDN9P9`M#%Qqvx}+DDW_ml@6TJ!|FOmaohB&4{ReMrF#gKZGAGLs1)<`IB$jnHC zEt)=@Ws%a;vCkaIFrG~C8<;V=k*r^{dgby(Y^!-!w5^qIHAkr7{C)V7qCwL&pNTa{ zgo%ZWqoC@#y2RT!UraV=^*ZL$dh!1o*Hb@;6-d(FDxF%{T&lgLo3&-VKNRn-SpRv7 zo!=7_t4Estnr!I*RoK1ySNcRTK}(cCgA5aPjGqkanQy(rmoO&K5f5UR$k^!ueI!f! znSw#`TMu7m<0DBN^dN!2B?--Dt$Gu%Sdup01S~F=c_4*R@uU$MM$jfZI6s8y8}oVjNe1S56Z63AXs>bZ#HcR@D%|WmlVInw zU8?iR+;DwW1$yU%jFWa!F#?0oWG0kT6_zfyedCsYT)lx<88gS~WVtm4HSXn|(Q&Pl z^E$o`DYIQHc*iQq9sjd%u&Ra{4l8Mk2Mnt1=waDr0i z*wIf7je&C1n`s|6`9&G}tHLI|va6$XuJ_rMSGw%8R@J%lodsL=GAjF-`1%WpucP?7 zfPJmGTZ#*7bDs@W>TilGnC){nIyUyG#jt(cq@G)ECE#`t9-%}04a^=cVEd=(1{fDY7Zse!76S=BX?*CUpJCr8JjSeqp5#sV!c(al;71^ukU z0CXNV%8k&RZbuL-OaCPr(Qky z9y%=bzH-R}+MgfU`Q+$>H2aYqPmbK3ZL{TP*^7-?ndo(JVYqiNGs|dqSktVo6kB%3 z{zd%{H8n(lUcFXvk?Fs zR*%J2j*1wh0%Ua@goDj$tYPW-rZaGSp4&3u{0p~b5c@p0W$^nKZp(oBd2Y)<{JC%Y z*>{X#A(~xUiem^OrD60N8puuUk=Je;2x2PFllrxwh2VvlvcJEeIr zz4h89g9qoYdVaibYks;RFX+K>MRKuU(eAjkW%aUoJEKE=(%S57qs3d;I-{$7?$ygT zy>)d*b4Q-Tf`*$~k0m1z$Q-zKVENFJ8y60&fR*$;+NNA4_mUh^9j&m!I+Ehu*~noK z5zzh&r7odeny(!A4OqEh?C#aUlg!{mKr3A^Z#&?8H{F18Kwb zQn0(LJ?fe1X~llx>dNxZAqA%-(hDFHlTBd15P7;MTZh~+w{!jSWiPC|NBiW+-WS&2 zOAU7)_|g8Jn@9Hj@baFU*MtVj7tHO+$a7?5W^P<$Q}grDz_~{$$iMxzWi#6=D%Pms zZ7*GXLi^)G+rDw}3F(ZIq=M3Ds?CR=;>_nUe74_}F`~k8MI{lx!)O)p>KUk+2XhyL$Z&?XR>w zLk$E9^Qc=X%$ayKSV=GM?dY6Ux-4iF&-5^G9cV~vmu=*b8d$#&Ef)4+Fs5Av_d08i^&+71xRSL@qJtmo7*G5_c z{`&fWv&?K3$92VQO zxu&#+T{UaR7B8&#ODPqhZ_b~&Y+kBZv|V-1yuDKm@3>(0g%)WTtE+a1jaO+GD6HF z69ddiOICm^_{+x>Y!SX$-x%iV`_@Rq(!yDKQQVL8*AaDoU(Xl!Tchl={0NI>pLtvC z54(AEZ$X}Rv+xp>Q{r{vodRe3y!DT-quWKK`+KM|{w4glAc;ilne@m-4uYKzp*LN^ z(4+=xA|Hi~TG{?=|CAnNF_LG;?J;;`u{II=L+<2N&g8Q{6mHOm59n{cu;Iwyg+IO< z8Fan<|Hn6oCslXF-pLE(Ipd2je0D24Z}5-wq#Tfb1s#}0dg;@|{1lk$k--QXO!+(k(b+f*X(_jSt({$hEWNwt!Zl7 z;LoT2t6gLLvwREO^Kx=bI87}pTgtRm1R^xgtiEw0IDU}6EC0J1Azs$)&Vt|#Kb{6S z!?F-RV0E&!`nfEuptFv1x0iTA{-Op$+!TxHJ{*4-k8JT%S+IjZe$ghG>n8r&!Ct;M zdfJxZ$~5_Cw>8CTS1$dgv$L#|fzA?V~wt(S=koOFa%i z4ySoB1AiuZ3`vL_Qm9HZE;cJ5kQDqw$5yDxi=Z^oehj_X(^J#r6oVmUh`&iOjADC2 ziebPVZTqx47-3F+`VG(sd%=R*+6Da!`fK}Yd*^jq{Y5#s<^Di5YlO{h2cS&I+;cHj z3x_p;{}Nr-8PVbBFGv|YKkHV`l{K2xb8{O=Ml?;TF4fw7lBx8u{(CagovFrrYE4hc z%#zm~_es(w+Zm(L?8-FT<&W5FW^V3Ew~}AbWO8e-W!X~G=@m9#HV(vWU-`WT?SG^% z`;?4&`o>&io;4*m{R$Or@L$DHN0uvP;`>ToW@b*RRHNigN9^|EBRNi2P6pj; z%gVKD*V7d3L!^v=wPNMCjog)uc{|7YJL3iB&YF^bV-R7~TO zxo(0`m7}({_JZ2c;nmBQ6qPgzgtN{V|8EG_`_2nODLS7u!n`e*DBOVg*GQlshdNCq zn!hke+oFv#BL2CaOeG&FD4b4gZyayB;G)HAeoNERl!Aiuk;CpO)f-s5qk7(>Smpe&jJLdYiHheM;&8D2C~f`7xs^`JQQq|KDyI9f;kHm>{@Kbo^89YSI-Idr&C4^F1dBD!|TQ z-M+1VYyXxDM%S!fF|=gSyt%WY!n|u>=A9M&xP&jl$bi)Yb9H?_6K{%*$J7_MX>rye zkCP=t4h|KDUw9swgQkB{)~;F2wNdwIU3WM_Mhw>8Xb zH7f;$H8e}MH(WMD`a0x}DM=3HGHHX8il-4o+H*f`P!GSe8$8lfB&pgDPX0E(+mt-h>tKg-AFpl{**D{Qxa^o z3}&lMGiT@7U!G^qw%C1W=~?YObF$-es&OBvZ~j}#q~8k1=75Dv;y%)p=P|0WIkfWZ zU&;H#^pqq$`98aiboN^iLGQsg;H3@@BJ!uV|H)#r8PsL?O)dNK&gb|Fj+7ZAs^9 z$G!eKDlP|+c~$VY@>Ze`ymn^R%OcVC@?2_3YX6R=Ou16{7ZREom1_X$4PfCuQYgZI;CW6A+a*XvO>lhGppPwSEzBhVJl$ z&V@73g|o8Jf=JK3As)<9Z#Xl}WHv&TtHf+n&7c$CaVJQR37m5{iP0G5iultU1?E3}zLOlj{-$N=`CJP3wg(p9_xTTb zxF~%UJ)Z}1f7ZU&$KxkJoIT6?l%D3i&JIZiuag$eTQtGz=girO%srC_=gwig&hJA@ zN%eW=Fg_N)wJA0y!N;N(IDejU{dsE7xexCbo-}7Cv7BcPdmertJWt-Vb2b{-^N8Qt z6q^%!9MLN7uAUTV2w!h13hv`)obaez zOL21(wlG&!kPt!Na%|^Gi?ww{CM&^_$yM|T=9GA5%b(Qy6>rZuQKMTg@V==%))Mgb zTz;-b``1Ni?(5xCkJzAhi(p)=7klie4edq|z0)=_3Sm7E4NOAUFpSV@lFKDD!@e$| zMPFWy5$sz^qM{^?an76=6`ebWVU6D>j@<1w+`cV2)rm%K4%r#52l?o+nCYdX4=Bzncqd%uo z)K$C{Ou=WscHto_t!cjf20XywoNP_E-gw3rRahhVp9pJ->Yt?8~zr+eZou@~lH z40SMaY>Z+I9#z}fZz9+FE-0rKodb48?LL?&Qfo_fRSrAJBm+^OSecCnW=b)7uIM|$ zQQ3sLMP|U1=q35?D5kIq1jx|C)6HWiG-nnUH`Eo^7T5SI{AEUc`7FmC>y`_N7q6t@ zos?^xJh+IeAC_x%(x4yKC9^Uc>O)ldVfM!Pyr=SsvBCU2M~=t7aUTEt;6;P^`Och) zmsoG*d}+h{3$?#&q^`(KW+9VSOy?VC(lr=V8YxF=BfMugyf)UfCpV zU_E$ZU3-by%=ejyGDl??VN7(GKpeOwT+bS-vhKa;AT7H0f_`C|a3et1S<@N>3Gp+j zk@O-S{Cmssiw!q-SJ#bw_wTOX2<<=dq0s)f9e+e9e43j5Cz2|-pSc*F_-T_aDKp|?d z8!Czd<)V!t2V~s+g8dGX7q$Yk?-2#o50^9W@*N?~ZEaGWyy~vr-P;zeT=Di7E4+cw z_M6&vusyk8s==*wYlqigYrj_y4NcWH#0yk&d+KMt8oM7+n*aOH2Qp z7|n{0R{th3S{xfCo03NVDMlf~Du4Sfv*D%Z&%VoJyD}*Uc8|%Y$Sg7sXWOA#vyB=| z`K)}khgFKeqi04kgfB(1RAptH5^CZzQzdp%U4|J=Ny~cEP*)`bxw2d$_syT*-i|V% zrSq2#_P5V#pW8Vb_l|~qMNWT-%^!?g$)I~Lgc6rWv3vr?d?EHn_+8;Ty+}JANo9VQ z6Mx`#c{xs56fw5{Dx!q;q@g-qyD06F>Ls;yM~2&+UNq}q*NMiK`xnmM(70~J!8a6h zP2yVyRI7aI=*=B{-u#}%(?um& zmQ1_dm*3EEOGj^bbk^v}>MloZQDb9wx+lk;?`){qHKX~~jk`i)ETYYSf<$vVH?jU(6pg;s2JvrMbcYj_{a*!JkgM4vWrDDU~j zIkY>8L#K`k4i%$}L-|}<`XS>*G0J#R++h>vThXZpoKM+S6B*w77Q$vv9+$|@!--Mc zna`GJ={1Q_+*yp0O-Gpwxd}YHPi;T~po2UTO)vANAxc6D(P)`PP*~+kahy8zHXrQt zPQ67Nf+%Q|Jqp?nKId}c;nu}l9aQNegI`-Dq?a-|0p-f}dW38qB%v_H(tK_jYH(x&X z*s7Z^SN=X{nK8#@%`CFa`my$_B}0c_**N;d*bRTXr98BM^N^w1nHsRPgdElayQ?B) z;<>etuG@ZKKx zZlo&`gqh%uh8cAjSTi`5ahYv-~ zp`t)p04;4mqb$J3%xk8Qk_nPGB#0NMGqaj)HVA|$lZoL5<=X}0Rp^$n^!CP!b6vSE zXZ`{9aS8wEcAeQ{k^FNmLjMfu4$H(Z_&fO~n=^Ow&{oz-qrPSoo8Pi?oEI+J##(Cd z&l6uNr{4;rt;RPhv=;Wt=!40bS)A^c3A+31bfY_eofu_w$LG@0pC(2bg^4?CdJCgs zKPA8KN`Bv+8faZ~@=!gzlgCZbtTOERH=qHk(d2PrTSshvOgR9Kb8sMB0%)mYGI2Kt zfHoTG2oo`h4heh*P$_1L{%xN*d208KD&BlU@4f+4$xL#@(e)W!IHq(s{Uz&g`dp%Y zv=1`*j+|BO))+1+;b&)g45 z_OH3+h^nlZ<+zPmczR5DW$a2?e)hxZuT=Y>HOha(^aZy(&wdY<2|F7XeH_Rg(e$}A zHLb0oSe%V3Htv_Ps478J71kg+7b@!rGCji?dT7-k!@e0YqeU@gJ$RzE5IHR5G9J4M zzw{XwAvsIPKtCR#cTVT*_LdnqX16HlEeiU@@p?|12(!Z^^y{)e5@DGT<~8vO>7;Es zp?~!V-rDV(e1&x_redotxVmb=(1vvfh1>M6pUJ!I>TrGmj#09^jOmu4xeM=FAl#`> zJEa$$pMe3^`FSR4F8o4KTf#V`x6*?OvjX^7tjDwPl_rmySj!wXq{gRWh&6v^;?K*( z9qjaVU^-=l?M-9NaLh2`AolnVQm zIK6eZ0LZ3Qx%_Ph(eP~I==Fibp8q%Ae zVa#I>!RccUn8W)cb4k1tx?dt)++q}0vgilD648%yW5eP~Chu_#EEQpyiYtfXS5{1o zcf^0QKYnEew`s+dJK|TCk#pm};y1S;7E|_T?0(|EY(gc`lPPdEac3U0HEhH^&^iba zOIBPoDW?Q2e;J~hzlWBor-dP~va=ri0=TGv^Iq!MT zzC7nS&v_QmKjg{?(UXL@2?!wqnu0&Be7cfl%Ty)HQHzeQTYvTP;TMi>IP9!HE~!f& z@l(;}4^!O9De6^G**BfGUf$5xzwv1EXusSf!*wp#wsdc}cl;=izPr1XUnsFXvne*# zf1NWS9(PDv?34ZrpBdVD;o+zICoZHp|NkpWe^6)+S9@ns`j=iN`{OdtG)ljRTjUr2 z+e^=)^=sBAxrP7-Y5mu0sBjjSH!C@K;%iV$)(;KtTyjMxB;ojBH+OahAMECYdplpJ6;*K|hE zrc(8p5=o`HB7?BKgHDtc;ptUo;;JdEa9QNcscGk#hx; z1;WU9ptdA$;Yn+3WUR5PaYg%5^msiKa?$E?Of{Q2>k=ax6$Dpltamv zWM~%WS@nH!RN8i3n5MU=mOFYjeywNX57+cvGq=$Hq9jD}xlw^7hk%rAlQ-SI;?iB- zYnG1mt6lQS==77JbCjoT`IbM%L8Jt;d*F_-h*<;<8cx-hG!fcWB&DPX`x)#r0|O$v z@m_v~$F>gCvDlD}acMWcGt6#$DXjWpvX(4fw7?oLVIQQ=22gBpIDRG* z_Ol`A!F4djI_c*!Z67raQQtf?SuHX3jsHty_dS=*pAlaVTz_DKu^TZrN%wyhsA{`C z=6cLdV*zd|h^9tEokJH!MqstU(-GK#NJ#-syWsBj0?W-OrX+VDUO>4v@)qZ!nWFc4 z%=s>t%TeqEnJi-_8v?UozqEzZ2LI{C1rq01oV#`k(%X0Lver+xHxQ9q)Um%Tyx*36 zxy?M24T1nP5xAa!CcyP90@n+_ohF#jp%3AU1R28dMPb$6KzJ@>-+(U`%z&*5t^InU zlLEs<&n^`hvP?;*VwuuC14N>fJLRcZ;MUvb&DZA{f;LY@QK-Yq+;O_k!84T$pJe(33Zcg*7*b#FNRo} z!Y{@Ktq0>1_-`X46|dQ-C<(oDpsZ_O%U=Wqcq^k3?m$BL(98x^|X;qd|fJ3~f?rge6`mjYvu~=>UklxPapv zmLbSCA}LG6As@HQTedK^W!si*BU_R8ChvxG*M}>Vr~q{ZSd7D!9N<)=(Fm!I2;*Z3 z1KMFcY+<4Dyns|Iatf>KaBYh4gmYJp;pOtYe6CQ^V;sBs}=oT0oX zk~E}iDm}z~ccd4*0692!noJCbO~$14Ey9NL!;(ZYZh|G1P}1oMXtT+MaK0Y!faIwI zWoZegMu*PXPmU>-kz-*CUF7oGubXwXFLmW$a*(oXy7oI;9l48$+~HT|!4VFd0&-D@ zPbsm`L6yakRGlw|m&{v@3Sata~_)D+kv9mp;v^Mn6`u;8GKKuA5dd8)d0ytzvN}M|iGwS2ud*AXYJF z*8?Zmgq6Dl>o%$yXRpX&(*6=a2^_csCo9-PL?Mty5J=Apoit$VS)8VD6$dRx;2t@I zt>F`+LK6wf1OW`ALNrn08PPaQY2AitfBiJl=oFiO9ipQ@JkB%FyR_Q=au#;=u|%%8 z>A0T^_tN#v4T0qqu*~~eFsKjEThcbk3id~dG{p(#Zm8O7J;VldrN-nnJpyo2?l#c3d{vlH6pUB6(G+$0R2wO$ zYhV+lC2GaN@^Cz^q2%o(yhyAXUNn90!wu0XP${ahI&xu^ z;qP)hEXxZV3e2)L)`31(Eoc-p=4S`PT7#zX-38=>gOmJ_Ni*L{5@E!?83_UhSG;wr#Jp5>Kj3ksQ=>nJ|72y*?StJ%;`|&<)sXibV=IZ0C z<+9{eIwqntUz2?7^7{SRkYK*laPx z@HqrhVcyPJ+oH3`uej*H85r}ggzX$Bu$t}cX-~==3z^#B!ySz-a2Y~H5fr6|Ov6;O zNWDoPX*xu^ANR)SqS311B)ftVzXhEYDhb1CGMRWdA5`lU!#&E6ro2wBO;xt2>lW6;7!s59 zJSDYr>DE2^bN9<}d{ObGD#tTVd}rD9RdZr(j@anUd&tbs>)J3^OtseiL%zH69Px838Re0+VHSY^1KI?~F`dVXH2n90vvy9h zuk;mh9?J)a#=XN@L0g)9Pj3Wd$YR9^rL)od;+*yj&P-%uC`$;_QuyCQI8l^(#ofqU zu}6=cX`fz_v}|MeCD!5CnWs5n+N4P&4AUlz9r^c)a*kgu@uler{tXn}OA9K^JSdGAQjsIs8!9QPc3SP+6^6ghcd z)e`oZrzy4839eq6w|d=-=9+<)hh$m9A&Ra~fQxr4??{PDOHHu*|FM++bAd58KPyvd zg4*5F7fJ|oyy8nT!hf}C1V^PH07CrFZ;#8dC8Q=j=3mEK0Vu4|5&ki$h8HFkN>|CR z-w0UlroMR_eMbFV!@lH+sv^#Td_CX>;Z3yF7XY}>=6(nh2LBI=O_~^#fJbYF-*kbi zOG2QgL`FQpL9l6hRB6-=n!$5(bDf1@M%}`?Ph%*e5Xp?BE$Ye;|52C{8nRu~@@1{- z&MY#XWyL7(YWeYW=X7&M{^3E{FZcQHIoq(&AN%CTyZKKfw57QyRvSrs3I2ZYCZA1J zmHbG=O)BpP!IdOuy|&trQq20_itw8;>&ZHdI7bh*pD= zrqF73V1#cISaq3Lv7;J(5YE9MxSRy_xC^NjHY)hyDCPeccB6EWl9vWjhVf}r%4Z>4 z8sLvA6%-qY#S6)?`M{FDN}92`F(fz!CMV1;;;keQf_VjzF=)!u3z0FXnb;(xK>}Rc zbbux?W`mFuqi&#?2yrFor_igImqfh#gfu`4D=MH-d`ZQUn#Ewt!kI`2g+)OqblMIR zcAy3lKZOzkoPkJq6z0&F_LHrjQT{9Gq91Nvv10k3ujlVgUUOU3!bQgpAD2t^6J@=& zJ%8n49=m0D&y^citbBRorn~gIW0*6n4n0nM!EQ9BiS>9^n^gk*xeMegaZg6Q_{{aQi8U1HY}1U`*3D12&4q$ zUyn23`Jjr9L9%!EcAS;X%jy-y>&o1x@E zElZBcam)6eJqvMU*s*r3w60~%(>Kp9QkdQ{mK!Tkc$i*7i(T1p1W0`^;k( z8ajflwAF{kZib+z-4$G|1S_V? zh0Fp8_i$033Qrz$e@f2sredfCLXBoU9mSL0UwF>(fQ}1AuZb3HU_! z3B=oTHV#1+kiM?pBhw3}gX(SnSnX;H!gp4|uGU|vSN))n|qC{Rye6pG} z8(}UoU1bjv&l4Eh3bw}+*;ZK$T-ZPwm58E|1v~~Ft{Woa zKI|ZDfWU{rfV=F72*IEMllRc21Q`z;D)=E}_Q`Q2g%>=Qt<5=Pcg^LlZVg{mUDy_rIv zpJn6(ZSnKjtP(URQ0emoS=cb0D!kE>p!+OltT43a2k7+EiNrT9SCSH=qCbmWD;mzp z5?W6)m4OiA~> zNQ3if(R)-cnUYRTGUZGVPo^9UrYrl?)pb~_8|S7^DHS0*?hSN(2cL{g41X3g50%5(pQvB&xOzaL-i ze{1JCIYx_1et7W5a=pJ)w3?^wJV(!9Y%6JzI_G;=%0)Z5&i}K_=^Foz3d~dNLvM(2+l6q#OtQqzrBRO1aL}K0f57U`CM|BnLk)w+Ai7A^bOB4p zAUXmL&>cdNAUtKWEN8YgH)xGxIth=Eg~~8GfbOYO<&({AOFKogn%Cz15;am?3_4jV za|vxrwpeIEgxX00DY%D+x$iWebylb`sZ*&LBc!Z7 z(*t^Cfq0OwCC+XW2_q^_g+YoRtYluhu%xJBPHmGp z(wbQ_r#>&yS^+fF6zbT z=;-9wn7<|`JEpv0ZnOKq(eOB6V?HbO6gx4l`t&&3Y1)O=b7?msSr}Hf3j27ZXS_VA z+!a)}s-cSk4XX}g}mYL{`@7L)zW`A%ADkOGb@>`00-5Zb?p!HRU=c3+3g# z@|%z^DJ3d4*Ma&z3u<_Sas>V8@_Z&8)PmB6ItB0E9BQG!G$%<5GTmeUk8(urIU2f% zQZT{wQD3l>_eAa=Yc^BVBWIPu-&fwzeM@g+ajfV;P{6QrdU4=1|b9f zk@7R$chwKHvS`*xJ!)pk{Sv$j#DUNR3G9Pq(Uk(}P@#Kiz_@bV*Wyh6zX!`wKcKSw zu+d|R<BT!fCGJ%*xZH^8V#?sdkz>qr9Vj4Xt+a`Dai%z{-5~0qx&7 zyZlT&jygJ#PJXG7Usw-v{E)lwrIJFBrc%VymWxxp_5E(~Z+ z(d+ZX1ZEouRnHOAI9F4;E!9JyiQxziX3O+jJR%Y3l59%e4j@_no&^sp4 z5AyJ?K1$lOHD%`h2B}V)KQ3{X*Rtl&I8?A#L4|%4_~C~h3+fwLP8NUjEI|06uSiGq zX|kE%fV_xK-3gu%u!>+C-V9z5vdaX74|)?L^CF44fpjlsA)<;#PWdYMOBgu7L~{`{ z4l(T_<|pTv^ci#f^vnd)Jn#xMbP*0HIZpZsGOL93cDOgt@gYvJa6Y2I7-RO$ZdParK4Mw=Z@6-Uz}e=E-#)B^0$r^0P-$oZvoq|0s7AMxWRX#gA4{x4FP*` zrc6&K^Dyc8>3L2^j4dWDDG{-wV362aSdpw*?9w-Y(T!^`({7(&0b-q}R7n z(=VBmGV2e{8n^>6lwkhGG6!r6w*d{7jJ9qzG{{HJ!DI^*wRk_Fxi%zXtU{REF~Re zgMfY}eccw1Ilg8%hjnse-_$ua&(V-z3MophpJasEmFpJSk-I609In@#a1 z-hlEBpuE07dDdtX?zK^#w!0Ma4tI_yPuou9$dF1df!T0fUzGorC{ZSNh%&9wIHI}D zac2MHQKD3?<2G5U|0~FLC3{-EO}85BG@h)@YI|f#{FGMF`9!ow-8@absc!W&g{0W@ z*)Ns1_2c>i>?RGm8|6)5LQMe}z_JsgbX;F)1}GNtx5A8^jP;`cwB)kih49J5*u6uoiZdkucg8*qdsB{2@;F=5h6bI^XJH( zI{))zPebxKvZrzSJlWIeeU9vDNIy^ZG|-XcAkOIVp_Zb@!}379E>B~Be)!dETOhyjSU0a!Fo68P#8R^wV+SfL%e z&@d&0H%V3Xm6}O4SVW<1D?k_u9(&4({0l+}@Ys=Ox88BbABy%O&fF zzq7cq`iV%LF+0oug#7yBj^6sl?sslbAKm@(HFx@dHjJ+ltL#{Y_?EPN#kb`bVcH@Pa?XaH5pM7t5qX$8CvD08#tVj zy#OP3=ydi%!@XQbyjOq7Of)O@gsS`u|6*k+Od@4wef+LI!W^5Ek(Ot%s4-cY-#dLo zcOK@{MZhPIsJFug1LhP+R=O0T9x9+7;^QUYLPyXVI69Ia*9j9_nQTsZQl;LID)~{w zSyC>m@MAnJ7j-`DhLXjenGCD>_ru>eFcs*W*_3SL$~$e#M@`ICMiA z1`ewPbZSuC=#Y**^=k$BYQIjtumKPQl z8@FFB7xv@URCTk$lbx0{^#*HPy!GQhI_G3&@s}i_B{tsQqI8LUJyHotssk-gAf;L1i0 z8F@J_lbCK8MsyH(n{uUt(G!bUpy7-bE_gEN0y3LCP@NBQ`+RlIxM%s1mCak*TuZOt z+%^u5k*EC?`kuYRVAC^4x2H(4ztS6W#kyUb%jUq+N+Z5nf8F~h*s1@2U7 z=dplAKxBFcCZeL-X^MnqSxihL+l-?stynl%vLMA`&Dy|;2`z;}@7pDx994?4G_v|c zSDCAle$0k2Q5GY>pSXRbWrV}6#N(GJq4`~z7%op=333?qb*xgZLYxKh-&1Z=_!dc? z0US7->VQt4*!7C0EB$?Z_G=&uq+A<#hn@sU z)KQ<4UykCCs|X8mH>g7_gO#vqPeqCepckSJAnk~A5YSq124nspL;zv}bUI~uW@ctd zW^rDQCBd#I;32LuNTHElFLya=yawMYxv)Dzof3jA?Qsbyk;XLJnJCP4ez71K^65^B6Bj5g0WKvwL&6aB9uJ}APW=^(=+fUyT;`#>g zlWiJMw+7mjK*Xp(n=lOknV{xx_BN%b<%u>4Obk0ZhL2`{MJ1RHG>BbhovBR&RQuEa zO3<37+&K9{plQmZ)7zvglJ)n$VLYpG{+A~;3Y#(K^Ye3KUQ}cG-qiAZ z|DE6F_1{q+&2UcsHO64E_zljC45yMDV@OKmA3LEj*$<0a`~k-OzXiO>z`gHk{))#u zpGO)Sb76~}n4sxER11c2Lu3S~C@^#b69|AmKr?jeArmwz!lr?NZwd&dfGyf=#old(MX(~IT=mrC>LTAZ}PDTGGb)o~!|52TYV*YfIMcxBB~!*&e#CcGr^h#58++bYVwjSAX19&q(O^ zOk&pa-@JTJp&=1O`ibou$E@-E1AOW+R@bH#I~@s8u_-Y-;~mxv`^D!KH1VUSe{j>C znK^Ok$(i|)wv=@nbR}}_tiS8w^2FR2OQnA9_AMPrV8`&s7Njhxj*E+pNU~x!-;3Ft zM6;Rw*%RB$q1YDNLS;Y~APxFLX4aWN1O#g*sENediC82QOWH?uIt4^)A<|Crv2rd; z76r8kEKc%zqLxQRfk( z>T>2nu~OK$5-dxUBZYyHqph7gL%aQq;|vUe;s-~ThF+iKT0CCgG2w|hvT4QU3zFmC z!e|+?oPP`(!VQ9my%cYUj*4z~6i{E7j~si;g{guRCM@Lc1+SUzRws&no4c{&i7-C~4UTFWXwQV2RF-c=RY9MY^PHw7fW+-w2q<8=YEHpBx_wgCsEn@J-#f>RSTO-M3F z7>B{U0Ip6bM+8$RP90pg0a_WcJV;WaXhBi+yfVm06gVLG6(7=WN@F&=uvc&aI1&Pf zEpb1h)8xI5horn{`Uj-Ejt7Oia)R6}0T#^D+s+p53aH2N`@%S0NQ=`(!OgmiB;T5= zpc^5gHUliJMcH#8JVQMIy04-;6lnxuID+_DN!X3dT>cxBI8*d17)W_#udZo=8myu+ftIuoeI-q;} z^!MaE46J|omVWwn@fVkf~cE_(aK$7|H9LEyp6`kgSV{GozLl8HadMWj-_Uq)soZeulCn zZ!480cw14{H2WiHmyAPlfRg`prhJIYJY1I%X;R`+vpo2H@`x8Q3mdWIg#Y$lk0>6Y$Co-Lso(m4zWpxR+Msbs@8!B*G*r(;L0$q1d<&xOr-z;_%#=w z7g9Mu9JNvteh1UEZa|kYcx;2=;J@WVs37=npALn_Bedie3dJ|XCF$JddOOPnC-2Yv zQ5;giZ)#G({wR$Waw}w%OK^MXVLz9ga8Xe2qBATmfLabRX%cz`lcq5G9$;a7A7$gC_C;Sz>q`+E=?& zg8U5efuY8sKo46|kyDZDwB|+z#0=%#$W#EC7*IASNK$gtLf}xYcO&+8-M20?UUU{r zJgBd$UwPM_#KjsJ_yRJD0*vT>IK&UGJ9*V^muu2G1qdq7+LP;Aw?4Gh|4q3yE3bxV z4PgJKks_JS@HyLs7I8*0B7_@t&|XrPvDgS zX^!Lmc^KykNQi+%2PS9Yokw;Zq*vNgL+mJdPDnlobSRwGG!tqhFwmK~Qf9z_lr}4m zlRe^pCw@9Ibo5G7{FUaqpSO2=wo_Min4SxFFP9ErL+OV#DugiY;HyWW|-7~HOxxp6u7b8B9j ze}e0l=qv12e=VqNaW#*mq~sXYN2)UB#PJ`))R&1bp;`AUexB|3v~Dncb?lWtet6u0{t}h4QTw6OfbQ4Nw-omBwNQ{Up8e6wvP9} z*0EM$GW0jk$k2}vII8h_eB^&6I?k2~R*x~k>ajpFWBA|m|5FPG@&*HwFZQnCxG?`R(tUhh(JX5y>6W=UvK`yH;KRLVZBe)c=q?#ah$W zY(F?AXZ13#boU$@Hx;E@GOUMQf>f#=cWJA8I( z(8_BKA+zNLxNIObh$OPF3E&G^eaQz&Jq~4v(5ekm=!R%vg8(Mtp+^SdQclw9LwGc1 z9>@|Hwa=DFD04!Er1gOXQac_HV=@h|AwSgV0_240+X@??@SAyxhY<*8V+?Jx4)w`Y zWv(0;P>O4KuQn`qrSV5KZ*$sT;KSKt(l2r4i_-3<0B6?SJ1&xObeCy#h=0q$c-nuP z?B{D_w_hjU*>_ z=y+T#^kHGs9gdDP;_5bHLwt-lyMbn$gR`qNCg5>1;$k-QL!X#Niw-loVEBXXSyTdA z=UQ7D>uWtr7UM+X%qGUsgh1bm6K~jQgn)mpPFyR5iy?(|aflcP!(p@_tYPOB2Tye3 zzrIF*=dyEm$_~Bg{;1;I?uah`YxeG3Cr>>jgSSV|mmc0D-D9z@xKpa_8M^3G=N!;J zHJo;yyp_Md+VqRfwIXoj}^2!DvRnsOyXI* zBX0&aJ|Y5Hb$3|&*Tp1SqGNE66qOv4ny+q4Pqg^2g8WTVTnzt8TwFTfCr?(stxh0+ zl7z_gq^Fy>;1mpP5GW)d1~GMmpi-u64dQxRc{$O48&y1p0IYRa)jdt53HRAN zz}K*}0U0QTLm>=CWP!d?%{MxcS8*VASYA)++tG$hd@Tul4djKsXZ%{MAOqVYbP>4$ zOMz6dTVs-F?}6_c?cYDx$NYBXYF(L{t@f$kR^Qd{*8j%94CRJ(hU*RgVJtO18POc^ zU}S#eWs!d~c}?Fp8_Zqiqvp4woKX)&AB%~JIT-Vg*rvFWctiZLgwlk|6aJp~9ZRg` z&ZMTKo0B7xe`g&{iB36~^7quv)Kh5}r1@=IZ4cSrORq`4DE;B|Kh1eCqd(*KnJ4Yh z_HQ}P$@3Mn%sxM-*JW~b=h|}b&0CcB`+SJ76>Ki}&%%ofKX4x{N-ydydaJmp z_?vS(N@7YLD?L>Dx3Z_pP2~^IUpD_}MN!3I#l4j!mG@P-tJYP$Q0=OoU;VA>e=k_H z(7GsR@zCOrYRolrYUb9|)^yhlE?KhVpC0Z>^yGLdJ*}Q~o^77ekkc)E%t5rtWy%1NHOjU#Wkq{$KT{8;lJJ4bFy_8t-X*xbcUL&o}ZSJ{!#$zueckywlscv-5E0)t%qyyu0&> z&SyJ+z2eaoKVR``m#_Pl?t8l*Te)IY<*L@z)oZF@(sK2h{xzd(4y`%1=Id*|v*z(N z&-SeDd8b$DjqXkD&FQV|ZN|mmVDEXo7p$GT_J?bKz4rCB|F!nN*F~;NU01lSVqMF+ z?sLl4N3YLZKX?7Y_08*h*Kb|_rS+Gs|LXd0u77C#57xi5{HS`=(ih7HyJk7Y&vh#H->+`rFF{_Tl`zww%)z&Ih_W3P|>Yy7hDua4g{{^a;C$KM=(f5I>kKQTNpF>z?(iixkC z*LU95-Rkbx-D$gXc9-m4xVvfhirsha{=@E5dpvt?-E-^So_%Ti-rk?KKWl&2{;%!- z#s1&ze{25-2XYTo9H=?4?7%q(wjS7b;PL}E9{9$A`wl!wYY14{%~g{v>o&wL`hdko zAb_zy++uGQ?#EB}5Dbm#Gdi)RjCjPK`W#EZ!$J?gM}3YT!23cxSKz6`b4Yzo=|^}8 z{2#%!zT_qFhntA!O3fudJ$p6xdbn+xAK_`ZWygT3?!?PL> z<^3QYN{jwu4S3LBXWoT-J|617Tj7r2K|DSRm-_5lJm_n7pY|PNz$uT#aOcCN{-Lzj zBaF(Vz7Kz>?`dA$gNOQgrpJwN>U(N)`11kY!=J11uJt?h{gem&!_x4Cr-z^V zp2kSH)Q>1%%(pOCw4KVQKA6d+Ht)wn?sb|=<~F3npSr`cReNArqYns3z4)Xp$h z%yDWf&HHXV6c_W4Trmg3T=u^9{cX*qbQC|_rSYOZ3%D!cr*%&8XzosTX)V!wp3Qv# z-yXyhaB0k`FFwr;tVLQ6<9Nc{Ge5z5puBFh^AbFF<2j0Xz6nnP{0=;TF^~`z>xI?@ z!7~0no{#V>!}}SyD%>8pXfLn8L-3#g58BM{#B%`tm3V%MCl$|Kc-G>f@gK%R`OG9-~j#Dm+vN3!Y&`$9uxC4v|Phz{k9%JxKHc)P-H~xDhs!#V92K76kKYkHN#ekyV zPht9U^wpo)P2{qJ3i?SYpqP5d~yPgGnr2TNu1N~kPeQMF{Ao~XU4*MRM%#wI6FXffIhI@DmU(UUJ zn2+(@{2)K3*py1;C(5fjm+m^~>N zZvVFZ9tWt9S+Q9OSxH%GSs7V{SuI(8SwlHL`&hwAkfB^V%Ds)<%^v3#p3L)j8L#F` zcr9PbJ9$6f!pHd@l$(NbpHY4vR_>vUcTsMlJ;k1Gw~KPi?A2$L8$YGoL6pluDgNNh zAK4$y`~Vm@M(E7rcpg6U5PosjdFDPmcjLM1%yo?U-}MjrSNhjYo}9e-^dpnIP-Av# z=#>4`oKxwiY^PFA#hzMr%J_!=6no?MZ@l!z3vW1HuYbMj^~%>bzh3fs(d&-a^{@To zwf}nMQUlqr5B!b7bEWn$_Eq@kIgaOEJZ$Rh5FvNY5GFo+`VZgDM)(A5Jd8qD@($=w z+r`G9+jIgWzZ)lqz3AQ5e319>&FoL?&wLHv2no^uWPjm9ycgrXmTzH`%+J^Ht(fDh zFgq;#96rL=^KE7_=e5}{U>YWWI(O>m_bwxhz_SyS3 z7Wovn)8TX!`E+jk;QcyF6058CCDz;f`sz+7mioFAIl6kEQonMK-52GAr`|j0Q#<#Z zR1^i-_#8v&4hlUPlf>)N?eIG5PA2k1d~^C(XU|aY$z)D3i+rlvrz`X&)%Q?&zU2CP zErQKHX!kwU=~G>6Pv-IH`o@7qpP{kG;nU^xcCG6{WZRJ*yRWkoL7rZl-B(4vs@`7v z2^kwT%0rO$X7`oQ_Y#WvRA-MJy>Y~AC%R)FLcn6^@R`V0LB5JUTOW{m8+ywZRX^Zk zT|GV~h?EYzABkfF6yp&+>&GF$+w0?ny}eosdhLT~kF&0~$ftMP8|^+d z$BQ-@>pOdVMrWNb!dZtAK$5;9pFwmtdcr<~-|oeV*c*N-4|QGlv)N4M#vXOZ(Vqc z6XO++jN(M6*wF_AsJJh_zR!N7&+dyyw-xyk+-)m+PN;(oz1hC#A?KbVU!uEhMNeC| z4752Ao+!dC?h`DbepSzjgoJt@_tyF13u(z=YSo>HrJp$b_#miZM@u?;PS83;chw!i z2&34z0*4dH0)ET~`c6r(lId$NTGEXAHzRcFV9hdwCm2g~qLb@=tmY&L>ta46x!DP( zG_LINB{=KsjlLL6zi20>9HycLA$_RB!zn2o|1Cpft&=y-Bd-6wS9rnyh3|H^Y4*g4|5^iAZt_ z-RKrM5I#d6y4-0m_VM+!Y>IsDu#d^Xk2~eZqOgyy;KyC^qutGXv4yiWnA-ZFY%4W1 zynPO|&yIR!p?%~!(LQps(LQo>&^~fqXdk(`Xdk(GXdk)xXdk%+Xdk)7Zu=s!qUO5M z#VLJuKtJ9`lfw(wS4@+)#O<3~=$ng$S&B8$jHx^0%5-|GoCM)NF$U&kk*_Q;)+b^N zjWqRqr3EMSJgKn<(2+*5Jgj?Wi!;w{pD$`YAGyhV8qbCo07Em@mcm&wwtxIJ)Hth7 z%;QPa)(Z3o8Zcv;KCBvVRgtgKU2I)cjch+d5$V#zu7VtX^e26S!fkt5B{ zX27Bz?0^8j*qW*!hG{_$F8~lr_E`~41zgP$(N09MI-j||aOg;}({5jM1bHr;8qHoT z^Ya<78noDUUmpP%&x)S=RlDA9yI*zb(|YR&9M;4>Z$c!8~lB}02I^Hcu_TM1kNUJmCcC~n$S)-q7>veLm{XL!Da&%F$P1A z35Ts@T1}9nm$ogcgbu$NNDY;R$+9TW7r+XAdY9H0&PC{^#lcTL6JUtl-sEhiLTMCh z0^dYqWKa9p%AR8TBJAu`dqoB!)8J6}3^{mf#it+=BM0&9nb+skMhja&k#9+$G|~Io zaP<+UGrh@yA@%@%6jLuY`KwLCrY>l>$Y~v*DhPL;p7#P%tCLNq>FmTx zE5^!`4Qg_qFk#c7*)L}P=bO^aGflAn%`B$=COEdpS!HvC%@;?nR?lVt;01+&UTMMG z!a@g)8TE_SnqU{Sq6?DbvIm-i6`ok^tH3H>I!kyPvg4LSUnSzSyM5JgmQgP@qPy)) z*o_0d)#0WI?OTR!UhY20SQ9**@Nn|1aG&HNqzfJq(oJ!i@o6Q+AeT?>W>GKl4U2k_Z;PlG`L>FBk#9uQi+tNe zy~sBz>P5co=;KAf0o)(w*DZRDu?xIeoXudkUjbX2am*R{|FU6SxEcZ(3?OgB7uM4>;V<#%!jz|4*J;F@b5a%KtY?)+rbyh{0G!W!4c7| zJ9*}B{*5vvE7Mo-KjQfn3X2A908|^5Xh6^6k$%q7@Fx8Vi(+qTejPY;|DpL++!_{W zemzU$Fy$-qF)$Y&(fkoCn;+Bsk>JUDNb{Rn1^>O~k78~mM)OB=yRty@$FO<2wX9xH z7WRU&0DF&YGwvkqXhjL^c+7`yB|?VaQmhFPX9&M`)+zkk#5eM9XItPO5UFbsa~$cm zBYX^T^F*%WpkIuE*Lg1fZ9-WTV}kXwVx-y*3ddYfHzwd4M?MpvcZA-&NJ(kuPOC+z z4*AGs_8PV#PcIumnFFjGF{y1;Y$3FBuEJ9b-_*3Be2c*E9!fhk*3>=-kGC2vpq3A# zHKS;MsLZK3%vR2dU_TV0hT%P7M{Q+a)S^9Jk$VH&O-L~W=HX_PJA{9ucxWW4&t;E? zdUNK!4UEFnRQ<@C+A$#V9e{5Kat_3$xiO6IcGe_XN;9V$zKtk%H&Rkv>{<-j`&6?r zgbpH{>M;mE%_f=)6t^4w-41uTD2MtklykeNM<53`zD@7vQq+tdIcsIjrj{G1jTiJY zFY=>4?8h&ay&LaT4?DuB+*-^H@{gkj?bCX5O!Nr##yHwjEc$2!F3tE&n5WB;zWsld zMgi^eLp;rp4j0sC{D%GUYY_+@L#$v}!~^#L7?`1~*#z#XC_tJRaQwvKP@RBdwFL@9 zk|C9x0_`zrkX%lOF4+w5#oC#JWicnqW;x8oaLEc z!J&#(qX!lOE-i-br6mB>wX6;+rhzr0mCdll-U=JWZD{W@FiS57WLUwvFp?`VcUOZ) ztOq*Z*0Ocr^#3N-Zvd?8=N7lW$5g!$MB?g5Rx4&2cVypcEYW>ETD*~jd(paL)D zZM>Z?;~k*>ck&gyi+2m^?`pmVHv~PP46o(u1fBR!P=nX=bJ_3NDfSBc5B4g1gZ+WM z&TeKW+5PMx_Aq-I5=0NOA7eKDkX;Ho|1<1K_I>s^yAoPqZsdKSec#0X3C$44*e&cX zb`*Q#^^i7siv0lepNIR2 zJ$x_U$M^FC{7bm2IG-Ql7w`+&x7m02VcfC&H@}!)0$q!j@yq!Ueg(ghU&XKHNBK4U zT7HawnP11R=Qr@L@EiF}YR9VfcH_k8a7jsBndX)Yx4f=id#^UuZu1W8+CFOZO4m@^ zzia5cA%j;q#@g+hwvP^NHF~9Mt{)iQH88Pl(Nu>qty*n{rK_|qRfe~imxj`sw}kw% zyz&aotu(ZI2PVdc3?stPLhCfQ-q0>vHX@x48Fw@+?!5Uj?z{>^hm15T9OH7WcH5;J zy?pb;=qB&3iESg^iSg*|;ctd6neVQ!eCKO5oL_0^lKJkEPPdFZCLD8jsAcA{kYCiP zth82h>kKPp;&EBGRa)I9q-$6ur`3dT^s9Cak8aXW&~Nmr@Onm1gufYAY5hK-&4RVE zX8VL=S{oc<)4rfrt522YR!g_MQn=-{^1Zxzo_H^<&}KzNxuH?kuvK%$herm7)OO^n zYaHEVST2Iqm6#odRpOgrjqIN_p+1RRGdMi7YiMkE%&=zDF7J6m=HAdpL$3%j49Nn9 zg%dekJhFXY1g4e@!?MH?Dsc!UZkHvFQ;8F@#ND#Q-Jwh)cLz({Elb=R`e@iIf~cis zC6%(pCAAImy|h&HKuK+h+BmUmy9|`wQ&v_gr(8+he8aZkQJTDCLj&7K2SpMHibfGs zfm=M_9UC%+sCYGr zrU-9*_!JQ#W;w~EUrrU_kE97Ed?wL>!b{i$Zcl+Ba3B;>c)(r@OhTdk0lx%oA$5z8 zIQ#<>ya5em9LsR=oW*OMKYlOK+yyK(T(N#iGkT>0Kn}KyWfK4m` zR$yX$W$j8k@DBNvqg*Snk0M|ZZ6b`yiw2J31nyA@%%UBxv36~voz>M-%AWcz{EoKO zuC=p^mMw3$v#)k7UuI`MOdUIRBbl!bm`^G&nz_JCmTCE_XlWX7oDyI#^}tLhW(07i zIN(Aq;5gO5V3up42H;HTz=g_y=`;d^k#UW{qvilVDhKw{1gu7eMgX_U0M0ZI7*R7Y z9T^%4d@B=p)O=t`Ex>+cs0lcj9k^8mFsD|+h`g8=3i~3zH1ib07y2F8wnK>;_yWHh z0ZtXm7x^6--sDx%zR)kghhirnqPWDbTl|)Z-zxE2BYqpi@6zqN21k|7FY-G!v13eG z{Y8GUI%w_DZw!9HDvyWWXf<-oSNb)HU!oR3x=s8NTO$XqPrrKcOY04)zQu2}_%&lz z=CM2ZZxxHugMa&i|E^Z^#nZ7`;y<`R zv_e4}(}@P5{8~IzABJ^_5Ue<^{7}@8LOAg6|IIn&Akq=mej&~ibkev4xa(!W|Bv9L zaV7YyuLh=i4NeEgz-x0IP9a}mHv*6SD)8Q0fZsj^T=!|f7CKoxhf~Eb*^4+u{1#a9 z%fOLe1CIPA@a(s6cKNF~SNxOxi@k?4%73$ufP+usGyrK*Xtg%ttYAi8#G==TFUN`# zfeotC=p2xRGe9n|_a+zxx~l8o6#rn=PCV#e&TnaPqL@>7wA8M9wcafA+Ti# z{_$(jpEPHvx3k4eQZQ!4NNW-4|QjWPWB~@^i(TulX2LL;js59AJcZ(X@@oT`U*pK=o0BY_NE_4JT=7FG} zT97=YRg|7)jqCx;9^{ja*{IDWvByze5)e-Im1)nTIAxfvp*m2zX+;>IH>(S7JMD<* z8){1{9!f*svsety9)a~SeQnUXh{0M2tb*w);DWFcGmx7}^tsAmu?DA4>QT~ZN20tq36goJd$gXEEr3Muej0)Zfnf8TTO%xYB(y!ZZ}KOa1roxL-A%em)#PaVb? zW63yZjLn!fy-nL{-_N);9aksKn75!+zvKfIpXV^9zS=#nylUIaR~It&rwG39TfMn| z+r$r+ZpP<37*qDF-m|M9^xNbs82jjbe7|Ykw)LBDuS?gZ>At-BQewSQ=|&iz4&u%KTZH zRpT8Nt|?YUvmSEV6swB=5863ripG`o4zA+o7vYb}R^p6xr>7?;GnU?%-cVCj7|PE} zPD@TpO~F$WYU8Z#66VTK)2)85FI1aWQ&;U()4Xb3sJ5m)O~tXUy2|BFORJ;58R<4P z4M(fr7gklPUz^}jJ-)$LeDp`HEmMXHl#>DVwbvA1MrxMj&O0qxsTn@ywb#@@M#ypJ zosN*DI6wIBslojGpyeCE{C|5bd;fj(!;}Qg%5UbURa;_eoKt_CcRJ%z6K$%#L0@Op z5>nE5r~Y^vQ}{dQK2(0EeZUe~E?e-FQ&m6=yrcaQ_ngHMH|C7@Yn<~yrv+nI`kA8m zm9Csf1}j1B zY$~^EilSn5HPpf&o*QV{n$XJWqdq-y^@C$t~vDZTjAb{z*jb_lCpX59pvjpPZ7HsXBT7@LBXrUN67Y|1x~0 z@BiQfn#IS@9oDif1#AYJ!+P00ksOPv*jYN~_Ql;z8JdMRa)+fbq$myxD5L-sQX0qY zoY{M=payPXe1KUTilsN6JFsn3hcdua)z5b&} z^vs;eSWjl72i)6K#q=sv>#U#;T z_qkl|lu$TCYgAV)2+^96j?3=a)VkUld=pMluJEqx@f8*Md_}&*NhdDpnA5xHzCGSx z(0gEkyquBg$lcz1S=+3hrC(m>4c@iBsL(&>pIb_cN*7oP@_i3y&MNcg<@ulU=VkB8 z`B!4DXUmesS9BLcP?!)O z_ukOTd9A+E#3ZNwUyNB;73lkB(03B^vPw3E^{`cumDt4=u2>E+)o!(`)F10y5 zw&~C>W1C(U`xWtwlbF-ZnA2u9ll{H@kxGztW*ld{fh%k#SCtw53{_Lhxka;d6^M;Pc(SS~>HyfOt=|EHF6^{(O|$e{u^4_!SC0Its?TiC&|KVVE?Z6n z!tA_1!ss`|JuxfY3)ak7+cXSvvcJY3XbOa!w0W?O=DrB|ePR{eysjR6izE|xo7Ltv zPkrGq?I5CodPxY1vFi0)`TdOA=85S`&RCwKi>Y+ zOKx1c_Vy{euIasg{!qyUQ)}i|Y~vx!>>rd@ls`cd#Irg%{RBJsN`*ug1H(zh87?fM z3#=b!U?UMH+Qc(wKqcB9mQB^w%Ac(Dsz1*YQ0uMbcWWP1>CM@>x!L>$S|nbi->>#t z*0Ow-|2UpDTm0aYcvcv{^f>3zbL&h4%ehA9&}#0t7km1knFgp}Hv)Vg{#(V6Ut zOG$X>-FF^NNQv_#JLC5K@~W#|-)mXxO7&!=J9g;ToI9s~VTU6<%aiJ|&iV(R`|`_t z{s#a)oL_)`+-3B`!PzXqiK!pO!~Mw175#9fW~3`t8!emIsCB8eHHtg~_HZk$uU~c5 zFZadC-aP!yyAK(?vA90aAAI>`{o#MivKl?&+s>WiyUZTZOg_)A))KI9YT5iqQUzyP zdDx$oq(T%ZkPgMzMrkzr{0M-RR@e!!z)EOMGH|AGjqyXYDwm6IwXWVs0)|k_YVraT z02{IeYzPXZM3iW=$Y}(}3DbDQAnJoejrD}1+!hI}lv8Dv0B7!$%%IciE70G4F{?N) zyEyCU(X8U^yyC1E^uHGPtj=I&ikq_lFDus0Rut=h-s|+{r={kGthGPR@&xlTCVcS0 zgp9nPC+o+x)=+M0TE5r0muFg>e%jvb0d}?K(-crbS)>@-nL*@f9B>F6gRiIktpF)m zlpc&IpXCMo{(#?R&mmcr;*}fAn}M2|Cr=0hRHo+)q($ldQFsDeqWR^Cjt{XBKr zOl5_Zlkox%r6naM>A6K!T0DO{Ekle{Q8b@&HA`Umk=)q51Qg7Hu^7IIs}UPX@C$P^ zngu-{vQqz*e=AqhXy_k$^cL{u-*_qR%Zj+nZ3!gTC7u-@G@fO0C7P9oTUut$#6Mo@ z@jXqC!~wtll75?Jwd`OitnN&lf|)1SN}wd39$Var2hz@rIH}(pItw|EMKE5G2o&H)cNQT;^uxBALl7$q`XQh!M zg1{0cL%O0P;4`da9RF9I2${)WqF!0SwFa74gz_$){ z@0~VnZ?`;ZXK&KqdHQMn-J5RWuBV^o?wd|+{n_=`|7^<^I&P)4_!ab@1npVSTScTS z5#S3{fP<=V-~tu!R-96&zy+D72KSlx!1D);jB=M)0wO_b-OFvz5&w5~qc6Q$Fo7a7H zv;NhCB&l8?atT8W@HKd|fy)l>nMDg*zhlpyO}hl#O-MZP zh<3K;hBXT>4u-B@xB1>>)0$kl>7L?*%EsO6)?Yv?-nVQ)e|Rbld$TLsv6xU4=ntTb z1z91hi&PhKX5}3=&McBC+Of|HJE0UPY9Ch8uVTN4Lud`1s>U1eIqbP5EF;Cl8X3lk z!B47dqbpd=y=iLOoz&+$FQ=nEmyV}&pU>muzjsxI^b7bxyLPr~=nCrTZ%hKki8oRC za(>=WJ%69p3A-5UbQh~(ZIP)qKxph3t3|a~RqPneqG|`x2#aSKz+%`|(h~VPfv$+R zD@6)1tQuD34+Y#IUqCLApf#1qjuwj;%gAMt=-4MEvf#m9^+p=QgoHIaFM4G8hHoD1 zd!ai&nO0}Y>GqzBS|)CtJ#ABUvai^$q$>qQic7nT2BbgVuxBQ0HeelVn*fhFy<-s zlmz{_EhiKR*zH+Da#(GeW+PEMVr;2_dgu}((7pNyM5+Fv{&sH7>4jS!UAyk_WXZ1> zHr%N1dLx7qb6A!?BWy877b6F}F|x<2{@G*I7dpZ@fierfQ4dKTq1;K!keU3+Z{2QB zW@4QByX$E$yaoxUvR6S@I(9-1;Lb!gEixtD3M@eE7z>~&mI0fP7gh)rsjDbMC*hciBZj8A6E|Hb~{6{$;IPT^iSC~3}l9m44-2r`IY(`kdD-YJXRbDyQL&oA@F&MYIwMEFY@U zZLCICMk*S|0nyNYiAsGyYnlxM1K`sLXiB2PgsJLWQ&i~N%rlY`U&AbPo3oIbB!DI^ zGu}&60k8+9GB<1jY-@~JgcGg=$8>Y85n~?wSGt%B<&L2~ITx^y9TH>K4?D$d@K)X` zXG1?sv!I{*P<;vdZ5W!-MG?_Hm!e#ojcV^+wVQq2CnN7S@!P;U`0Z(jvJhX#%Y_v994zU44Bs;Oht= zMGyni9K$)4*KV6P{pjWd%j6a{K}kxPK4*E^+GUq4CI%XxaO1Nnb#;>`b+BGVMRHoz3vc2&hW0Lwkr%BnKJEt}2KD?k^sS!_M+?TocA zZeKKa4jwowTonpV2n9k3_B?~>3LzfDgR0zOMO|dnhS-y63v)rLzKcG}uW1+1t)PI^ zK(!*6GQJehOfCD29slR_JeE*!Sq(D}R0Q zl85(CzoOQz<|bG&>u&7%(jWJKiMt+}w4gDNSGlOBFrd{P`{<5ckFRcRnL4#@ZQIiC zA6?TDXR~D`>OalNDlR{{_p;~L-=OPXI`oZo=_yKCsx!x#nS1!3_r1U;KA|t`JvO6! z!qTf-Csfm{!YHD>00~ck@g=NoQ9M{Z0XmsIXr%tqr5e0~wdI$&n^2w@Ha) zVRGs)p%;~x6&HqsUT8-w*BhAR5b%J=-)6uba}+7&C{zP*`=Q!n zdHr7H#8AqJeft|si64>DYBU*w^lNu8~lmlPDh;m(C56hH{!y&O=L~=7*Wulk`{!9RGT0@PqchvMsKLO7b7|QM7Wi%b@*3nVjhznTRp?A2FUs#w=|8!j`@fGohv6jD-CL1|J`9YnQ z_8I-!rSw;SfsRY{4S&FL$~jwzIjdur$~h~?9)x7t0XikbyB-v)Syc^em~-dKIQZLq zuxLZ1tOS4Y+aRDS=nl~Jq0f5@gcT;Kj@49500T-B(-c2EMRF>HX9tsGPKDo8FvrZG z)@aOy9-WFm(n(CE=`t^@!>@VtjN6f^5k&K8aX%%)Z`64H=*^wCy@B$E) zgOGwBO;t$o7mfkDLY@H(1x^CvTv1F*KQ2#V6GOp3jSm~xDLAY-m=PPezSd+%7%eEo zpJK?Lky}|4TY1XCMO(kxxAeX(Upw$G8XbR#js=0aukF6|y~9V}JH6t%N@GL+CyjN| zidwm$8-HhxQvaYby}a@!?tbbF&%AkJePxsm4uB4(60c%$u=2)f>*Jkvhz-Ze#016R z@O9cOFqUy;r4`!-u4IgGDw{HSVpC&7T~)auOT2-kVK?iTCG(ECGJ5RZD09|UVq`OC z()je3=(tQzTsHhke#4u@H~hcFH^7}j#U9*j4wj$RH<;(%-P;9@ztvKL2FCsCH#xPLB7&zQ5 zkdMGUp;|Ia(*_biC)zn}0NwcB4_@4HHj+#%Wd8Ms_vl|0eS1RoZK&#NPxQ2<6>yK> z7az6n+N(Swrpw?LccYi{XlKmk8v3D-g$#ZHD2xMf2E`=A8x*6E?nTl;n2m5-PiOnA z8B-&e%s^pHLuDXwm|Qse3!9kuKkCJTy8ymk{11_5vwbH0L=lP@=VX1kJ^64~etE9u zO%7M*(lF<)oss2phuoR7CKPw&<=siw^u=^E1kNftU&hY}(&N+Qq`)$@rf^NWbAe|j zO~tXQMU&@yeStiWNB{Xa1U8R96gy)il>)3PQjQfR6UZSzer8=smJ2C0)jrd*hIT%P z41Wr&H$vzOmLPl#1~(kT0F^h<;s56E(Q=w{;!ZIxrPw4lK1(d-®noDRk&?P2sT zLi>JFzFUQJhqQmJCqIPv0POxa=XrL2gf%zT(L%!3=?xehoVuGf3P>V2M$n`Rz!j^| zRi_!-AD1bprn*|hQ&eTwiA52+eyi&T2_=C*Nx}~^whmvd%c`UgKg-Ou{^zgbDt=}T zGrAPjLod;Qm8QWTMz0B+nVd58C8gg>V{bEdTrKNAQ<6Y#2tzl^u~`&aA8>WKK#Icq zi6LOqSm!~DF$j3$Ct5A#6Utc}4? zZT`^5+O=Z%0%=d}r1Rgna_syKO(1TQP6wSi1@-Ee245aI>cqssN0i?Sl2q7YjC&WP zTN1e5|Cc@xReA65;rDKZAi{CWeM=#x`0=0b zARUIV+hWk67p~CSNEP4~<5spFkYBR^?T_Wi#f31kd09Sj<&Z;o=!B{Z`8kTnqO%!= z`)d7jt5-jF#b4g1SsZ$uj>dlR|K+t~*Pp!lHSMky4{qOn|8o78Bj<7GiwC#wB%rfc ze_zaDBb&v}M$)P{v$=pE%V9KAJDkw<+uI)r0D^{TC&5_&eU`9;x|S3&D}oBhrVa!p zOjJ-`5K<6A^B|xp<2LBJ=fBMk8Z2h8b{`qrn5h=TEyVnWy$kUJ?k0rgHO*?8*&1Pu ztf4Yk=J$u<1bZ=@T45W>3O9)gQi2T^IBi*I+mtwGr8>cvl^FMfChq^yV?6%4QyX8t>Z+Fq2I#oapdOM+ zlh`!Y5}5>mVh0zq;~TpIF7einutT2TyBlnT)%dh>D78n&V=;H9`zw zMht4gR754wr;%8J@aL%3$CsbFv>}*ZnvHR_4C9eN9QabI)lzKZC=9@$DMCr=>%g(0#EOTvZrNKL z_OIw(xVCc5_EpaxS@YEvl3%`}lBA-?4F5fHS16JOlz7< zx+`bg{iN3;DiXuHF^vcT=dw)tYH@P ziN3}F9BfhAU{UmD^cB`B16*tOpjVyxO$pVdCDrlztsSDTd+2yAui~|9#OE#p2PFIR z@_p+2W?u)dQFqCHp8F8}1b2t~um7o%KmsC3N$6*R^+M<)M3`wL^)(GMY_$eEDI7rv z{X9q{@{1lC)yilfWj=h05ci1D8X@xq_z?lZ7@=wo$QU7^9&C*?6A5{>vlvp{)s~{d zx#?%Wo-r?6q+KDf4i^~p`ZdocHWm1-U*B**jM!M6!Q_BviZXrZ>r?XlG2?zq=_pT6 zA9_gjis54f2!}!x;$6_(B9X~WMVTo9$UYLI=rz{YVBy67 zhDC!Q4Igbb9OuHAL7NwZk~c+vg)b3`oG#GK=5t*CWF8Gqf0mBTe7XMebTM2p2fe@k z&q?A_g5Lh*{tQ!RwDB?8 zMLjn?sl?K~>X64dG@ztQ_BEvVJc-Il-6=mRzoAvgN*tWS6Nr21U!y)Fi2lKk1v8sW zdN!Y}Kd!E`EMsocvq6UxN3mYxm~wRy{+O}(=&75z0<|^d+|{DGg6M^uQmEPLEKHZa zN=%j@82v1t@eK--&JS9>2s*^szb_;X8XISn2u%OKh%<7NTTC)1q2}{OzfHMAttoW- zZ9{$dYuS;W{P7KN_2#7~TQ8u$_+`Eh(M16xGNfjQ3`m|MoYl zC(WJe%C+(uXI`#$HZ^VNQDQNwP+Qf7l~q;jQWQf}#-R8aRcg{*l^t$4L^S{;q%`4U}{q7ypZtYed`^r7~j&5RFQ(9(r zO}~8U?Kf60=wDhKbW~&}`_oFxb*+2hte$%|yO6e`upm~V6S)jQDA8}9Nru*BGc|KR z=2hy0fldm{7V1+896@9iGljJbB`iCCQ)$;T?!r8igqI=RB~UeC{jiX|d&JYnyCqUI zUTa`SqcISKiP3to5Ux;&!Pg(EnNW(M`LXLmFb&AiQUU=Z(6k{oqNafA(V;qgs^`*Y z54^Z-+lvQQ-P_{veTkN1?m9YtgJ&J^a%D?4cPM2&_&jnDfSt6K`I$@6Bs_Z>aGVsgFU@2ov|@6*UWQ?(4s4VPjo# zQI^~9o;2;?udcrOR|ls|nj}3|G^UeLddfu@z6q}Xq zGB@4`dQvSK^3ZG|FUEZOIJX$|G^#c2YuOkiU_O2vdV-sw#&6Qou+myv8{O8luT9uL zhMv?vc;*uEfR0-3T_p+Y*-P)FOCReVK}o%Ws)(LGc~GK}Idd0Fy1IuSlk_AhNm3Q< zANKp8 zeoBbvh+qUoZ zWBb3HrL4}l@iO(X-9I|&%e~>I^01>eBc;$4uGsa)7f<|Z?{yb%-MN?c0-|8GC6*wo zW*0sQ>z{*|5K%%AzEm&_*hduvgh9=LVCN1b={Ot#&+!uL%&IS)z0VS?POXSbYP3}T#}=`8FUmy?<|_g!@4x3Pt>7j4I_)G@u$;AU zXCyADV9c4q=r03VN?>!Mkjq0(L>Y0`@36wef}ktJYV^}AL?aZ-Ai|_ktZu|Drks@b zlRN+XcTjd?fBUl!G784x#)`xGPMlYSY()97dPwx}ge(4Gh+z%LKqLz~Q90rzG_ zOGR@-9cExcAm9!JYNhlP_6&2Q0l5hPWkL>V1gWKKlD&yFuW>SIyfJ^1Q{UtQwOPYfq#)@!*1hj)DM)~!Fj=9(XGJ=J~f z(xumS&%U;=@7mc!!Qj){QE2@M(l&0>QKv2*v+)hTk=@=DB01In0UU;-Oqnh`7rhIkv(jzkkJCYjUvbl2> zoLsz25VKGT=Zf>kg=|agU*COdwVrEIFaJgFhE)%4)ZaEQNLj~_eM&oemSrCE@wFf` zg_mh`^*Mc=dQ@D+&PHT+8GC`4E_7r$do65t#4))vDN#fGtucc^khXOtII_ec_LZ2? zU}v0DL-ZtKQdEcnvg$_sup3zHR*S$B=V>MV;VrCrQd13iQeZ%+A#civ;QngWHafC8 z%FCe{rHs}*p@nN3Y4eNun)%5Y5i72Xz?`jzX(r$BdHBUM=!^>mbfW$SpVM@uIcvQ5 zj%f0SoWcCy;Gg*%^Lu?r7dqCXn57obSPq*ZiOUTht|8P&(*m%cU?PR|BF{+%E>b*! zx<2;0Odmo_FO6KL4-MzqjP|W6cY3%`lLv+Io;T|6i4kmw6-&WnmPL^4x*$} z-m{W99OK;)2~#|b*;eeh@mqq;AO#;?>~5dcHmzk6ZKWXnPrgw}1Ox|DM(v#Ou8rAE zAdL*M6WtPGrc`U+!;0VF^ORMU&nXuvOJ6WP)QJ7{dpgb)n-8r@E^3>$F17dCiOcJo z4bo8NOrO5!meu<6k`hLJg!H&ZezAJR%4NMzPTaeA=xvi1U5AyJ$nF+%`D6pfUhBxA zzt~pBI^wY}fzfFUY4I&RGXRUv94#Vu)9XfJo)s3Z+^6vH#?pIVbz&QGM*dua6!3^#OT2wcw^z zt8Q8#kJO(aH2hBVrwERvC(nc&3dQP4U;yO?hExjy0*gh6blJV((2B4?1SHeTMcWt| zZeXbM-WDkxc5-3ppV6EId2un)EE|g(sw&XgLRxE|;R7=!COl@jM=k3p5w2zl?d#b~ z9~ApWm?qc7VCdB`N*KVV(7*1{cbojv@SK~^SIx>Pu36%{?&g|wrL}x<>=y=;Dbo_zOQ*q_Z?doHNnW5CoMtjc1Ki>U-w1*JeDC!{;Tk1R>!VcEnHm$nyf8`-01%QSN27iNj;y5o?oQi3N7;ZlSx9jN=BSb<}r;thnf}yy`pVD_<~`MB=#E^ z+d`TgsId~YKl(;A1GSij37IubMoRDmqWfxADIrXBModKsq;6UyM&MU5QFX&}qkcbX zkARdk)q(qc9-#^xr>Xga3J1wh1x-O-aPPWJ5TsnhxZvuagbu*-=u4U#QGEk*b3Xqh zc-;TZKY1}a)S`bQvA(jRHc9`c^rZ?P#UY-;(-%>Pc@y;*W;ZvL5mDZubMbkX+^n#e z3;!hgS;v|p^<|+%;h-GX_ZW3fV!9Da>qiilKQz|y7&2`7_-lwWgEsweJ(3M&l4tAxuHaWtCGXgZPxYi8s5iW@+s9c z9{nqH?0f&cZt>|QI#%)N`WsS75(2*C=f9|@>%2maUH`5wBK>H9T+wxNN%;a^Z=V10 zk7D>lh5B0UW{iIV#UBLIMaUWQR^bJUZckWKh0(Z7#CJ|$rI4xcC&xPWd7>h6?2yY- zKYDP(qt%EaoAvcm4&1WUAFA!!zH+*LeT(S3L6+G(p;vr1$a3(RD^AbQc(8nmYN4WJqpj>e_ED7Vb~CH) zhLf37AuEH-kf#D45idfEF@F|>cbOUF@UV+yG-9$`L4^}T7pW{SDJsaz&O~IdnG=VU z54YQ8wPlc}02y5(g-MV!(RV#%9KcFQ=w1ldFgb1zaPuvY!N$Fnnrhj4$-(WY`E*z? z&+omZ#3@Ih`gwfEF6S2I*RNQXksGmT|C*T>-B#lap4j4w+nbPe$u7G3#1sD1{kiem zx6_A%yV9Mr^AgUU1!Bt4Z&Mz%?0|=Ff}DZRs^CCbk46OtGnNLuR89!1zpn^Y8~h(X zM6+$3C#Blo^~bdwG2d$=&Qd_q3=W}em|=1-!6cSZtO_n=%r_|<6u@0fsdHk!g*Ruo z8RC(90g`FHRhsW4ddOk?7W7^e}lOU^J%JZ#Q#-uXwrMws8_ z$7oi+a0Cjxwf1LI%{sbXy%&zO>~u{*cbUjTAlJ1sJ=sZKc^t0kQbm70Y!RQD3S0G zHje_6^dT6s6o%qn7LgE7dGIu3CJLJ%b>9~V`$W{Z;R7Z_HWH>Fa0~SofYVI}Aph0c zNYl*lg0^H3V1cdt%C4q0tqrq7F&C7#iVJ-O^V3o?a}(n_mKGO!z0nWo0DninPx+n5 zkj-WDpUO;0#zL5ijay_7^`oQM=M*)LcuAqlAX~(Uog8k#QFJC%WRK>4YA&xx)Tj6w z7Z|@1Fe=n79$C0fIX+yXZZIn|TlqE>uN#`24XX@vF;rIbz`oT4skJ(i(o*Hkb0Lhd zxjNCRA?Q6yhzK7+@bn?vA!|orz50PEL@lENtcv^=8VB~f*#^{%0aIn8r;39`6N)V4 z4ix!^(Lxs!kOop$S1)!ov;w$5j8kLxpx_xytzzi{_%a1bs^%$ZePkt7J3IJ|bsN5M zfX=3DDU{f`$hURF%qtqmr#6%n+1=H-dkUWcuUS>Zd4^EQnZ(O}a>*q>KAdm=$>nrCMYM9mt8%N`v1zgH#HkD^9puXBrP5^IRP~3N6P$+ zY6XTg%n=2*B3V(YScs2BRww)>lt>fTk0h%&kxp;xhm{5n1DIC($uopHXE~Aj|H)lY z!w}JEw-+JqRit9AV9OWIpVO5VDDwvcg@LdPT*7WPwsS3rTx58new+!~iM@h{if~w( zSP=~iUpV%{sAyP93Waw{FxqNt7+R`o<;AhDre&uVfa12Y z)!K5cht;DB->gVmQ4pq@`sy6FX0;_a6mC^fMH2)J?x-;YL)iul)G5kDGAImSu|3mT zCpDFo6o&j>zaLqNStSVcLAnx{M3@dyc0pCf>Lud<#B^g4joe$}t#k`$6;g^smRta> z&F%5HGu$WEUw--e6F9-A<1=R-ANT6eS6VOZ?7Xm59)BZSpO`xJglv6$-H{{fj*olw z%NI?ZdQp43ID&4?NU-@-ak5?H+{D3Ti)1fECxJv!^$je0eNtjPAX>u8lw>6#0eMi6 zFGAz@TPX);KAYRsF?;4TN`*p6(MpjD1vlRK6(?;bm5sLM%Q`6lD8mG0P}VSDH!p}Z ziD_ThN0Q`6n|PT1>aV^{f6UObSLp)}Z~77a-G8D@d=z&6(Sc@vB071P4$+icaUw2> zFX_8z*qIU|^HI~owE1I~im>WpQH_&ijY8(VNDlc!2=5Uck?lh z8Go5uo`m2?Q+Tb`t=G`wA#q8RO@k5&hM6`# z@mC59>+A84ziFIU=6M2_1w5k;;93FLMZN;*L^ktwwqEpP8DKahlkE_AoyBH7i2UC; zu42oh^ri#xKMs@*vLbuH3g0I@Kni5G!XT>^)>BYG<-rQt3uaGir2@0%WkrQC#ljK* z*hS|x%B|4+z5pe121Zvv5qWL~?-V>xznz^pEbnSO4hLDQ>&( ziXZRX`Qt0(ankZ)JSI6eJ~cQc)V*$9cW6p5H9j}lmYz|(ylm--Ide`d)z03f|M7tb z^grHxH_v|H0iJ!=MTdTS{P^344!wQ+_-_xL&Pa2jYG_KKJtb-Tz`*vT6nkMxa%z?{ zEo0s-8#mqp8LzPa=0DLKn8gXKfw(1w#?{p#G%f|f^J<3~nFdocX4Z;)muMs$mYaZ3 zbu=!mR_PKkX$|G|HB}UomL3TDYii>hMw0u8oC{(ELcUgw7n3F?4Jh2N=r?9&r)0a` z*_Bn@@t5AzwXf}gD=%NyHMi+VGwKK@+w!O0+Wy{*=93q0-l3hnVxRuYyev;aeolGm z=IS*w_U*~7Zl0Ext(Bq7M}nt7->|i!X7}_gbe&zpo3%Q%lclnt*x~F5gadLz7vYaW z1~7$pV@s#9WPgx?Du?s*qY<1MY9NDK4V4fRR!h}RL}cxuoy4VK1l;6uUZc&l)Cn4$ z3_HmMf=c^B++r_+5K=l2EMigMlRP9T6>cvo5)0ovYQ(}vZ_(_?)gG5p+onaD3nmv# ztgET4m{2+%r3!9iPV|^sJ$WdPfm)(bLGL%96LIJ2Xik;#U%%SF|5wM3iR0FX`uZN) zDvxuPRkk$sx>8fpTq%cVXL@qo*}1oFT-?x5TeH$qcjddskN@SWtNwEQ_`6rG+4$_9 z3!lB^X$eG<@4*B7pC`Rrl+PPr{B2Ela=M+kK|_Qe}iT`0rce4=Bf{9Z-cvp z#a!iLQLtXJUMSoaBWoNQ>;!VfaN2p*Ye`yuNK2wPwYN#d5^9#hK2)w!Lk7R77tbz* z5F_!0NgqAOWQp7(lG&b1qo`Sus?DIQS|21 zYYSpzQuH7imf$9g6@frCY6})S98^P__N5pd7-bZ33v^8bql%%}reg{Vib0+^GGklo zth;WXeQKi1o|^A;RPU@?vT9{-O=*TZJb&ThuI_1Ku#I1sVX2$6scr8h*P7WE9`zQ) z=cHtmYuR~ICb!l#=lYvknkIW%XvAAQ2|hoK_{)gXK53yi?R>F=(i5>ek&}mQc?G`S z6Bf0n#7;5d_$**RqW@gYPxC>^)~`-YMA&vRUuHR46!v5%yy-;DHmR3*$Q$|&br6<> zGRonI1E9lfLK(Lr{ZVxh&A7=aECdhE6eUw6w;@j|h`JoLh*CHCG~rC)kO&j#G*Ksc zE2QrRE(yWs-t^{$m2h6mlWW&Z^%f~bUUBGM-f_c9oT>Nb`3HYWEd9i)edYSibf!H< z$DucttY7!gTE10UvkoJgZaMI10Ym03_&$0~#dJs39gw!)0+yHNPa7w?bhab$QGK2VafVL1CyS_rS&)Q*yOhy(KdQp;29EviVDkWb5 zv!mq-ra7Dr&3Op&2sHyZThAPt&Cv@Ftm=d*$L6#SAo$6)irE~tx!v6r72Q4EJr!LQ zowH{m7dbPl)bFdLa3{eLByWzLTw#Wh@i+nSyW#TnWLbcUNL$xr;8MVg^cC90)&4Y9 zNlDMprxq7KaBX6|J1N2ai6bE?{Z7F1j>N%@HitVSF;V>@{oRtDp1w3YFE2-bDLu<- z=aZB2GdyKWe_;8w@?utP4gbMxTW&^DdfX+J)Rdv`WaTucr`d;oq~)fkraF{LEq5q4 zGdDNuCOjqmCT~GfS{&b-mYS2UU&EdHhfsqtw}sj(#@sGv=fun=$Y3*ZHr*)1I|ABC8bA3iU!WQQ| z_}R~hv<}~ndPsJghB8R@IGa80Aob&OJp}r$tD>S}dBw6`3STX%lPgVDxc}u!XQWHP z9h3#xkfUO*yAa%1ae!4R=RfzVugWgc{e{`wRZ-H~9BA`^0J2jmFPXgclGe8G@`UWX z@fUyFsKp<=IV0oZvPlK*cM7K!RW_z1EhK~OzRWmpVArb1#>RW5WS}y)#?r<9+6hVC z$u_|*_mQB2Y!equfkr{tU@LbduEj)K!E)2Ua=T2ZfOp#%JlB!vOmsL8C4+%mP-lJE ztpp~VsIY+)p6G~A>`mg%1RfXfjH3&Q@vB&TVmui0eDi_K4i}!CAA&9eR(_C;_gK5Z z+du2Ey^%l{V9J)wU7NZtSlz#3S?{8GJu}*xVe*IqmsF(Li{<}6fEN_%7b?jxD*ziX zBe=%n1-v?qFWWk4Mg8O}FQ0s%GR>BlV{;Vum9@|9o?RM9P4%|ToIPb~gIN2Dizcd0 z!4`(uLt@!d+Sa4F!#V!C#j>+%Y15kOw0X^|x98?KT?uJn)s8Yr#tjes- zz<iXHv`dMw~gQFi{BfXvQs39Z4ju zYY@OBe-Db9c>R!D@S>nR_bM`0hA9)lKdK>K(ZW$gV%_i!v;fLm;A>bW;~BG8Kh^pZ&EWt=uU&%JP-HkX;t;l=0vdY(2DqirhAy?&lH z{bn0BU_M6~)gPPRY{Ms*&oSE&a>BTF03Ak1v-9 z3Up=jsH`IWG_n8Kqg^uZo#}nrFku5>w<725_o>`q!zm~4)8;CE9swP(ArM_$(bX9H9O{p3WAwDbfN z{v=*VHBky+pWsJ;BV<~m(ho}tJoOd}BZPrOgB&yg7KKR%?T9qTHbIC@C{$S+~4WWO!Wkl z7q^O!`?}m&X}Lq+yKm_%{?`TDwr@w>vDtdM_DW8w`%uqYN2v7JysZVu`A^9_*z?vE z#GdAED@c1DWyqeqNO@`EU@uCMJ$2Dg(=de+x@a({Z|okHR6N{fJYFE%5cP@YM5!;9 zU&uB@S@O3`%Hk$vVaEtBHFiUo?PN}l7sSvN!&W2E4*10u@Cy_ULG`q1HU%;WwXamW zf)^Swy#GShzJmTO;&mwmnBsxK@K9hJ1`aR`+*gQ<2ye)XEch~{&A7BQr|7rJKbLZZ*`%kYEYmnCUTW_Uv#rgVAH}BfE{io6 zh0Eq{+Q07Uy@)~b9Xx)uD1WqS{qD`{b|M;@X8CyUS9Vx}OK)4X^k_-ZMpY_ zQFZhQWznnPqS33!w=|xMr8TcwGt8@ef(@1t){YgwM12hVpatdJ*G5*=a;rU)Lm}-T zA1%~dLa$_kgbU1)3^s)X@`0o{)HbvCCsMvxNoPD(Oa&!~B=Sh4v5~RJ?8xl4X^kz7 z&66hL+4UjNGGg_;0SRA4LU}3}j8J8;G{Wy17O_48p~}^W@+jg?SPLW5T)5r^cdAwY zc8wL7b-U$D6?2MHT=`iUIrW#%ysM|;x}L5*k&l1b&|bE1LYg}_GsC_A`kST|Zl5u| zE1s9yT3hwNjgzVyme#6|{rTsaa@qLlostlX@cx-U%ajO>|n-$Smot9M5g7Y zZ`{>5@wyGWH*ME%T(hPz(zvz-(F({HDil>4<`Sx{1gZ@o3EPqSe?YZJ05MT*$^Qz~ zj(h-6ZBKW{Y!lVGDZ@^n+RuiyhKc)gp;}Kt+t=5g2iER;YPDHBLc-e7B__U(D7e}w z_VeP}!>?X!R+TX0;YQS+0A-762Vx)1jM+z{ukL)8c7eP~`$)9q#p%OWX~)PX3^?hk z%v;9(lzGc+>Ko%-mHSh+#dBp_V}Hu4(adK=Ak#j-274}Ise#Ox%I=FKRu>lJrdSj$ z37CTH3prr8V2c_|4uau|WN{pf+H*lfLRqaQw}Z`*iX(tG8tsuX1EmQ163_!=4ZYVQ zrZwylhy{V&SkbP)o`xCOXdl~(7-&sR&D5IK38B1TNS4HfRyl0)u5yP2fRL`Q`WO$G z2sm>I8<9;h;H?bxb5(1R{jVQA`uctx_wJc><@+g#shLiD$qi+l!Ng2oO6tXZe={z9 zdC7_H?h`9kh@(1D-+koO9Xnn!;RG0ea2>%}P%ywxQKAZ-WW-SS;*WR-iAC$l%_W;qZc%Qb z--}o0$d|Rmqaue0OgGhkfCAGoA~pLM(*V9xZm+CtXu!V_4rBf6##Jrfb;_YTKYEjT#EMA4chCp!1*ha*ag+wrEAk1AtC}{o_4u12ln5I zjN9t+0e5b$DBHe}Juyl(D zkU-UU{w!X^1|wWZt_+z(Vk#(&lf!%e`HLvUB=K5AY{SShO3|64`IIv!agVTCTHa@2 zw&mQb0>{I88H?j_r$AzeYB3QLa6PU{d*?=674}YEYT6fLbY_X+mYH|*QiQDH-7r7~ zFF-GtfylQjo|ugyHYiL?e7zVb|NBq-t2?tvwF*322xr?gB$-7zQ@DS=>E7JJud6^4@y5TYVcu9=lp9X|hS zXRy`GYLkBMMc@9~S?sTwY*+IfN=iz5@A3=gbQ~l$a{gD*6h>cK(>$~kZ>33_x3AtG zN>S=kZLTb9_J&2Xt`J(4!ul*ieUxjjzn=rt-JRG6W3;CN1(iWeZo!!Qi}dMy~0wI5Vm z(iw;F9t9!tvM!ul(5BCMpS>TZOTY05=<`%rPIh#P`2>VmC=LKfC|R-#uziAZMs;Ak z2Sr*w|1+o}gX{~7ixZ4mxHcx7(tt_W#a}TT^aSqm|v?a)wG?QE( zCY?|WV6Pe{P7u0lOsPA;2S9-;n1IiqMy+R*xyJwBUcdlMRc|#~~w^P)) z(_e~GQ1=ZTz8T}zxr^4pGl=dxF1ILrM|)hnEy&RFQw4Vjjo}WWI-B6gZDI%R92&m! zG8P6RDE!nr2^AKDnJAQr8U4+E+*!ubKlM)HW#Tt^nLwnnx0mB8ddY3P#I&i#a3tB= zJ<&T$#GP}#PUmTnxN_ttcrYZ8vXxn)i#qZMq9N-ChV$_R&6dap7p4&@A$6csIT8&xx>YhF9B3=}-nl9q)iE2(=|auQqyp5-8W{6vT@9L2<<8W2lvc zbi?PmNfMlRfJr`vGFBIRKX^HUvSWT+{^a;~%R*~5fHRwwbb@Htji;RdUKCn8|82vx zj(~(%rVnawfCaQ+MnfB{m-Vd9kGdID($Gs$LD53X1QpEk0Rnrwhl5s4V;PveX{}_V z^gi|PW_^}Pw=CQ9%*Kt+?0ICb{u3g2UM}h0=h;jj^~%d;&%SKlyo*{|E}Ex)fABe4 z_WWR5=e*6Y9y|8x=93~ZMj(a!ps15I_{6NMSFXHzRu>9y9_u3RO4QyV@g9;^$!=RX zhNBBBfWUiO#QVvi^_zD>))QZb?fLw7imGL0=AA$ZbAU_eZ8Hlvlm6pY24AMdwgVzO z9>E~%K?HFcB0;zT`>?h$naS755Czqr1ml^%GXbW2<6KmeA!3|LPl9ihJfZ*VM@42w zpJGDFQBMRDH0K4HrW4xalf)cMH5TQi zM>sZJ+6d{uNtXH$q%Xu=-gEpo4JL=FL`>HnS*d{)6Jyw`1YSy!6 z))i?lgRO>Q7qRwaq=6|_u_5}7s;p@-FB^dth9I+kC}>5NF0s>^8<4L?J1ta*;5(G< zBUNhL0-H7yFx8C!UBe>h)9P;KOkUVt?5}Ui%#{GWyS;ttXB6U0XzbZn8wfi!e>gpp zAo+|drX|GI=8WzTLJ`3(^frR9}cI4}ltzABd-jH_w z$B-16JmxXrA2ti37R3|BeOydmfY?TNBYHoI@R_#*@F_-LhHoYi6~NpiGZyJa(WAEH zmShz2tg0w23Hb70ipTUN)+HJh76>U(xI7^x#U)}W45t@`TNAa5@O0Q3+`@_w3%W*? z22+0RQ(El4UAflXNu@>q!%Cl)yE8Mic>T8p+3^Y7AJP;5hlM|l-Ejak?!$Y`iBgGP zM^kDiq|;IBA0cCk&wa>ua0M0ulO}hF2yi9(cCZC_ZS<YE8#wdEl6#AoIqL|^0Ug0>GFB25`virn)-Nt>TV9fWUUo1FO!T(!& zE-xV@FeKh5LT9mW7?f3fL<9Qj5^<()-?RzS&mg2lE!Ix+6iSK9e@xji-1f)u0^R6WSrhHKp=`kpO7riSU8#`V>78q)}VnYYU-UDk7 z3c1=)$aU;(qkn*;DhQ#IbLLOaQ9iixpG2j~WpqTX#DCD=e;B11=B2})zCqtaJKjSO2ojL9B;@g(M$T=aND#-A`(`uoyG zF~T~ge?-$b{5nedbPlho6chRx;3SwoxS3|;>zE6wqMHD((Tj36O6V0Ah$dYNIV1hw z#Z-nt&||PO-ibG*M&BE1=qAvkkpr$FugTDn;RV^tad_KzWPSLuD)0GDsiFD7i29mX)uvrD60zt>n56mbtV1hci-+Hp1b77{Jub#JqED`VRG~RhbSsD~i=0IQtSNd)8wLgZvqY|+spVC^qB30fg zkVFxAizl4#9>l5|Z&i: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 Zml!TZoI3*L5^T`t!ca@8AE_7F{|CV3TfqPT literal 0 HcmV?d00001 diff --git a/samples/client/petstore/gdscript/addons/gut/fonts/LobsterTwo-Bold.ttf b/samples/client/petstore/gdscript/addons/gut/fonts/LobsterTwo-Bold.ttf new file mode 100644 index 0000000000000000000000000000000000000000..2e979fbff2caae0ac51c9eb23d63d3f10cfc3b3b GIT binary patch literal 222040 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 literal 0 HcmV?d00001 diff --git a/samples/client/petstore/gdscript/addons/gut/fonts/LobsterTwo-Italic.ttf b/samples/client/petstore/gdscript/addons/gut/fonts/LobsterTwo-Italic.ttf new file mode 100644 index 0000000000000000000000000000000000000000..b88ec1723c6cc760834716848772f4ca035cd5ea GIT binary patch literal 229404 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 literal 0 HcmV?d00001 diff --git a/samples/client/petstore/gdscript/addons/gut/fonts/LobsterTwo-Regular.ttf b/samples/client/petstore/gdscript/addons/gut/fonts/LobsterTwo-Regular.ttf new file mode 100644 index 0000000000000000000000000000000000000000..556c45e7d1d6e89bcb94c012d14707cd97d4718b GIT binary patch literal 234956 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 l=zbo|8hLz${wQW+TahP%4s5 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 BGSdJ6 literal 0 HcmV?d00001 diff --git a/samples/client/petstore/gdscript/addons/gut/fonts/OFL.txt b/samples/client/petstore/gdscript/addons/gut/fonts/OFL.txt new file mode 100644 index 000000000000..3ed0152c4cee --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/fonts/OFL.txt @@ -0,0 +1,94 @@ +Copyright (c) 2009, Mark Simonson (http://www.ms-studio.com, mark@marksimonson.com), +with Reserved Font Name Anonymous Pro. + +This Font Software is licensed under the SIL Open Font License, Version 1.1. +This license is copied below, and is also available with a FAQ at: +http://scripts.sil.org/OFL + + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- + +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide +development of collaborative font projects, to support the font creation +efforts of academic and linguistic communities, and to provide a free and +open framework in which fonts may be shared and improved in partnership +with others. + +The OFL allows the licensed fonts to be used, studied, modified and +redistributed freely as long as they are not sold by themselves. The +fonts, including any derivative works, can be bundled, embedded, +redistributed and/or sold with any software provided that any reserved +names are not used by derivative works. The fonts and derivatives, +however, cannot be released under any other type of license. The +requirement for fonts to remain under this license does not apply +to any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this license and clearly marked as such. This may +include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the +copyright statement(s). + +"Original Version" refers to the collection of Font Software components as +distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, deleting, +or substituting -- in part or in whole -- any of the components of the +Original Version, by changing formats or by porting the Font Software to a +new environment. + +"Author" refers to any designer, engineer, programmer, technical +writer or other person who contributed to the Font Software. + +PERMISSION & CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Font Software, to use, study, copy, merge, embed, modify, +redistribute, and sell modified and unmodified copies of the Font +Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, +in Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, +redistributed and/or sold with any software, provided that each copy +contains the above copyright notice and this license. These can be +included either as stand-alone text files, human-readable headers or +in the appropriate machine-readable metadata fields within text or +binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font +Name(s) unless explicit written permission is granted by the corresponding +Copyright Holder. This restriction only applies to the primary font name as +presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font +Software shall not be used to promote, endorse or advertise any +Modified Version, except to acknowledge the contribution(s) of the +Copyright Holder(s) and the Author(s) or with their explicit written +permission. + +5) The Font Software, modified or unmodified, in part or in whole, +must be distributed entirely under this license, and must not be +distributed under any other license. The requirement for fonts to +remain under this license does not apply to any document created +using the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. diff --git a/samples/client/petstore/gdscript/addons/gut/gui/BottomPanelShortcuts.gd b/samples/client/petstore/gdscript/addons/gut/gui/BottomPanelShortcuts.gd new file mode 100644 index 000000000000..2e167c5e0958 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/gui/BottomPanelShortcuts.gd @@ -0,0 +1,82 @@ +@tool +extends Window + +@onready var _ctrls = { + run_all = $Layout/CRunAll/ShortcutButton, + run_current_script = $Layout/CRunCurrentScript/ShortcutButton, + run_current_inner = $Layout/CRunCurrentInner/ShortcutButton, + run_current_test = $Layout/CRunCurrentTest/ShortcutButton, + panel_button = $Layout/CPanelButton/ShortcutButton, +} + +func _ready(): + for key in _ctrls: + var sc_button = _ctrls[key] + sc_button.connect('start_edit', _on_edit_start.bind(sc_button)) + sc_button.connect('end_edit', _on_edit_end) + + + # show dialog when running scene from editor. + if(get_parent() == get_tree().root): + popup_centered() + +# ------------ +# Events +# ------------ +func _on_Hide_pressed(): + hide() + +func _on_edit_start(which): + for key in _ctrls: + var sc_button = _ctrls[key] + if(sc_button != which): + sc_button.disable_set(true) + sc_button.disable_clear(true) + +func _on_edit_end(): + for key in _ctrls: + var sc_button = _ctrls[key] + sc_button.disable_set(false) + sc_button.disable_clear(false) + +# ------------ +# Public +# ------------ +func get_run_all(): + return _ctrls.run_all.get_shortcut() + +func get_run_current_script(): + return _ctrls.run_current_script.get_shortcut() + +func get_run_current_inner(): + return _ctrls.run_current_inner.get_shortcut() + +func get_run_current_test(): + return _ctrls.run_current_test.get_shortcut() + +func get_panel_button(): + return _ctrls.panel_button.get_shortcut() + + +func save_shortcuts(path): + var f = ConfigFile.new() + + f.set_value('main', 'run_all', _ctrls.run_all.get_shortcut()) + f.set_value('main', 'run_current_script', _ctrls.run_current_script.get_shortcut()) + f.set_value('main', 'run_current_inner', _ctrls.run_current_inner.get_shortcut()) + f.set_value('main', 'run_current_test', _ctrls.run_current_test.get_shortcut()) + f.set_value('main', 'panel_button', _ctrls.panel_button.get_shortcut()) + + f.save(path) + + +func load_shortcuts(path): + var emptyShortcut = Shortcut.new() + var f = ConfigFile.new() + f.load(path) + + _ctrls.run_all.set_shortcut(f.get_value('main', 'run_all', emptyShortcut)) + _ctrls.run_current_script.set_shortcut(f.get_value('main', 'run_current_script', emptyShortcut)) + _ctrls.run_current_inner.set_shortcut(f.get_value('main', 'run_current_inner', emptyShortcut)) + _ctrls.run_current_test.set_shortcut(f.get_value('main', 'run_current_test', emptyShortcut)) + _ctrls.panel_button.set_shortcut(f.get_value('main', 'panel_button', emptyShortcut)) diff --git a/samples/client/petstore/gdscript/addons/gut/gui/BottomPanelShortcuts.tscn b/samples/client/petstore/gdscript/addons/gut/gui/BottomPanelShortcuts.tscn new file mode 100644 index 000000000000..bfcdd389e34d --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/gui/BottomPanelShortcuts.tscn @@ -0,0 +1,150 @@ +[gd_scene load_steps=3 format=3 uid="uid://bsk32dh41b4gs"] + +[ext_resource type="PackedScene" uid="uid://sfb1fw8j6ufu" path="res://addons/gut/gui/ShortcutButton.tscn" id="1"] +[ext_resource type="Script" path="res://addons/gut/gui/BottomPanelShortcuts.gd" id="2"] + +[node name="BottomPanelShortcuts" type="Popup"] +title = "Shortcuts" +size = Vector2i(500, 350) +visible = true +exclusive = true +script = ExtResource("2") + +[node name="Layout" type="VBoxContainer" parent="."] +anchors_preset = 15 +anchor_right = 1.0 +anchor_bottom = 1.0 +offset_left = 5.0 +offset_right = -5.0 +offset_bottom = 2.0 + +[node name="TopPad" type="CenterContainer" parent="Layout"] +custom_minimum_size = Vector2(0, 5) +layout_mode = 2 + +[node name="Label2" type="Label" parent="Layout"] +custom_minimum_size = Vector2(0, 20) +layout_mode = 2 +text = "Always Active" + +[node name="ColorRect" type="ColorRect" parent="Layout/Label2"] +show_behind_parent = true +layout_mode = 0 +anchor_right = 1.0 +anchor_bottom = 1.0 +color = Color(0, 0, 0, 0.196078) + +[node name="CPanelButton" type="HBoxContainer" parent="Layout"] +layout_mode = 2 + +[node name="Label" type="Label" parent="Layout/CPanelButton"] +custom_minimum_size = Vector2(50, 0) +layout_mode = 2 +size_flags_vertical = 7 +text = "Show/Hide GUT Panel" + +[node name="ShortcutButton" parent="Layout/CPanelButton" instance=ExtResource("1")] +layout_mode = 2 +size_flags_horizontal = 3 + +[node name="GutPanelPad" type="CenterContainer" parent="Layout"] +custom_minimum_size = Vector2(0, 5) +layout_mode = 2 + +[node name="Label" type="Label" parent="Layout"] +custom_minimum_size = Vector2(0, 20) +layout_mode = 2 +text = "Only Active When GUT Panel Shown" + +[node name="ColorRect2" type="ColorRect" parent="Layout/Label"] +show_behind_parent = true +layout_mode = 0 +anchor_right = 1.0 +anchor_bottom = 1.0 +color = Color(0, 0, 0, 0.196078) + +[node name="TopPad2" type="CenterContainer" parent="Layout"] +custom_minimum_size = Vector2(0, 5) +layout_mode = 2 + +[node name="CRunAll" type="HBoxContainer" parent="Layout"] +layout_mode = 2 + +[node name="Label" type="Label" parent="Layout/CRunAll"] +custom_minimum_size = Vector2(50, 0) +layout_mode = 2 +size_flags_vertical = 7 +text = "Run All" + +[node name="ShortcutButton" parent="Layout/CRunAll" instance=ExtResource("1")] +layout_mode = 2 +size_flags_horizontal = 3 + +[node name="CRunCurrentScript" type="HBoxContainer" parent="Layout"] +layout_mode = 2 + +[node name="Label" type="Label" parent="Layout/CRunCurrentScript"] +custom_minimum_size = Vector2(50, 0) +layout_mode = 2 +size_flags_vertical = 7 +text = "Run Current Script" + +[node name="ShortcutButton" parent="Layout/CRunCurrentScript" instance=ExtResource("1")] +layout_mode = 2 +size_flags_horizontal = 3 + +[node name="CRunCurrentInner" type="HBoxContainer" parent="Layout"] +layout_mode = 2 + +[node name="Label" type="Label" parent="Layout/CRunCurrentInner"] +custom_minimum_size = Vector2(50, 0) +layout_mode = 2 +size_flags_vertical = 7 +text = "Run Current Inner Class" + +[node name="ShortcutButton" parent="Layout/CRunCurrentInner" instance=ExtResource("1")] +layout_mode = 2 +size_flags_horizontal = 3 + +[node name="CRunCurrentTest" type="HBoxContainer" parent="Layout"] +layout_mode = 2 + +[node name="Label" type="Label" parent="Layout/CRunCurrentTest"] +custom_minimum_size = Vector2(50, 0) +layout_mode = 2 +size_flags_vertical = 7 +text = "Run Current Test" + +[node name="ShortcutButton" parent="Layout/CRunCurrentTest" instance=ExtResource("1")] +layout_mode = 2 +size_flags_horizontal = 3 + +[node name="CenterContainer2" type="CenterContainer" parent="Layout"] +custom_minimum_size = Vector2(0, 5) +layout_mode = 2 +size_flags_horizontal = 3 +size_flags_vertical = 3 + +[node name="ShiftDisclaimer" type="Label" parent="Layout"] +layout_mode = 2 +text = "\"Shift\" cannot be the only modifier for a shortcut." + +[node name="HBoxContainer" type="HBoxContainer" parent="Layout"] +layout_mode = 2 + +[node name="CenterContainer" type="CenterContainer" parent="Layout/HBoxContainer"] +layout_mode = 2 +size_flags_horizontal = 3 +size_flags_vertical = 3 + +[node name="Hide" type="Button" parent="Layout/HBoxContainer"] +custom_minimum_size = Vector2(60, 30) +layout_mode = 2 +text = "Close" + +[node name="BottomPad" type="CenterContainer" parent="Layout"] +custom_minimum_size = Vector2(0, 10) +layout_mode = 2 +size_flags_horizontal = 3 + +[connection signal="pressed" from="Layout/HBoxContainer/Hide" to="." method="_on_Hide_pressed"] diff --git a/samples/client/petstore/gdscript/addons/gut/gui/GutBottomPanel.gd b/samples/client/petstore/gdscript/addons/gut/gui/GutBottomPanel.gd new file mode 100644 index 000000000000..404320b90cb6 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/gui/GutBottomPanel.gd @@ -0,0 +1,367 @@ +@tool +extends Control + +const RUNNER_JSON_PATH = 'res://.gut_editor_config.json' +const RESULT_FILE = 'user://.gut_editor.bbcode' +const RESULT_JSON = 'user://.gut_editor.json' +const SHORTCUTS_PATH = 'res://.gut_editor_shortcuts.cfg' + +var TestScript = load('res://addons/gut/test.gd') +var GutConfigGui = load('res://addons/gut/gui/gut_config_gui.gd') +var ScriptTextEditors = load('res://addons/gut/gui/script_text_editor_controls.gd') + +var _interface = null; +var _is_running = false; +var _gut_config = load('res://addons/gut/gut_config.gd').new() +var _gut_config_gui = null +var _gut_plugin = null +var _light_color = Color(0, 0, 0, .5) +var _panel_button = null +var _last_selected_path = null + + +@onready var _ctrls = { + output = $layout/RSplit/CResults/TabBar/OutputText.get_rich_text_edit(), + output_ctrl = $layout/RSplit/CResults/TabBar/OutputText, + run_button = $layout/ControlBar/RunAll, + shortcuts_button = $layout/ControlBar/Shortcuts, + + settings_button = $layout/ControlBar/Settings, + run_results_button = $layout/ControlBar/RunResultsBtn, + output_button = $layout/ControlBar/OutputBtn, + + settings = $layout/RSplit/sc/Settings, + shortcut_dialog = $BottomPanelShortcuts, + light = $layout/RSplit/CResults/ControlBar/Light3D, + results = { + bar = $layout/RSplit/CResults/ControlBar, + passing = $layout/RSplit/CResults/ControlBar/Passing/value, + failing = $layout/RSplit/CResults/ControlBar/Failing/value, + pending = $layout/RSplit/CResults/ControlBar/Pending/value, + errors = $layout/RSplit/CResults/ControlBar/Errors/value, + warnings = $layout/RSplit/CResults/ControlBar/Warnings/value, + orphans = $layout/RSplit/CResults/ControlBar/Orphans/value + }, + run_at_cursor = $layout/ControlBar/RunAtCursor, + run_results = $layout/RSplit/CResults/TabBar/RunResults +} + + +func _init(): + _gut_config.load_panel_options(RUNNER_JSON_PATH) + + +func _ready(): + _ctrls.results.bar.connect('draw', _on_results_bar_draw.bind(_ctrls.results.bar)) + hide_settings(!_ctrls.settings_button.button_pressed) + _gut_config_gui = GutConfigGui.new(_ctrls.settings) + _gut_config_gui.set_options(_gut_config.options) + + _apply_options_to_controls() + + _ctrls.shortcuts_button.icon = get_theme_icon('Shortcut', 'EditorIcons') + _ctrls.settings_button.icon = get_theme_icon('Tools', 'EditorIcons') + _ctrls.run_results_button.icon = get_theme_icon('AnimationTrackGroup', 'EditorIcons') # Tree + _ctrls.output_button.icon = get_theme_icon('Font', 'EditorIcons') + + _ctrls.run_results.set_output_control(_ctrls.output_ctrl) + _ctrls.run_results.set_font( + _gut_config.options.panel_options.font_name, + _gut_config.options.panel_options.font_size) + + var check_import = load('res://addons/gut/images/red.png') + if(check_import == null): + _ctrls.run_results.add_centered_text("GUT got some new images that are not imported yet. Please restart Godot.") + print('GUT got some new images that are not imported yet. Please restart Godot.') + else: + _ctrls.run_results.add_centered_text("Let's run some tests!") + + +func _apply_options_to_controls(): + hide_settings(_gut_config.options.panel_options.hide_settings) + hide_result_tree(_gut_config.options.panel_options.hide_result_tree) + hide_output_text(_gut_config.options.panel_options.hide_output_text) + + _ctrls.output_ctrl.set_use_colors(_gut_config.options.panel_options.use_colors) + _ctrls.output_ctrl.set_all_fonts(_gut_config.options.panel_options.font_name) + _ctrls.output_ctrl.set_font_size(_gut_config.options.panel_options.font_size) + + _ctrls.run_results.set_font( + _gut_config.options.panel_options.font_name, + _gut_config.options.panel_options.font_size) + _ctrls.run_results.set_show_orphans(!_gut_config.options.hide_orphans) + + +func _process(delta): + if(_is_running): + if(!_interface.is_playing_scene()): + _is_running = false + _ctrls.output_ctrl.add_text("\ndone") + load_result_output() + _gut_plugin.make_bottom_panel_item_visible(self) + +# --------------- +# Private +# --------------- + +func load_shortcuts(): + _ctrls.shortcut_dialog.load_shortcuts(SHORTCUTS_PATH) + _apply_shortcuts() + + +func _is_test_script(script): + var from = script.get_base_script() + while(from and from.resource_path != 'res://addons/gut/test.gd'): + from = from.get_base_script() + + return from != null + + +func _show_errors(errs): + _ctrls.output_ctrl.clear() + var text = "Cannot run tests, you have a configuration error:\n" + for e in errs: + text += str('* ', e, "\n") + text += "Check your settings ----->" + _ctrls.output_ctrl.add_text(text) + hide_output_text(false) + hide_settings(false) + + +func _save_config(): + _gut_config.options = _gut_config_gui.get_options(_gut_config.options) + _gut_config.options.panel_options.hide_settings = !_ctrls.settings_button.button_pressed + _gut_config.options.panel_options.hide_result_tree = !_ctrls.run_results_button.button_pressed + _gut_config.options.panel_options.hide_output_text = !_ctrls.output_button.button_pressed + _gut_config.options.panel_options.use_colors = _ctrls.output_ctrl.get_use_colors() + + var w_result = _gut_config.write_options(RUNNER_JSON_PATH) + if(w_result != OK): + push_error(str('Could not write options to ', RUNNER_JSON_PATH, ': ', w_result)) + return; + + +func _run_tests(): + var issues = _gut_config_gui.get_config_issues() + if(issues.size() > 0): + _show_errors(issues) + return + + write_file(RESULT_FILE, 'Run in progress') + _save_config() + _apply_options_to_controls() + + _ctrls.output_ctrl.clear() + _ctrls.run_results.clear() + _ctrls.run_results.add_centered_text('Running...') + + _interface.play_custom_scene('res://addons/gut/gui/GutRunner.tscn') + _is_running = true + _ctrls.output_ctrl.add_text('Running...') + + +func _apply_shortcuts(): + _ctrls.run_button.shortcut = _ctrls.shortcut_dialog.get_run_all() + + _ctrls.run_at_cursor.get_script_button().shortcut = \ + _ctrls.shortcut_dialog.get_run_current_script() + _ctrls.run_at_cursor.get_inner_button().shortcut = \ + _ctrls.shortcut_dialog.get_run_current_inner() + _ctrls.run_at_cursor.get_test_button().shortcut = \ + _ctrls.shortcut_dialog.get_run_current_test() + + _panel_button.shortcut = _ctrls.shortcut_dialog.get_panel_button() + + +func _run_all(): + _gut_config.options.selected = null + _gut_config.options.inner_class = null + _gut_config.options.unit_test_name = null + + _run_tests() + + +# --------------- +# Events +# --------------- +func _on_results_bar_draw(bar): + bar.draw_rect(Rect2(Vector2(0, 0), bar.size), Color(0, 0, 0, .2)) + + +func _on_Light_draw(): + var l = _ctrls.light + l.draw_circle(Vector2(l.size.x / 2, l.size.y / 2), l.size.x / 2, _light_color) + + +func _on_editor_script_changed(script): + if(script): + set_current_script(script) + + +func _on_RunAll_pressed(): + _run_all() + + +func _on_Shortcuts_pressed(): + _ctrls.shortcut_dialog.popup_centered() + +func _on_bottom_panel_shortcuts_visibility_changed(): + _apply_shortcuts() + _ctrls.shortcut_dialog.save_shortcuts(SHORTCUTS_PATH) + +func _on_RunAtCursor_run_tests(what): + _gut_config.options.selected = what.script + _gut_config.options.inner_class = what.inner_class + _gut_config.options.unit_test_name = what.test_method + + _run_tests() + + +func _on_Settings_pressed(): + hide_settings(!_ctrls.settings_button.button_pressed) + _save_config() + + +func _on_OutputBtn_pressed(): + hide_output_text(!_ctrls.output_button.button_pressed) + _save_config() + + +func _on_RunResultsBtn_pressed(): + hide_result_tree(! _ctrls.run_results_button.button_pressed) + _save_config() + + +# Currently not used, but will be when I figure out how to put +# colors into the text results +func _on_UseColors_pressed(): + pass + +# --------------- +# Public +# --------------- +func hide_result_tree(should): + _ctrls.run_results.visible = !should + _ctrls.run_results_button.button_pressed = !should + + +func hide_settings(should): + var s_scroll = _ctrls.settings.get_parent() + s_scroll.visible = !should + + # collapse only collapses the first control, so we move + # settings around to be the collapsed one + if(should): + s_scroll.get_parent().move_child(s_scroll, 0) + else: + s_scroll.get_parent().move_child(s_scroll, 1) + + $layout/RSplit.collapsed = should + _ctrls.settings_button.button_pressed = !should + + +func hide_output_text(should): + $layout/RSplit/CResults/TabBar/OutputText.visible = !should + _ctrls.output_button.button_pressed = !should + + +func load_result_output(): + _ctrls.output_ctrl.load_file(RESULT_FILE) + + var summary = get_file_as_text(RESULT_JSON) + var test_json_conv = JSON.new() + if (test_json_conv.parse(summary) != OK): + return + var results = test_json_conv.get_data() + + _ctrls.run_results.load_json_results(results) + + var summary_json = results['test_scripts']['props'] + _ctrls.results.passing.text = str(summary_json.passing) + _ctrls.results.passing.get_parent().visible = true + + _ctrls.results.failing.text = str(summary_json.failures) + _ctrls.results.failing.get_parent().visible = true + + _ctrls.results.pending.text = str(summary_json.pending) + _ctrls.results.pending.get_parent().visible = _ctrls.results.pending.text != '0' + + _ctrls.results.errors.text = str(summary_json.errors) + _ctrls.results.errors.get_parent().visible = _ctrls.results.errors.text != '0' + + _ctrls.results.warnings.text = str(summary_json.warnings) + _ctrls.results.warnings.get_parent().visible = _ctrls.results.warnings.text != '0' + + _ctrls.results.orphans.text = str(summary_json.orphans) + _ctrls.results.orphans.get_parent().visible = _ctrls.results.orphans.text != '0' and !_gut_config.options.hide_orphans + + if(summary_json.tests == 0): + _light_color = Color(1, 0, 0, .75) + elif(summary_json.failures != 0): + _light_color = Color(1, 0, 0, .75) + elif(summary_json.pending != 0): + _light_color = Color(1, 1, 0, .75) + else: + _light_color = Color(0, 1, 0, .75) + _ctrls.light.visible = true + _ctrls.light.queue_redraw() + + +func set_current_script(script): + if(script): + if(_is_test_script(script)): + var file = script.resource_path.get_file() + _last_selected_path = script.resource_path.get_file() + _ctrls.run_at_cursor.activate_for_script(script.resource_path) + + +func set_interface(value): + _interface = value + _interface.get_script_editor().connect("editor_script_changed",Callable(self,'_on_editor_script_changed')) + + var ste = ScriptTextEditors.new(_interface.get_script_editor()) + _ctrls.run_results.set_interface(_interface) + _ctrls.run_results.set_script_text_editors(ste) + _ctrls.run_at_cursor.set_script_text_editors(ste) + set_current_script(_interface.get_script_editor().get_current_script()) + + +func set_plugin(value): + _gut_plugin = value + + +func set_panel_button(value): + _panel_button = value + +# ------------------------------------------------------------------------------ +# Write a file. +# ------------------------------------------------------------------------------ +func write_file(path, content): + var f = FileAccess.open(path, FileAccess.WRITE) + if(f != null): + f.store_string(content) + f = null; + + return FileAccess.get_open_error() + + +# ------------------------------------------------------------------------------ +# Returns the text of a file or an empty string if the file could not be opened. +# ------------------------------------------------------------------------------ +func get_file_as_text(path): + var to_return = '' + var f = FileAccess.open(path, FileAccess.READ) + if(f != null): + to_return = f.get_as_text() + f = null + return to_return + + +# ------------------------------------------------------------------------------ +# return if_null if value is null otherwise return value +# ------------------------------------------------------------------------------ +func nvl(value, if_null): + if(value == null): + return if_null + else: + return value diff --git a/samples/client/petstore/gdscript/addons/gut/gui/GutBottomPanel.tscn b/samples/client/petstore/gdscript/addons/gut/gui/GutBottomPanel.tscn new file mode 100644 index 000000000000..fdcdc1e6ed70 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/gui/GutBottomPanel.tscn @@ -0,0 +1,249 @@ +[gd_scene load_steps=10 format=3 uid="uid://b3bostcslstem"] + +[ext_resource type="Script" path="res://addons/gut/gui/GutBottomPanel.gd" id="1"] +[ext_resource type="PackedScene" uid="uid://bsk32dh41b4gs" path="res://addons/gut/gui/BottomPanelShortcuts.tscn" id="2"] +[ext_resource type="PackedScene" uid="uid://0yunjxtaa8iw" path="res://addons/gut/gui/RunAtCursor.tscn" id="3"] +[ext_resource type="Texture2D" uid="uid://cr6tvdv0ve6cv" path="res://addons/gut/gui/play.png" id="4"] +[ext_resource type="PackedScene" uid="uid://4gyyn12um08h" path="res://addons/gut/gui/RunResults.tscn" id="5"] +[ext_resource type="PackedScene" uid="uid://bqmo4dj64c7yl" path="res://addons/gut/gui/OutputText.tscn" id="6"] + +[sub_resource type="Shortcut" id="9"] + +[sub_resource type="Image" id="Image_18d1g"] +data = { +"data": PackedByteArray(255, 255, 255, 0, 255, 255, 255, 0, 255, 128, 128, 4, 255, 128, 128, 4, 255, 128, 128, 4, 255, 128, 128, 4, 255, 128, 128, 4, 255, 128, 128, 4, 255, 128, 128, 4, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 255, 255, 0, 255, 93, 93, 131, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 255, 255, 0, 255, 93, 93, 255, 255, 93, 93, 131, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 255, 255, 0, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 131, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 255, 255, 0, 255, 93, 93, 252, 255, 93, 93, 252, 255, 93, 93, 252, 255, 94, 94, 127, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 128, 128, 4, 255, 128, 128, 4, 255, 128, 128, 4, 255, 128, 128, 4, 255, 128, 128, 4, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 93, 93, 231, 255, 93, 93, 55, 255, 97, 97, 58, 255, 93, 93, 233, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 231, 255, 94, 94, 54, 255, 94, 94, 57, 255, 93, 93, 233, 255, 93, 93, 255, 255, 93, 93, 255, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 97, 97, 42, 255, 255, 255, 0, 255, 255, 255, 0, 255, 97, 97, 42, 255, 93, 93, 233, 255, 93, 93, 232, 255, 93, 93, 41, 255, 255, 255, 0, 255, 255, 255, 0, 255, 97, 97, 42, 255, 93, 93, 233, 255, 93, 93, 232, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 96, 96, 45, 255, 97, 97, 42, 255, 255, 255, 0, 255, 97, 97, 42, 255, 97, 97, 42, 255, 255, 255, 0, 255, 98, 98, 47, 255, 97, 97, 42, 255, 255, 255, 0, 255, 97, 97, 42, 255, 97, 97, 42, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 96, 96, 45, 255, 93, 93, 235, 255, 93, 93, 233, 255, 97, 97, 42, 255, 255, 255, 0, 255, 255, 255, 0, 255, 94, 94, 46, 255, 93, 93, 236, 255, 93, 93, 233, 255, 97, 97, 42, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 93, 93, 235, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 233, 255, 95, 95, 59, 255, 96, 96, 61, 255, 93, 93, 235, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 233, 255, 95, 95, 59, 255, 96, 96, 61, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 93, 93, 252, 255, 93, 93, 252, 255, 93, 93, 252, 255, 93, 93, 252, 255, 93, 93, 252, 255, 93, 93, 252, 255, 93, 93, 252, 255, 93, 93, 252, 255, 93, 93, 252, 255, 93, 93, 252, 255, 93, 93, 252, 255, 93, 93, 252, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0), +"format": "RGBA8", +"height": 16, +"mipmaps": false, +"width": 16 +} + +[sub_resource type="ImageTexture" id="ImageTexture_8u17l"] +image = SubResource("Image_18d1g") + +[node name="GutBottomPanel" type="Control"] +custom_minimum_size = Vector2(250, 250) +layout_mode = 3 +anchor_left = -0.0025866 +anchor_top = -0.00176575 +anchor_right = 0.997413 +anchor_bottom = 0.998234 +offset_left = 2.64868 +offset_top = 1.05945 +offset_right = 2.64862 +offset_bottom = 1.05945 +script = ExtResource("1") + +[node name="layout" type="VBoxContainer" parent="."] +layout_mode = 0 +anchor_right = 1.0 +anchor_bottom = 1.0 + +[node name="ControlBar" type="HBoxContainer" parent="layout"] +layout_mode = 2 + +[node name="RunAll" type="Button" parent="layout/ControlBar"] +layout_mode = 2 +size_flags_vertical = 11 +shortcut = SubResource("9") +text = "Run All" +icon = ExtResource("4") + +[node name="Label" type="Label" parent="layout/ControlBar"] +layout_mode = 2 +mouse_filter = 1 +text = "Current: " + +[node name="RunAtCursor" parent="layout/ControlBar" instance=ExtResource("3")] +layout_mode = 2 + +[node name="CenterContainer2" type="CenterContainer" parent="layout/ControlBar"] +layout_mode = 2 +size_flags_horizontal = 3 + +[node name="Sep1" type="ColorRect" parent="layout/ControlBar"] +custom_minimum_size = Vector2(1, 2.08165e-12) +layout_mode = 2 + +[node name="RunResultsBtn" type="Button" parent="layout/ControlBar"] +layout_mode = 2 +toggle_mode = true +button_pressed = true +icon = SubResource("ImageTexture_8u17l") + +[node name="OutputBtn" type="Button" parent="layout/ControlBar"] +layout_mode = 2 +toggle_mode = true +icon = SubResource("ImageTexture_8u17l") + +[node name="Settings" type="Button" parent="layout/ControlBar"] +layout_mode = 2 +toggle_mode = true +button_pressed = true +icon = SubResource("ImageTexture_8u17l") + +[node name="Sep2" type="ColorRect" parent="layout/ControlBar"] +custom_minimum_size = Vector2(1, 2.08165e-12) +layout_mode = 2 + +[node name="Shortcuts" type="Button" parent="layout/ControlBar"] +layout_mode = 2 +size_flags_vertical = 11 +icon = SubResource("ImageTexture_8u17l") + +[node name="RSplit" type="HSplitContainer" parent="layout"] +layout_mode = 2 +size_flags_horizontal = 3 +size_flags_vertical = 3 + +[node name="CResults" type="VBoxContainer" parent="layout/RSplit"] +layout_mode = 2 +size_flags_horizontal = 3 +size_flags_vertical = 3 + +[node name="ControlBar" type="HBoxContainer" parent="layout/RSplit/CResults"] +layout_mode = 2 + +[node name="Sep2" type="ColorRect" parent="layout/RSplit/CResults/ControlBar"] +custom_minimum_size = Vector2(1, 2.08165e-12) +layout_mode = 2 + +[node name="Light3D" type="Control" parent="layout/RSplit/CResults/ControlBar"] +custom_minimum_size = Vector2(30, 30) +layout_mode = 2 + +[node name="Passing" type="HBoxContainer" parent="layout/RSplit/CResults/ControlBar"] +visible = false +layout_mode = 2 + +[node name="Sep" type="ColorRect" parent="layout/RSplit/CResults/ControlBar/Passing"] +custom_minimum_size = Vector2(1, 2.08165e-12) +layout_mode = 2 + +[node name="label" type="Label" parent="layout/RSplit/CResults/ControlBar/Passing"] +layout_mode = 2 +text = "Passing" + +[node name="value" type="Label" parent="layout/RSplit/CResults/ControlBar/Passing"] +layout_mode = 2 +text = "---" + +[node name="Failing" type="HBoxContainer" parent="layout/RSplit/CResults/ControlBar"] +visible = false +layout_mode = 2 + +[node name="Sep" type="ColorRect" parent="layout/RSplit/CResults/ControlBar/Failing"] +custom_minimum_size = Vector2(1, 2.08165e-12) +layout_mode = 2 + +[node name="label" type="Label" parent="layout/RSplit/CResults/ControlBar/Failing"] +layout_mode = 2 +text = "Failing" + +[node name="value" type="Label" parent="layout/RSplit/CResults/ControlBar/Failing"] +layout_mode = 2 +text = "---" + +[node name="Pending" type="HBoxContainer" parent="layout/RSplit/CResults/ControlBar"] +visible = false +layout_mode = 2 + +[node name="Sep" type="ColorRect" parent="layout/RSplit/CResults/ControlBar/Pending"] +custom_minimum_size = Vector2(1, 2.08165e-12) +layout_mode = 2 + +[node name="label" type="Label" parent="layout/RSplit/CResults/ControlBar/Pending"] +layout_mode = 2 +text = "Pending" + +[node name="value" type="Label" parent="layout/RSplit/CResults/ControlBar/Pending"] +layout_mode = 2 +text = "---" + +[node name="Orphans" type="HBoxContainer" parent="layout/RSplit/CResults/ControlBar"] +visible = false +layout_mode = 2 + +[node name="Sep" type="ColorRect" parent="layout/RSplit/CResults/ControlBar/Orphans"] +custom_minimum_size = Vector2(1, 2.08165e-12) +layout_mode = 2 + +[node name="label" type="Label" parent="layout/RSplit/CResults/ControlBar/Orphans"] +layout_mode = 2 +text = "Orphans" + +[node name="value" type="Label" parent="layout/RSplit/CResults/ControlBar/Orphans"] +layout_mode = 2 +text = "---" + +[node name="Errors" type="HBoxContainer" parent="layout/RSplit/CResults/ControlBar"] +visible = false +layout_mode = 2 + +[node name="Sep" type="ColorRect" parent="layout/RSplit/CResults/ControlBar/Errors"] +custom_minimum_size = Vector2(1, 2.08165e-12) +layout_mode = 2 + +[node name="label" type="Label" parent="layout/RSplit/CResults/ControlBar/Errors"] +layout_mode = 2 +text = "Errors" + +[node name="value" type="Label" parent="layout/RSplit/CResults/ControlBar/Errors"] +layout_mode = 2 +text = "---" + +[node name="Warnings" type="HBoxContainer" parent="layout/RSplit/CResults/ControlBar"] +visible = false +layout_mode = 2 + +[node name="Sep" type="ColorRect" parent="layout/RSplit/CResults/ControlBar/Warnings"] +custom_minimum_size = Vector2(1, 2.08165e-12) +layout_mode = 2 + +[node name="label" type="Label" parent="layout/RSplit/CResults/ControlBar/Warnings"] +layout_mode = 2 +text = "Warnings" + +[node name="value" type="Label" parent="layout/RSplit/CResults/ControlBar/Warnings"] +layout_mode = 2 +text = "---" + +[node name="CenterContainer" type="CenterContainer" parent="layout/RSplit/CResults/ControlBar"] +layout_mode = 2 +size_flags_horizontal = 3 + +[node name="TabBar" type="HSplitContainer" parent="layout/RSplit/CResults"] +layout_mode = 2 +size_flags_horizontal = 3 +size_flags_vertical = 3 + +[node name="RunResults" parent="layout/RSplit/CResults/TabBar" instance=ExtResource("5")] +layout_mode = 2 +size_flags_horizontal = 3 +size_flags_vertical = 3 + +[node name="OutputText" parent="layout/RSplit/CResults/TabBar" instance=ExtResource("6")] +visible = false +layout_mode = 2 + +[node name="sc" type="ScrollContainer" parent="layout/RSplit"] +custom_minimum_size = Vector2(500, 2.08165e-12) +layout_mode = 2 +size_flags_vertical = 3 + +[node name="Settings" type="VBoxContainer" parent="layout/RSplit/sc"] +layout_mode = 2 +size_flags_horizontal = 3 +size_flags_vertical = 3 + +[node name="BottomPanelShortcuts" parent="." instance=ExtResource("2")] +visible = false + +[connection signal="pressed" from="layout/ControlBar/RunAll" to="." method="_on_RunAll_pressed"] +[connection signal="run_tests" from="layout/ControlBar/RunAtCursor" to="." method="_on_RunAtCursor_run_tests"] +[connection signal="pressed" from="layout/ControlBar/RunResultsBtn" to="." method="_on_RunResultsBtn_pressed"] +[connection signal="pressed" from="layout/ControlBar/OutputBtn" to="." method="_on_OutputBtn_pressed"] +[connection signal="pressed" from="layout/ControlBar/Settings" to="." method="_on_Settings_pressed"] +[connection signal="pressed" from="layout/ControlBar/Shortcuts" to="." method="_on_Shortcuts_pressed"] +[connection signal="draw" from="layout/RSplit/CResults/ControlBar/Light3D" to="." method="_on_Light_draw"] +[connection signal="visibility_changed" from="BottomPanelShortcuts" to="." method="_on_bottom_panel_shortcuts_visibility_changed"] diff --git a/samples/client/petstore/gdscript/addons/gut/gui/GutRunner.gd b/samples/client/petstore/gdscript/addons/gut/gui/GutRunner.gd new file mode 100644 index 000000000000..1214353b6de3 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/gui/GutRunner.gd @@ -0,0 +1,121 @@ +extends Node2D + +var Gut = load('res://addons/gut/gut.gd') +var ResultExporter = load('res://addons/gut/result_exporter.gd') +var GutConfig = load('res://addons/gut/gut_config.gd') + +const RUNNER_JSON_PATH = 'res://.gut_editor_config.json' +const RESULT_FILE = 'user://.gut_editor.bbcode' +const RESULT_JSON = 'user://.gut_editor.json' + +var _gut_config = null +var _gut = null; +var _wrote_results = false +# Flag for when this is being used at the command line. Otherwise it is +# assumed this is being used by the panel and being launched with +# play_custom_scene +var _cmdln_mode = false + +@onready var _gut_layer = $GutLayer +@onready var _gui = $GutLayer/GutScene + +var auto_run_tests = true + +func _ready(): + if(_gut_config == null): + _gut_config = GutConfig.new() + _gut_config.load_panel_options(RUNNER_JSON_PATH) + + # The command line will call run_tests on its own. When used from the panel + # we have to kick off the tests ourselves b/c there's no way I know of to + # interact with the scene that was run via play_custom_scene. + if(!_cmdln_mode and auto_run_tests): + call_deferred('run_tests') + + +func run_tests(show_gui=true): + + if(_gut == null): + get_gut() + + _setup_gui(show_gui) + + _gut.add_children_to = self + if(_gut_config.options.gut_on_top): + _gut_layer.add_child(_gut) + else: + add_child(_gut) + + if(!_cmdln_mode): + _gut.end_run.connect(_on_tests_finished.bind(_gut_config.options.should_exit, _gut_config.options.should_exit_on_success)) + + _gut_config.config_gut(_gut) + var run_rest_of_scripts = _gut_config.options.unit_test_name == '' + + _gut.test_scripts(run_rest_of_scripts) + + +func _setup_gui(show_gui): + if(show_gui): + _gui.gut = _gut + var printer = _gut.logger.get_printer('gui') + printer.set_textbox(_gui.get_textbox()) + else: + _gut.logger.disable_printer('gui', true) + _gui.visible = false + + var opts = _gut_config.options + _gui.set_font_size(opts.font_size) + _gui.set_font(opts.font_name) + if(opts.font_color != null and opts.font_color.is_valid_html_color()): + _gui.set_default_font_color(Color(opts.font_color)) + if(opts.background_color != null and opts.background_color.is_valid_html_color()): + _gui.set_background_color(Color(opts.background_color)) + + _gui.set_opacity(min(1.0, float(opts.opacity) / 100)) + # if(opts.should_maximize): + # _tester.maximize() + _gui.use_compact_mode(opts.compact_mode) + + + +func _write_results(): + var content = _gui.get_textbox().get_parsed_text() #_gut.logger.get_gui_bbcode() + var f = FileAccess.open(RESULT_FILE, FileAccess.WRITE) + if(f != null): + f.store_string(content) + f = null # closes file + else: + push_error('Could not save bbcode, result = ', FileAccess.get_open_error()) + + var exporter = ResultExporter.new() + var f_result = exporter.write_json_file(_gut, RESULT_JSON) + _wrote_results = true + + +func _exit_tree(): + if(!_wrote_results and !_cmdln_mode): + _write_results() + + +func _on_tests_finished(should_exit, should_exit_on_success): + _write_results() + + if(should_exit): + get_tree().quit() + elif(should_exit_on_success and _gut.get_fail_count() == 0): + get_tree().quit() + + +func get_gut(): + if(_gut == null): + _gut = Gut.new() + return _gut + + +func set_gut_config(which): + _gut_config = which + + +func set_cmdln_mode(is_it): + _cmdln_mode = is_it diff --git a/samples/client/petstore/gdscript/addons/gut/gui/GutRunner.tscn b/samples/client/petstore/gdscript/addons/gut/gui/GutRunner.tscn new file mode 100644 index 000000000000..fa98d3399ff9 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/gui/GutRunner.tscn @@ -0,0 +1,12 @@ +[gd_scene load_steps=3 format=3 uid="uid://bqy3ikt6vu4b5"] + +[ext_resource type="Script" path="res://addons/gut/gui/GutRunner.gd" id="1"] +[ext_resource type="PackedScene" uid="uid://m28heqtswbuq" path="res://addons/gut/GutScene.tscn" id="2_6ruxb"] + +[node name="GutRunner" type="Node2D"] +script = ExtResource("1") + +[node name="GutLayer" type="CanvasLayer" parent="."] +layer = 128 + +[node name="GutScene" parent="GutLayer" instance=ExtResource("2_6ruxb")] diff --git a/samples/client/petstore/gdscript/addons/gut/gui/GutSceneTheme.tres b/samples/client/petstore/gdscript/addons/gut/gui/GutSceneTheme.tres new file mode 100644 index 000000000000..61ca6ab5edd1 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/gui/GutSceneTheme.tres @@ -0,0 +1,505 @@ +[gd_resource type="Theme" load_steps=6 format=3 uid="uid://cstkhwkpajvqu"] + +[ext_resource type="FontFile" uid="uid://c6c7gnx36opr0" path="res://addons/gut/fonts/AnonymousPro-Regular.ttf" id="1_df57p"] + +[sub_resource type="Image" id="Image_1b8gs"] +data = { +"data": PackedByteArray(255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 8, 255, 139, 255, 221, 255, 245, 255, 222, 255, 163, 255, 42, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 66, 255, 207, 255, 247, 255, 231, 255, 135, 255, 6, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 252, 255, 253, 255, 184, 255, 62, 255, 207, 255, 247, 255, 237, 255, 23, 255, 0, 255, 0, 255, 0, 255, 0, 255, 20, 255, 255, 255, 96, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 36, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 71, 255, 204, 255, 247, 255, 225, 255, 120, 255, 2, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 155, 255, 185, 255, 243, 255, 223, 255, 121, 255, 1, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 95, 255, 223, 255, 240, 255, 175, 255, 20, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 251, 255, 248, 255, 248, 255, 248, 255, 248, 255, 224, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 20, 255, 255, 255, 96, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 135, 255, 248, 255, 255, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 75, 255, 209, 255, 248, 255, 228, 255, 127, 255, 5, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255, 140, 255, 244, 255, 142, 255, 135, 255, 243, 255, 163, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 56, 255, 196, 255, 246, 255, 231, 255, 133, 255, 161, 255, 72, 255, 0, 255, 0, 255, 0, 255, 0, 255, 19, 255, 247, 255, 57, 255, 0, 255, 0, 255, 0, 255, 7, 255, 237, 255, 79, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 251, 255, 248, 255, 248, 255, 248, 255, 248, 255, 224, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 155, 255, 249, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 56, 255, 255, 255, 138, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 88, 255, 184, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 11, 255, 144, 255, 54, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 157, 255, 182, 255, 35, 255, 1, 255, 23, 255, 94, 255, 87, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 65, 255, 222, 255, 62, 255, 4, 255, 29, 255, 170, 255, 166, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 88, 255, 203, 255, 218, 255, 62, 255, 1, 255, 31, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 11, 255, 144, 255, 54, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 27, 255, 216, 255, 2, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 57, 255, 235, 255, 75, 255, 5, 255, 43, 255, 207, 255, 127, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 215, 255, 60, 255, 7, 255, 46, 255, 204, 255, 123, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 173, 255, 174, 255, 18, 255, 15, 255, 180, 255, 149, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 11, 255, 144, 255, 54, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 85, 255, 227, 255, 70, 255, 7, 255, 39, 255, 187, 255, 164, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255, 127, 255, 33, 255, 250, 255, 156, 255, 19, 255, 237, 255, 43, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 37, 255, 237, 255, 94, 255, 7, 255, 37, 255, 179, 255, 240, 255, 72, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 162, 255, 157, 255, 0, 255, 0, 255, 0, 255, 87, 255, 227, 255, 3, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 135, 255, 208, 255, 217, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 88, 255, 184, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 20, 255, 255, 255, 96, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 192, 255, 108, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 194, 255, 71, 255, 0, 255, 0, 255, 0, 255, 6, 255, 235, 255, 33, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 88, 255, 255, 255, 65, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 140, 255, 107, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 177, 255, 106, 255, 0, 255, 0, 255, 0, 255, 36, 255, 236, 255, 8, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 35, 255, 241, 255, 14, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 231, 255, 8, 255, 0, 255, 0, 255, 66, 255, 210, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 225, 255, 71, 255, 0, 255, 0, 255, 0, 255, 14, 255, 234, 255, 50, 255, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255, 39, 255, 0, 255, 229, 255, 71, 255, 0, 255, 201, 255, 69, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 149, 255, 134, 255, 0, 255, 0, 255, 0, 255, 9, 255, 228, 255, 72, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 57, 255, 243, 255, 12, 255, 0, 255, 0, 255, 185, 255, 127, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 214, 255, 76, 255, 242, 255, 40, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 88, 255, 184, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 48, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 72, 255, 242, 255, 202, 255, 154, 255, 109, 255, 42, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 243, 255, 248, 255, 248, 255, 248, 255, 248, 255, 248, 255, 251, 255, 73, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 88, 255, 222, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 16, 255, 221, 255, 9, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 13, 255, 248, 255, 20, 255, 0, 255, 0, 255, 0, 255, 0, 255, 197, 255, 81, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 219, 255, 61, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 150, 255, 0, 255, 0, 255, 0, 255, 44, 255, 231, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 137, 255, 252, 255, 255, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 28, 255, 251, 255, 4, 255, 0, 255, 0, 255, 0, 255, 0, 255, 174, 255, 108, 255, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255, 21, 255, 0, 255, 228, 255, 50, 255, 0, 255, 200, 255, 72, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 237, 255, 45, 255, 0, 255, 0, 255, 0, 255, 0, 255, 101, 255, 41, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 207, 255, 100, 255, 0, 255, 29, 255, 249, 255, 27, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 67, 255, 207, 255, 246, 255, 213, 255, 125, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 37, 255, 244, 255, 7, 255, 174, 255, 119, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 252, 255, 253, 255, 254, 255, 252, 255, 252, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 155, 255, 116, 255, 0, 255, 0, 255, 0, 255, 81, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 15, 255, 85, 255, 131, 255, 174, 255, 241, 255, 144, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 1, 255, 251, 255, 47, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 88, 255, 188, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 121, 255, 126, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 43, 255, 228, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 160, 255, 115, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 219, 255, 61, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 120, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 30, 255, 249, 255, 3, 255, 0, 255, 0, 255, 0, 255, 0, 255, 171, 255, 110, 255, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255, 20, 255, 0, 255, 228, 255, 48, 255, 0, 255, 200, 255, 72, 255, 0, 255, 0, 255, 0, 255, 0, 255, 15, 255, 253, 255, 2, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 102, 255, 199, 255, 0, 255, 124, 255, 175, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 63, 255, 233, 255, 75, 255, 8, 255, 37, 255, 172, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 117, 255, 177, 255, 0, 255, 100, 255, 198, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 88, 255, 184, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 135, 255, 137, 255, 0, 255, 0, 255, 0, 255, 170, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 1, 255, 0, 255, 0, 255, 0, 255, 0, 255, 31, 255, 255, 255, 13, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 194, 255, 129, 255, 0, 255, 0, 255, 0, 255, 0, 255, 35, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 88, 255, 184, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 7, 255, 221, 255, 19, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 62, 255, 212, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 138, 255, 136, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 34, 255, 243, 255, 15, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 251, 255, 248, 255, 248, 255, 248, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 251, 255, 248, 255, 248, 255, 248, 255, 249, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 1, 255, 231, 255, 66, 255, 0, 255, 0, 255, 0, 255, 11, 255, 232, 255, 56, 255, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255, 20, 255, 0, 255, 228, 255, 48, 255, 0, 255, 200, 255, 72, 255, 0, 255, 0, 255, 0, 255, 0, 255, 34, 255, 240, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 11, 255, 241, 255, 44, 255, 220, 255, 71, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 251, 255, 248, 255, 248, 255, 248, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 191, 255, 98, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 196, 255, 102, 255, 0, 255, 26, 255, 253, 255, 23, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 88, 255, 184, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 74, 255, 227, 255, 40, 255, 5, 255, 120, 255, 172, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 1, 255, 205, 255, 127, 255, 29, 255, 0, 255, 13, 255, 114, 255, 227, 255, 2, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 53, 255, 243, 255, 96, 255, 10, 255, 22, 255, 149, 255, 183, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 88, 255, 184, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 11, 255, 144, 255, 54, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 102, 255, 145, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 43, 255, 227, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 152, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 214, 255, 59, 255, 6, 255, 45, 255, 204, 255, 125, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 92, 255, 224, 255, 68, 255, 7, 255, 39, 255, 182, 255, 171, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255, 20, 255, 0, 255, 228, 255, 48, 255, 0, 255, 200, 255, 72, 255, 0, 255, 0, 255, 0, 255, 0, 255, 15, 255, 253, 255, 2, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 148, 255, 200, 255, 221, 255, 1, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 239, 255, 32, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 21, 255, 252, 255, 28, 255, 0, 255, 0, 255, 208, 255, 100, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 88, 255, 184, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 131, 255, 232, 255, 238, 255, 149, 255, 48, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 57, 255, 165, 255, 227, 255, 247, 255, 234, 255, 171, 255, 34, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 54, 255, 197, 255, 246, 255, 235, 255, 152, 255, 13, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 252, 255, 253, 255, 254, 255, 252, 255, 94, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 20, 255, 255, 255, 96, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 2, 255, 213, 255, 31, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 14, 255, 249, 255, 19, 255, 0, 255, 0, 255, 0, 255, 0, 255, 195, 255, 85, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 156, 255, 188, 255, 244, 255, 226, 255, 111, 255, 1, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 81, 255, 212, 255, 248, 255, 230, 255, 133, 255, 6, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255, 20, 255, 0, 255, 228, 255, 48, 255, 0, 255, 200, 255, 72, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 239, 255, 44, 255, 0, 255, 0, 255, 0, 255, 0, 255, 50, 255, 7, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 42, 255, 255, 255, 119, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 240, 255, 31, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 99, 255, 254, 255, 232, 255, 232, 255, 232, 255, 247, 255, 179, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 87, 255, 184, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 83, 255, 164, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 180, 255, 110, 255, 0, 255, 0, 255, 0, 255, 34, 255, 246, 255, 20, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 152, 255, 138, 255, 0, 255, 0, 255, 0, 255, 14, 255, 234, 255, 34, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 52, 255, 249, 255, 21, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 193, 255, 95, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 178, 255, 137, 255, 24, 255, 24, 255, 24, 255, 65, 255, 247, 255, 11, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 65, 255, 209, 255, 0, 255, 0, 255, 0, 255, 135, 255, 49, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 200, 255, 47, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 60, 255, 243, 255, 73, 255, 3, 255, 36, 255, 210, 255, 134, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 39, 255, 242, 255, 95, 255, 4, 255, 31, 255, 185, 255, 151, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 31, 255, 2, 255, 169, 255, 165, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 66, 255, 232, 255, 70, 255, 5, 255, 27, 255, 172, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 10, 255, 246, 255, 45, 255, 0, 255, 0, 255, 0, 255, 0, 255, 221, 255, 81, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 11, 255, 230, 255, 96, 255, 5, 255, 75, 255, 228, 255, 15, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 64, 255, 184, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 73, 255, 205, 255, 246, 255, 226, 255, 123, 255, 2, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 137, 255, 252, 255, 255, 255, 252, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 137, 255, 252, 255, 255, 255, 252, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 57, 255, 197, 255, 244, 255, 226, 255, 131, 255, 6, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 206, 255, 244, 255, 196, 255, 31, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 253, 255, 252, 255, 252, 255, 252, 255, 252, 255, 228, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 71, 255, 210, 255, 244, 255, 213, 255, 125, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 80, 255, 218, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 138, 255, 160, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 52, 255, 200, 255, 243, 255, 204, 255, 56, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 182, 255, 65, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 63, 255, 204, 255, 247, 255, 215, 255, 84, 255, 244, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 56, 255, 196, 255, 246, 255, 231, 255, 133, 255, 161, 255, 72, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 88, 255, 216, 255, 248, 255, 217, 255, 99, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 252, 255, 31, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 45, 255, 202, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 249, 255, 255, 255, 229, 255, 0, 255, 155, 255, 254, 255, 251, 255, 69, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 9, 255, 246, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 70, 255, 204, 255, 247, 255, 225, 255, 120, 255, 2, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 59, 255, 234, 255, 77, 255, 8, 255, 36, 255, 188, 255, 244, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 37, 255, 237, 255, 94, 255, 7, 255, 37, 255, 177, 255, 240, 255, 72, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 99, 255, 220, 255, 64, 255, 10, 255, 57, 255, 217, 255, 96, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 250, 255, 142, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 113, 255, 84, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 4, 255, 222, 255, 77, 255, 0, 255, 20, 255, 245, 255, 41, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 140, 255, 255, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 55, 255, 236, 255, 77, 255, 5, 255, 46, 255, 212, 255, 131, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 187, 255, 102, 255, 0, 255, 0, 255, 0, 255, 40, 255, 244, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 149, 255, 134, 255, 0, 255, 0, 255, 0, 255, 8, 255, 227, 255, 72, 255, 0, 255, 0, 255, 0, 255, 0, 255, 3, 255, 235, 255, 62, 255, 0, 255, 0, 255, 0, 255, 55, 255, 226, 255, 1, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 164, 255, 241, 255, 13, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 103, 255, 192, 255, 0, 255, 122, 255, 173, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 24, 255, 152, 255, 211, 255, 233, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 173, 255, 112, 255, 0, 255, 0, 255, 0, 255, 86, 255, 247, 255, 19, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 236, 255, 36, 255, 0, 255, 0, 255, 0, 255, 0, 255, 30, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 237, 255, 45, 255, 0, 255, 0, 255, 0, 255, 0, 255, 101, 255, 41, 255, 0, 255, 0, 255, 0, 255, 0, 255, 37, 255, 248, 255, 2, 255, 0, 255, 0, 255, 0, 255, 0, 255, 240, 255, 41, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 191, 255, 113, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 1, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255, 248, 255, 248, 255, 255, 255, 249, 255, 248, 255, 253, 255, 72, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 6, 255, 227, 255, 57, 255, 228, 255, 52, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 92, 255, 211, 255, 246, 255, 202, 255, 93, 255, 196, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 252, 255, 252, 255, 252, 255, 252, 255, 252, 255, 252, 255, 252, 255, 70, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 63, 255, 206, 255, 246, 255, 212, 255, 128, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255, 185, 255, 24, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 11, 255, 248, 255, 19, 255, 0, 255, 0, 255, 38, 255, 219, 255, 221, 255, 84, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 20, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 20, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 51, 255, 27, 255, 0, 255, 0, 255, 0, 255, 0, 255, 1, 255, 76, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 20, 255, 249, 255, 59, 255, 0, 255, 0, 255, 0, 255, 4, 255, 234, 255, 84, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 245, 255, 39, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 15, 255, 253, 255, 2, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 36, 255, 248, 255, 2, 255, 0, 255, 0, 255, 0, 255, 0, 255, 236, 255, 70, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 77, 255, 223, 255, 3, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 110, 255, 219, 255, 201, 255, 38, 255, 0, 255, 1, 255, 187, 255, 23, 255, 0, 255, 0, 255, 0, 255, 0, 255, 236, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 160, 255, 72, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 111, 255, 227, 255, 187, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 74, 255, 221, 255, 47, 255, 7, 255, 67, 255, 219, 255, 196, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 57, 255, 233, 255, 77, 255, 8, 255, 40, 255, 177, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 22, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 41, 255, 232, 255, 0, 255, 0, 255, 26, 255, 215, 255, 63, 255, 153, 255, 115, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 57, 255, 215, 255, 6, 255, 0, 255, 0, 255, 0, 255, 0, 255, 161, 255, 122, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 41, 255, 226, 255, 55, 255, 0, 255, 0, 255, 0, 255, 0, 255, 11, 255, 209, 255, 96, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 168, 255, 154, 255, 0, 255, 0, 255, 0, 255, 78, 255, 234, 255, 5, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 187, 255, 112, 255, 0, 255, 0, 255, 0, 255, 0, 255, 15, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 34, 255, 240, 255, 0, 255, 0, 255, 0, 255, 174, 255, 248, 255, 249, 255, 165, 255, 0, 255, 0, 255, 0, 255, 0, 255, 2, 255, 230, 255, 61, 255, 0, 255, 0, 255, 0, 255, 46, 255, 255, 255, 90, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 1, 255, 218, 255, 84, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 19, 255, 196, 255, 4, 255, 52, 255, 170, 255, 0, 255, 103, 255, 160, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 236, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 160, 255, 72, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 24, 255, 255, 255, 102, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 159, 255, 121, 255, 0, 255, 0, 255, 0, 255, 87, 255, 196, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 186, 255, 102, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 61, 255, 212, 255, 0, 255, 16, 255, 206, 255, 80, 255, 0, 255, 137, 255, 136, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 46, 255, 221, 255, 44, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 11, 255, 199, 255, 105, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 2, 255, 209, 255, 77, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 26, 255, 224, 255, 35, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 66, 255, 240, 255, 8, 255, 0, 255, 0, 255, 173, 255, 138, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 49, 255, 238, 255, 93, 255, 12, 255, 16, 255, 124, 255, 194, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 15, 255, 253, 255, 2, 255, 0, 255, 0, 255, 0, 255, 0, 255, 137, 255, 143, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 95, 255, 219, 255, 57, 255, 8, 255, 57, 255, 201, 255, 205, 255, 75, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 106, 255, 198, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 13, 255, 203, 255, 20, 255, 80, 255, 158, 255, 22, 255, 220, 255, 21, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 165, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 112, 255, 50, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 123, 255, 215, 255, 200, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 136, 255, 182, 255, 3, 255, 0, 255, 0, 255, 6, 255, 24, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 237, 255, 34, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 43, 255, 225, 255, 8, 255, 194, 255, 99, 255, 0, 255, 0, 255, 158, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 36, 255, 220, 255, 55, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 17, 255, 208, 255, 90, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 101, 255, 170, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 93, 255, 175, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 1, 255, 218, 255, 88, 255, 0, 255, 18, 255, 248, 255, 38, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 95, 255, 223, 255, 240, 255, 175, 255, 20, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 52, 255, 195, 255, 246, 255, 236, 255, 162, 255, 22, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 239, 255, 44, 255, 0, 255, 0, 255, 0, 255, 0, 255, 181, 255, 106, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 86, 255, 214, 255, 242, 255, 191, 255, 51, 255, 215, 255, 25, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 10, 255, 238, 255, 99, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 149, 255, 200, 255, 8, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 79, 255, 198, 255, 168, 255, 23, 255, 163, 255, 100, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 11, 255, 234, 255, 44, 255, 218, 255, 66, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 18, 255, 211, 255, 208, 255, 95, 255, 9, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 243, 255, 30, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 14, 255, 251, 255, 184, 255, 119, 255, 0, 255, 0, 255, 0, 255, 197, 255, 85, 255, 0, 255, 0, 255, 0, 255, 0, 255, 27, 255, 216, 255, 67, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 24, 255, 215, 255, 76, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 208, 255, 40, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 1, 255, 214, 255, 30, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 118, 255, 184, 255, 0, 255, 106, 255, 192, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 173, 255, 174, 255, 18, 255, 15, 255, 180, 255, 149, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 152, 255, 138, 255, 0, 255, 0, 255, 0, 255, 27, 255, 245, 255, 22, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 69, 255, 189, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 136, 255, 212, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 101, 255, 227, 255, 24, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 65, 255, 196, 255, 1, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 116, 255, 182, 255, 0, 255, 107, 255, 189, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 6, 255, 107, 255, 205, 255, 237, 255, 113, 255, 2, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 23, 255, 134, 255, 219, 255, 247, 255, 224, 255, 131, 255, 4, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 201, 255, 89, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 180, 255, 173, 255, 0, 255, 0, 255, 0, 255, 37, 255, 247, 255, 20, 255, 0, 255, 0, 255, 0, 255, 0, 255, 24, 255, 214, 255, 71, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 26, 255, 217, 255, 71, 255, 0, 255, 0, 255, 0, 255, 0, 255, 34, 255, 211, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 133, 255, 112, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 21, 255, 246, 255, 26, 255, 201, 255, 91, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 231, 255, 8, 255, 0, 255, 0, 255, 66, 255, 210, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 39, 255, 242, 255, 95, 255, 4, 255, 28, 255, 191, 255, 151, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 31, 255, 110, 255, 14, 255, 5, 255, 83, 255, 227, 255, 47, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 27, 255, 250, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 60, 255, 238, 255, 49, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 6, 255, 211, 255, 45, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 8, 255, 231, 255, 67, 255, 0, 255, 11, 255, 238, 255, 56, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 59, 255, 217, 255, 129, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 56, 255, 121, 255, 35, 255, 4, 255, 33, 255, 188, 255, 135, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 79, 255, 227, 255, 66, 255, 8, 255, 41, 255, 180, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 60, 255, 238, 255, 75, 255, 1, 255, 33, 255, 201, 255, 134, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 33, 255, 219, 255, 58, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 18, 255, 210, 255, 85, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 89, 255, 146, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 67, 255, 168, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 170, 255, 158, 255, 238, 255, 8, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 150, 255, 0, 255, 0, 255, 0, 255, 44, 255, 231, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 57, 255, 197, 255, 244, 255, 230, 255, 133, 255, 4, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 15, 255, 157, 255, 239, 255, 242, 255, 185, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 165, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 29, 255, 231, 255, 82, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 125, 255, 139, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 47, 255, 252, 255, 255, 255, 181, 255, 0, 255, 110, 255, 255, 255, 253, 255, 114, 255, 0, 255, 0, 255, 0, 255, 0, 255, 66, 255, 12, 255, 0, 255, 0, 255, 0, 255, 54, 255, 243, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 59, 255, 221, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 97, 255, 214, 255, 248, 255, 211, 255, 123, 255, 230, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 137, 255, 252, 255, 255, 255, 252, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 73, 255, 205, 255, 243, 255, 226, 255, 123, 255, 2, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 43, 255, 220, 255, 45, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 12, 255, 200, 255, 100, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 116, 255, 119, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 38, 255, 195, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 67, 255, 255, 255, 146, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 120, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 126, 255, 206, 255, 131, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 35, 255, 217, 255, 13, 255, 144, 255, 213, 255, 152, 255, 4, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 204, 255, 90, 255, 0, 255, 0, 255, 0, 255, 35, 255, 247, 255, 1, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 6, 255, 126, 255, 207, 255, 239, 255, 247, 255, 237, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 3, 255, 2, 255, 0, 255, 0, 255, 0, 255, 78, 255, 202, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 55, 255, 214, 255, 6, 255, 0, 255, 0, 255, 0, 255, 0, 255, 161, 255, 118, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 127, 255, 107, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 24, 255, 207, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 251, 255, 248, 255, 247, 255, 231, 255, 170, 255, 35, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 242, 255, 227, 255, 175, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 184, 255, 79, 255, 80, 255, 147, 255, 0, 255, 134, 255, 96, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 204, 255, 228, 255, 86, 255, 9, 255, 24, 255, 179, 255, 145, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 171, 255, 180, 255, 49, 255, 7, 255, 0, 255, 53, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 119, 255, 173, 255, 44, 255, 15, 255, 63, 255, 218, 255, 86, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 18, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 18, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 103, 255, 131, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 51, 255, 182, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 236, 255, 4, 255, 0, 255, 0, 255, 166, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 17, 255, 133, 255, 217, 255, 5, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 196, 255, 16, 255, 222, 255, 84, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 87, 255, 177, 255, 0, 255, 85, 255, 135, 255, 0, 255, 121, 255, 103, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 137, 255, 252, 255, 255, 255, 252, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 204, 255, 74, 255, 190, 255, 245, 255, 227, 255, 132, 255, 5, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 250, 255, 35, 255, 0, 255, 0, 255, 0, 255, 111, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 5, 255, 129, 255, 226, 255, 246, 255, 208, 255, 92, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 68, 255, 172, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 92, 255, 148, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 253, 255, 252, 255, 252, 255, 252, 255, 252, 255, 228, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 255, 255, 67, 255, 0, 255, 7, 255, 241, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 227, 255, 45, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 72, 255, 231, 255, 17, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 177, 255, 30, 255, 0, 255, 4, 255, 166, 255, 215, 255, 173, 255, 8, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 211, 255, 130, 255, 8, 255, 19, 255, 108, 255, 215, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 7, 255, 230, 255, 8, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 172, 255, 72, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 203, 255, 150, 255, 0, 255, 77, 255, 202, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 44, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 204, 255, 19, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 12, 255, 150, 255, 229, 255, 250, 255, 67, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255, 255, 255, 255, 255, 0, 255, 188, 255, 255, 255, 255, 255, 72, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 167, 255, 158, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 135, 255, 248, 255, 255, 255, 249, 255, 205, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 47, 255, 192, 255, 241, 255, 234, 255, 146, 255, 57, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 81, 255, 210, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 139, 255, 159, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 164, 255, 99, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 29, 255, 225, 255, 5, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 33, 255, 252, 255, 7, 255, 2, 255, 245, 255, 70, 255, 0, 255, 174, 255, 111, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 129, 255, 224, 255, 2, 255, 160, 255, 120, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 20, 255, 134, 255, 217, 255, 5, 255, 0, 255, 0, 255, 0, 255, 0, 255, 34, 255, 7, 255, 0, 255, 196, 255, 11, 255, 0, 255, 42, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 140, 255, 184, 255, 27, 255, 2, 255, 3, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 8, 255, 161, 255, 161, 255, 0, 255, 79, 255, 228, 255, 21, 255, 2, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 23, 255, 238, 255, 68, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 10, 255, 246, 255, 32, 255, 0, 255, 0, 255, 0, 255, 0, 255, 215, 255, 80, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 37, 255, 224, 255, 11, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 168, 255, 104, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 239, 255, 46, 255, 37, 255, 255, 255, 117, 255, 0, 255, 216, 255, 64, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 181, 255, 65, 255, 225, 255, 51, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 251, 255, 248, 255, 247, 255, 229, 255, 169, 255, 35, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 103, 255, 207, 255, 52, 255, 187, 255, 25, 255, 173, 255, 172, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 209, 255, 65, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 17, 255, 228, 255, 64, 255, 220, 255, 75, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 101, 255, 222, 255, 10, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 179, 255, 110, 255, 0, 255, 0, 255, 0, 255, 36, 255, 246, 255, 10, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 96, 255, 82, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 131, 255, 179, 255, 4, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 108, 255, 200, 255, 3, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 193, 255, 88, 255, 82, 255, 217, 255, 163, 255, 6, 255, 251, 255, 17, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 100, 255, 209, 255, 168, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 38, 255, 179, 255, 236, 255, 199, 255, 77, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 137, 255, 252, 255, 255, 255, 252, 255, 252, 255, 252, 255, 70, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 78, 255, 247, 255, 162, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 251, 255, 248, 255, 247, 255, 227, 255, 126, 255, 3, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 252, 255, 252, 255, 252, 255, 252, 255, 252, 255, 252, 255, 252, 255, 70, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 153, 255, 181, 255, 241, 255, 224, 255, 110, 255, 1, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 100, 255, 187, 255, 0, 255, 0, 255, 0, 255, 113, 255, 178, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 9, 255, 245, 255, 74, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 1, 255, 158, 255, 76, 255, 0, 255, 0, 255, 0, 255, 0, 255, 12, 255, 200, 255, 20, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 253, 255, 252, 255, 252, 255, 252, 255, 254, 255, 191, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 145, 255, 130, 255, 128, 255, 119, 255, 208, 255, 45, 255, 225, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 93, 255, 214, 255, 248, 255, 220, 255, 118, 255, 1, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 21, 255, 252, 255, 86, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 39, 255, 185, 255, 238, 255, 205, 255, 79, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 99, 255, 235, 255, 181, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 32, 255, 192, 255, 142, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 218, 255, 60, 255, 3, 255, 44, 255, 202, 255, 125, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 23, 255, 248, 255, 15, 255, 0, 255, 0, 255, 190, 255, 98, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 82, 255, 207, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 2, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 2, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 76, 255, 0, 255, 0, 255, 39, 255, 239, 255, 84, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 97, 255, 172, 255, 173, 255, 49, 255, 222, 255, 93, 255, 177, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 67, 255, 226, 255, 66, 255, 8, 255, 41, 255, 203, 255, 117, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 109, 255, 12, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 101, 255, 211, 255, 57, 255, 187, 255, 27, 255, 178, 255, 170, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 26, 255, 233, 255, 43, 255, 206, 255, 94, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 42, 255, 183, 255, 238, 255, 228, 255, 141, 255, 9, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 251, 255, 248, 255, 247, 255, 225, 255, 141, 255, 10, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 24, 255, 241, 255, 16, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 251, 255, 248, 255, 247, 255, 231, 255, 170, 255, 35, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 36, 255, 242, 255, 14, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 198, 255, 87, 255, 0, 255, 16, 255, 248, 255, 22, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 164, 255, 86, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 76, 255, 0, 255, 16, 255, 217, 255, 129, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 49, 255, 214, 255, 213, 255, 6, 255, 178, 255, 176, 255, 130, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 181, 255, 88, 255, 0, 255, 0, 255, 0, 255, 67, 255, 216, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 36, 255, 9, 255, 0, 255, 196, 255, 11, 255, 0, 255, 46, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 4, 255, 178, 255, 137, 255, 0, 255, 56, 255, 236, 255, 27, 255, 1, 255, 0, 255, 0, 255, 0, 255, 20, 255, 229, 255, 94, 255, 12, 255, 29, 255, 189, 255, 143, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 1, 255, 41, 255, 201, 255, 148, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 16, 255, 206, 255, 162, 255, 2, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 179, 255, 95, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 18, 255, 138, 255, 217, 255, 5, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 223, 255, 61, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 119, 255, 165, 255, 0, 255, 88, 255, 196, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 6, 255, 202, 255, 2, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 31, 255, 15, 255, 3, 255, 185, 255, 173, 255, 1, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 6, 255, 245, 255, 205, 255, 0, 255, 128, 255, 248, 255, 82, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 199, 255, 31, 255, 0, 255, 0, 255, 0, 255, 69, 255, 217, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 204, 255, 19, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 40, 255, 255, 255, 255, 255, 208, 255, 0, 255, 140, 255, 255, 255, 255, 255, 116, 255, 0, 255, 0, 255, 0, 255, 115, 255, 148, 255, 0, 255, 0, 255, 0, 255, 47, 255, 228, 255, 0, 255, 47, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 69, 255, 222, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 13, 255, 200, 255, 163, 255, 2, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 141, 255, 130, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 238, 255, 45, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 223, 255, 61, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 40, 255, 238, 255, 4, 255, 165, 255, 117, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 144, 255, 209, 255, 11, 255, 0, 255, 44, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 208, 255, 160, 255, 0, 255, 77, 255, 255, 255, 35, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 1, 255, 184, 255, 134, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 232, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 101, 255, 69, 255, 0, 255, 0, 255, 0, 255, 50, 255, 237, 255, 0, 255, 78, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 57, 255, 219, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 10, 255, 194, 255, 164, 255, 2, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 122, 255, 152, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 238, 255, 42, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 78, 255, 201, 255, 244, 255, 220, 255, 125, 255, 4, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 36, 255, 244, 255, 15, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 217, 255, 67, 255, 238, 255, 37, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 155, 255, 116, 255, 0, 255, 0, 255, 0, 255, 44, 255, 231, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 97, 255, 234, 255, 31, 255, 0, 255, 0, 255, 236, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 133, 255, 208, 255, 10, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 5, 255, 53, 255, 201, 255, 122, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 34, 255, 194, 255, 123, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 123, 255, 187, 255, 190, 255, 3, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 141, 255, 133, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 20, 255, 139, 255, 204, 255, 2, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 63, 255, 232, 255, 67, 255, 6, 255, 38, 255, 194, 255, 136, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 214, 255, 59, 255, 6, 255, 45, 255, 204, 255, 128, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 138, 255, 203, 255, 214, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 140, 255, 126, 255, 0, 255, 0, 255, 0, 255, 55, 255, 214, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 107, 255, 183, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 117, 255, 178, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 58, 255, 243, 255, 61, 255, 0, 255, 0, 255, 0, 255, 236, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 114, 255, 224, 255, 28, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 137, 255, 252, 255, 255, 255, 252, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 219, 255, 255, 255, 169, 255, 9, 255, 0, 255, 7, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 247, 255, 240, 255, 244, 255, 255, 255, 196, 255, 11, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 243, 255, 184, 255, 237, 255, 60, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 137, 255, 252, 255, 255, 255, 252, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 178, 255, 101, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 251, 255, 248, 255, 252, 255, 231, 255, 157, 255, 23, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 159, 255, 123, 255, 0, 255, 0, 255, 0, 255, 48, 255, 238, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 160, 255, 189, 255, 244, 255, 227, 255, 114, 255, 1, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 59, 255, 255, 255, 135, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 105, 255, 179, 255, 0, 255, 0, 255, 0, 255, 107, 255, 177, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 64, 255, 224, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 157, 255, 135, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 159, 255, 255, 255, 252, 255, 252, 255, 252, 255, 252, 255, 239, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 97, 255, 232, 255, 37, 255, 0, 255, 22, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 3, 255, 29, 255, 149, 255, 180, 255, 0, 255, 175, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 21, 255, 137, 255, 196, 255, 1, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 180, 255, 4, 255, 84, 255, 236, 255, 38, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 24, 255, 244, 255, 21, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 166, 255, 166, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 118, 255, 0, 255, 0, 255, 0, 255, 42, 255, 234, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 18, 255, 241, 255, 93, 255, 2, 255, 46, 255, 232, 255, 75, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 22, 255, 254, 255, 11, 255, 0, 255, 0, 255, 0, 255, 0, 255, 198, 255, 92, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 81, 255, 236, 255, 48, 255, 0, 255, 0, 255, 236, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 251, 255, 248, 255, 248, 255, 248, 255, 248, 255, 189, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 250, 255, 248, 255, 248, 255, 248, 255, 248, 255, 254, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 43, 255, 21, 255, 0, 255, 0, 255, 0, 255, 5, 255, 248, 255, 27, 255, 230, 255, 57, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 228, 255, 48, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 127, 255, 221, 255, 22, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 35, 255, 193, 255, 150, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 27, 255, 243, 255, 66, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 56, 255, 224, 255, 59, 255, 5, 255, 32, 255, 184, 255, 127, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 54, 255, 207, 255, 247, 255, 226, 255, 99, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 235, 255, 50, 255, 2, 255, 247, 255, 61, 255, 0, 255, 238, 255, 49, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 67, 255, 239, 255, 60, 255, 0, 255, 0, 255, 0, 255, 236, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 76, 255, 0, 255, 0, 255, 0, 255, 67, 255, 196, 255, 5, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 155, 255, 119, 255, 0, 255, 0, 255, 0, 255, 9, 255, 249, 255, 29, 255, 169, 255, 113, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 229, 255, 45, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 1, 255, 169, 255, 201, 255, 10, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 253, 255, 252, 255, 251, 255, 229, 255, 132, 255, 5, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 119, 255, 214, 255, 5, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 128, 255, 254, 255, 254, 255, 255, 255, 189, 255, 11, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 193, 255, 91, 255, 38, 255, 255, 255, 105, 255, 24, 255, 253, 255, 9, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 176, 255, 254, 255, 252, 255, 252, 255, 252, 255, 252, 255, 239, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 76, 255, 0, 255, 0, 255, 13, 255, 219, 255, 33, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 52, 255, 235, 255, 81, 255, 7, 255, 21, 255, 167, 255, 176, 255, 0, 255, 168, 255, 113, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 25, 255, 144, 255, 216, 255, 4, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 6, 255, 217, 255, 119, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 124, 255, 190, 255, 46, 255, 4, 255, 24, 255, 138, 255, 194, 255, 2, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 150, 255, 132, 255, 82, 255, 245, 255, 149, 255, 65, 255, 219, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 140, 255, 173, 255, 246, 255, 230, 255, 125, 255, 3, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 21, 255, 10, 255, 0, 255, 0, 255, 122, 255, 135, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 63, 255, 192, 255, 239, 255, 228, 255, 144, 255, 13, 255, 0, 255, 228, 255, 58, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 253, 255, 252, 255, 251, 255, 230, 255, 167, 255, 34, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 116, 255, 0, 255, 0, 255, 0, 255, 72, 255, 244, 255, 29, 255, 0, 255, 0, 255, 0, 255, 0, 255, 2, 255, 243, 255, 31, 255, 0, 255, 0, 255, 0, 255, 0, 255, 209, 255, 66, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 108, 255, 172, 255, 126, 255, 161, 255, 193, 255, 105, 255, 176, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 156, 255, 232, 255, 75, 255, 6, 255, 48, 255, 204, 255, 142, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 1, 255, 220, 255, 26, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 31, 255, 232, 255, 94, 255, 11, 255, 30, 255, 173, 255, 177, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 5, 255, 252, 255, 34, 255, 0, 255, 0, 255, 0, 255, 0, 255, 213, 255, 75, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 65, 255, 213, 255, 170, 255, 70, 255, 229, 255, 146, 255, 133, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 21, 255, 18, 255, 0, 255, 0, 255, 0, 255, 32, 255, 245, 255, 25, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 64, 255, 199, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 52, 255, 194, 255, 245, 255, 234, 255, 138, 255, 8, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 158, 255, 194, 255, 46, 255, 2, 255, 23, 255, 142, 255, 219, 255, 11, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 23, 255, 250, 255, 217, 255, 17, 255, 205, 255, 212, 255, 90, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 209, 255, 73, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 119, 255, 152, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 7, 255, 129, 255, 219, 255, 246, 255, 230, 255, 164, 255, 33, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 236, 255, 221, 255, 0, 255, 157, 255, 255, 255, 47, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 144, 255, 28, 255, 0, 255, 0, 255, 0, 255, 0, 255, 208, 255, 72, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 167, 255, 109, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 193, 255, 172, 255, 0, 255, 108, 255, 253, 255, 8, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 187, 255, 108, 255, 0, 255, 0, 255, 0, 255, 31, 255, 241, 255, 19, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 201, 255, 80, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 67, 255, 238, 255, 77, 255, 7, 255, 45, 255, 202, 255, 124, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 214, 255, 66, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 76, 255, 203, 255, 245, 255, 224, 255, 107, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 226, 255, 59, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0), +"format": "LumAlpha8", +"height": 256, +"mipmaps": false, +"width": 256 +} + +[sub_resource type="Image" id="Image_f4u7m"] +data = { +"data": PackedByteArray(255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 255, 255, 255, 255, 255, 255, 254, 255, 232, 255, 162, 255, 31, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 92, 255, 255, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255, 255, 255, 255, 255, 104, 255, 61, 255, 193, 255, 227, 255, 236, 255, 201, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 21, 255, 144, 255, 224, 255, 250, 255, 231, 255, 159, 255, 32, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 18, 255, 139, 255, 221, 255, 249, 255, 222, 255, 121, 255, 134, 255, 176, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 240, 255, 104, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 27, 255, 150, 255, 225, 255, 250, 255, 231, 255, 162, 255, 41, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 84, 255, 187, 255, 233, 255, 251, 255, 238, 255, 190, 255, 89, 255, 4, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 113, 255, 219, 255, 245, 255, 206, 255, 82, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 160, 255, 0, 255, 0, 255, 0, 255, 0, 255, 48, 255, 255, 255, 255, 255, 255, 255, 56, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 92, 255, 255, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 255, 255, 156, 255, 0, 255, 0, 255, 0, 255, 0, 255, 184, 255, 160, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 3, 255, 80, 255, 178, 255, 232, 255, 250, 255, 226, 255, 160, 255, 37, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255, 139, 255, 209, 255, 241, 255, 126, 255, 119, 255, 230, 255, 225, 255, 82, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 212, 255, 24, 255, 24, 255, 25, 255, 57, 255, 176, 255, 237, 255, 40, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 70, 255, 196, 255, 88, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 28, 255, 28, 255, 241, 255, 150, 255, 223, 255, 63, 255, 0, 255, 0, 255, 24, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 24, 255, 224, 255, 215, 255, 83, 255, 35, 255, 65, 255, 186, 255, 235, 255, 36, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 19, 255, 219, 255, 209, 255, 70, 255, 31, 255, 68, 255, 192, 255, 233, 255, 176, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 240, 255, 104, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 39, 255, 235, 255, 198, 255, 65, 255, 29, 255, 57, 255, 177, 255, 246, 255, 64, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 104, 255, 247, 255, 127, 255, 52, 255, 30, 255, 54, 255, 101, 255, 204, 255, 33, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 100, 255, 253, 255, 118, 255, 55, 255, 133, 255, 253, 255, 58, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 212, 255, 24, 255, 24, 255, 24, 255, 24, 255, 24, 255, 24, 255, 15, 255, 0, 255, 0, 255, 0, 255, 0, 255, 4, 255, 24, 255, 53, 255, 255, 255, 56, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 70, 255, 196, 255, 88, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 254, 255, 251, 255, 35, 255, 0, 255, 0, 255, 0, 255, 184, 255, 160, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 41, 255, 174, 255, 98, 255, 56, 255, 31, 255, 55, 255, 150, 255, 232, 255, 31, 255, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255, 206, 255, 8, 255, 93, 255, 254, 255, 188, 255, 4, 255, 121, 255, 235, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 2, 255, 184, 255, 193, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 240, 255, 248, 255, 42, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 158, 255, 230, 255, 21, 255, 0, 255, 0, 255, 0, 255, 4, 255, 200, 255, 176, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 147, 255, 226, 255, 11, 255, 0, 255, 0, 255, 0, 255, 8, 255, 217, 255, 176, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 240, 255, 104, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 190, 255, 200, 255, 3, 255, 0, 255, 0, 255, 0, 255, 0, 255, 168, 255, 222, 255, 3, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 183, 255, 168, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 182, 255, 176, 255, 0, 255, 0, 255, 0, 255, 227, 255, 130, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 32, 255, 255, 255, 56, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 211, 255, 215, 255, 161, 255, 0, 255, 0, 255, 0, 255, 184, 255, 160, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 199, 255, 132, 255, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255, 119, 255, 0, 255, 35, 255, 255, 255, 92, 255, 0, 255, 63, 255, 255, 255, 20, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 53, 255, 255, 255, 38, 255, 0, 255, 0, 255, 0, 255, 0, 255, 48, 255, 255, 255, 255, 255, 255, 255, 56, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 240, 255, 171, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 238, 255, 133, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 97, 255, 250, 255, 8, 255, 0, 255, 0, 255, 0, 255, 0, 255, 227, 255, 127, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 108, 255, 126, 255, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 72, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 21, 255, 254, 255, 83, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 47, 255, 255, 255, 55, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 115, 255, 248, 255, 145, 255, 80, 255, 45, 255, 8, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 185, 255, 170, 255, 0, 255, 0, 255, 46, 255, 253, 255, 93, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 32, 255, 255, 255, 56, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 89, 255, 252, 255, 38, 255, 0, 255, 0, 255, 184, 255, 160, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 54, 255, 147, 255, 207, 255, 232, 255, 243, 255, 229, 255, 243, 255, 159, 255, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255, 92, 255, 0, 255, 32, 255, 255, 255, 63, 255, 0, 255, 60, 255, 255, 255, 28, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 1, 255, 242, 255, 96, 255, 0, 255, 0, 255, 0, 255, 0, 255, 5, 255, 28, 255, 56, 255, 255, 255, 56, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 240, 255, 122, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 6, 255, 255, 255, 248, 255, 244, 255, 244, 255, 244, 255, 244, 255, 244, 255, 246, 255, 255, 255, 41, 255, 0, 255, 0, 255, 0, 255, 0, 255, 250, 255, 98, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 28, 255, 28, 255, 241, 255, 120, 255, 28, 255, 28, 255, 28, 255, 7, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 46, 255, 255, 255, 47, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 11, 255, 255, 255, 81, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 86, 255, 183, 255, 240, 255, 255, 255, 252, 255, 204, 255, 113, 255, 2, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 97, 255, 241, 255, 28, 255, 103, 255, 237, 255, 156, 255, 1, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 32, 255, 255, 255, 56, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 2, 255, 212, 255, 165, 255, 0, 255, 0, 255, 184, 255, 160, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 101, 255, 253, 255, 160, 255, 76, 255, 45, 255, 36, 255, 48, 255, 202, 255, 160, 255, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255, 88, 255, 0, 255, 32, 255, 255, 255, 56, 255, 0, 255, 60, 255, 255, 255, 28, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 216, 255, 123, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 32, 255, 255, 255, 56, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 240, 255, 104, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 235, 255, 139, 255, 36, 255, 36, 255, 36, 255, 36, 255, 36, 255, 36, 255, 36, 255, 7, 255, 0, 255, 0, 255, 0, 255, 0, 255, 225, 255, 133, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 240, 255, 104, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 22, 255, 255, 255, 80, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 44, 255, 255, 255, 57, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 24, 255, 64, 255, 125, 255, 239, 255, 151, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 1, 255, 199, 255, 249, 255, 218, 255, 78, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 253, 255, 244, 255, 244, 255, 244, 255, 244, 255, 205, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 32, 255, 255, 255, 56, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 0, 255, 85, 255, 253, 255, 41, 255, 0, 255, 184, 255, 160, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 231, 255, 131, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 201, 255, 160, 255, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255, 88, 255, 0, 255, 32, 255, 255, 255, 56, 255, 0, 255, 60, 255, 255, 255, 28, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 215, 255, 124, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 32, 255, 255, 255, 56, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 240, 255, 104, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 148, 255, 214, 255, 11, 255, 0, 255, 0, 255, 0, 255, 0, 255, 35, 255, 13, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 139, 255, 234, 255, 20, 255, 0, 255, 0, 255, 0, 255, 0, 255, 42, 255, 23, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 240, 255, 104, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 195, 255, 195, 255, 1, 255, 0, 255, 0, 255, 0, 255, 0, 255, 161, 255, 226, 255, 4, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 35, 255, 1, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 146, 255, 210, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 92, 255, 253, 255, 216, 255, 212, 255, 32, 255, 0, 255, 0, 255, 6, 255, 108, 255, 21, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 214, 255, 36, 255, 36, 255, 36, 255, 36, 255, 30, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 32, 255, 255, 255, 56, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 0, 255, 1, 255, 209, 255, 169, 255, 0, 255, 184, 255, 160, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 243, 255, 102, 255, 0, 255, 0, 255, 0, 255, 0, 255, 87, 255, 255, 255, 160, 255, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255, 88, 255, 0, 255, 32, 255, 255, 255, 56, 255, 0, 255, 60, 255, 255, 255, 28, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 241, 255, 100, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 32, 255, 255, 255, 56, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 28, 255, 28, 255, 241, 255, 120, 255, 28, 255, 12, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 16, 255, 208, 255, 206, 255, 82, 255, 38, 255, 47, 255, 119, 255, 238, 255, 95, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 13, 255, 203, 255, 225, 255, 91, 255, 35, 255, 45, 255, 116, 255, 239, 255, 107, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 240, 255, 104, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 42, 255, 234, 255, 194, 255, 76, 255, 39, 255, 69, 255, 174, 255, 247, 255, 67, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 2, 255, 222, 255, 210, 255, 110, 255, 51, 255, 32, 255, 46, 255, 105, 255, 238, 255, 128, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 11, 255, 239, 255, 149, 255, 6, 255, 163, 255, 233, 255, 57, 255, 0, 255, 82, 255, 250, 255, 21, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 32, 255, 255, 255, 56, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 69, 255, 192, 255, 87, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 0, 255, 0, 255, 81, 255, 254, 255, 44, 255, 184, 255, 160, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 168, 255, 230, 255, 84, 255, 35, 255, 53, 255, 149, 255, 218, 255, 209, 255, 160, 255, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255, 88, 255, 0, 255, 32, 255, 255, 255, 56, 255, 0, 255, 60, 255, 255, 255, 28, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 51, 255, 255, 255, 45, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 32, 255, 255, 255, 56, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 6, 255, 121, 255, 217, 255, 249, 255, 239, 255, 188, 255, 69, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 4, 255, 116, 255, 215, 255, 249, 255, 239, 255, 188, 255, 74, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 235, 255, 108, 255, 0, 255, 0, 255, 0, 255, 0, 255, 38, 255, 1, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 18, 255, 148, 255, 227, 255, 251, 255, 233, 255, 166, 255, 43, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 22, 255, 120, 255, 193, 255, 237, 255, 251, 255, 235, 255, 187, 255, 90, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 52, 255, 255, 255, 61, 255, 0, 255, 0, 255, 132, 255, 247, 255, 97, 255, 217, 255, 154, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 32, 255, 255, 255, 56, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 92, 255, 255, 255, 116, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 0, 255, 0, 255, 1, 255, 206, 255, 173, 255, 184, 255, 160, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 15, 255, 143, 255, 222, 255, 248, 255, 224, 255, 140, 255, 17, 255, 184, 255, 160, 255, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255, 88, 255, 0, 255, 32, 255, 255, 255, 56, 255, 0, 255, 60, 255, 255, 255, 28, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 1, 255, 181, 255, 202, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 32, 255, 255, 255, 56, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 196, 255, 160, 255, 0, 255, 0, 255, 0, 255, 42, 255, 251, 255, 16, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 35, 255, 255, 255, 101, 255, 0, 255, 0, 255, 0, 255, 108, 255, 255, 255, 243, 255, 16, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 32, 255, 255, 255, 56, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 0, 255, 0, 255, 0, 255, 77, 255, 254, 255, 226, 255, 160, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 213, 255, 28, 255, 28, 255, 29, 255, 60, 255, 176, 255, 241, 255, 46, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 5, 255, 28, 255, 56, 255, 255, 255, 77, 255, 28, 255, 7, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 81, 255, 252, 255, 114, 255, 40, 255, 73, 255, 216, 255, 154, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 159, 255, 240, 255, 114, 255, 75, 255, 116, 255, 223, 255, 212, 255, 243, 255, 172, 255, 10, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 5, 255, 28, 255, 56, 255, 255, 255, 77, 255, 28, 255, 7, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 202, 255, 255, 255, 160, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 255, 255, 255, 255, 255, 255, 254, 255, 233, 255, 166, 255, 36, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 48, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 72, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 82, 255, 204, 255, 244, 255, 222, 255, 129, 255, 6, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 6, 255, 121, 255, 216, 255, 248, 255, 216, 255, 117, 255, 4, 255, 55, 255, 196, 255, 19, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 48, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 72, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 132, 255, 208, 255, 0, 255, 0, 255, 0, 255, 0, 255, 73, 255, 255, 255, 160, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0), +"format": "LumAlpha8", +"height": 256, +"mipmaps": false, +"width": 256 +} + +[sub_resource type="FontFile" id="FontFile_f0lek"] +data = PackedByteArray(0, 1, 0, 0, 0, 16, 1, 0, 0, 4, 0, 0, 79, 83, 47, 50, 74, 98, 190, 132, 0, 1, 82, 64, 0, 0, 0, 96, 86, 68, 77, 88, 106, 165, 114, 60, 0, 1, 82, 160, 0, 0, 5, 224, 99, 109, 97, 112, 146, 18, 23, 146, 0, 1, 98, 88, 0, 0, 3, 226, 99, 118, 116, 32, 4, 138, 10, 158, 0, 1, 104, 76, 0, 0, 0, 46, 102, 112, 103, 109, 146, 65, 218, 250, 0, 1, 102, 60, 0, 0, 1, 97, 103, 97, 115, 112, 0, 21, 0, 8, 0, 1, 181, 184, 0, 0, 0, 16, 103, 108, 121, 102, 188, 115, 236, 191, 0, 0, 1, 12, 0, 1, 70, 240, 104, 100, 109, 120, 121, 100, 77, 180, 0, 1, 88, 128, 0, 0, 9, 216, 104, 101, 97, 100, 255, 43, 154, 196, 0, 1, 77, 0, 0, 0, 0, 54, 104, 104, 101, 97, 10, 103, 2, 206, 0, 1, 82, 28, 0, 0, 0, 36, 104, 109, 116, 120, 52, 106, 53, 208, 0, 1, 77, 56, 0, 0, 4, 226, 108, 111, 99, 97, 177, 5, 98, 167, 0, 1, 72, 28, 0, 0, 4, 226, 109, 97, 120, 112, 4, 136, 3, 97, 0, 1, 71, 252, 0, 0, 0, 32, 110, 97, 109, 101, 4, 103, 92, 104, 0, 1, 104, 124, 0, 0, 59, 106, 112, 111, 115, 116, 230, 170, 54, 215, 0, 1, 163, 232, 0, 0, 17, 206, 112, 114, 101, 112, 48, 247, 212, 104, 0, 1, 103, 160, 0, 0, 0, 171, 0, 2, 0, 49, 0, 0, 3, 115, 5, 25, 0, 3, 0, 7, 0, 69, 176, 8, 47, 176, 9, 47, 176, 0, 220, 176, 8, 16, 176, 1, 208, 176, 1, 47, 177, 4, 12, 244, 176, 0, 16, 177, 5, 8, 244, 0, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 177, 4, 6, 244, 176, 2, 16, 177, 6, 6, 244, 48, 49, 33, 33, 17, 33, 1, 33, 17, 33, 3, 115, 252, 190, 3, 66, 253, 71, 2, 47, 253, 209, 5, 25, 251, 92, 4, 47, 0, 0, 2, 0, 0, 0, 1, 3, 164, 3, 165, 0, 27, 0, 31, 0, 189, 176, 32, 47, 176, 33, 47, 176, 2, 220, 177, 3, 13, 244, 176, 32, 16, 176, 7, 208, 176, 7, 47, 177, 6, 13, 244, 176, 7, 16, 176, 11, 208, 176, 7, 16, 176, 15, 208, 176, 6, 16, 176, 17, 208, 176, 3, 16, 176, 19, 208, 176, 2, 16, 176, 21, 208, 176, 2, 16, 176, 25, 208, 176, 3, 16, 176, 28, 208, 176, 6, 16, 176, 30, 208, 0, 176, 0, 69, 88, 176, 16, 47, 27, 177, 16, 19, 62, 89, 176, 0, 69, 88, 176, 20, 47, 27, 177, 20, 19, 62, 89, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 15, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 179, 27, 1, 0, 4, 43, 179, 15, 1, 12, 4, 43, 176, 0, 16, 176, 4, 208, 176, 0, 16, 176, 8, 208, 176, 27, 16, 176, 10, 208, 176, 15, 16, 176, 18, 208, 176, 15, 16, 176, 22, 208, 176, 12, 16, 176, 24, 208, 176, 27, 16, 176, 28, 208, 176, 12, 16, 176, 29, 208, 48, 49, 37, 35, 21, 35, 53, 33, 21, 35, 53, 35, 53, 51, 17, 35, 53, 51, 53, 51, 21, 33, 53, 51, 21, 51, 21, 35, 17, 51, 33, 17, 33, 17, 3, 164, 221, 117, 255, 0, 117, 221, 221, 221, 221, 117, 1, 0, 117, 221, 221, 221, 254, 174, 255, 0, 222, 221, 221, 221, 221, 110, 1, 8, 109, 228, 228, 228, 228, 109, 254, 248, 1, 8, 254, 248, 0, 0, 3, 0, 0, 255, 70, 3, 131, 5, 211, 0, 43, 0, 50, 0, 59, 0, 175, 179, 51, 8, 15, 4, 43, 179, 36, 8, 44, 4, 43, 179, 41, 8, 0, 4, 43, 176, 0, 16, 176, 9, 208, 176, 0, 16, 176, 20, 208, 176, 41, 16, 176, 22, 208, 176, 36, 16, 176, 28, 208, 176, 28, 47, 180, 218, 44, 234, 44, 2, 93, 64, 27, 9, 44, 25, 44, 41, 44, 57, 44, 73, 44, 89, 44, 105, 44, 121, 44, 137, 44, 153, 44, 169, 44, 185, 44, 201, 44, 13, 93, 176, 44, 16, 176, 29, 208, 176, 29, 47, 176, 41, 16, 176, 32, 208, 176, 41, 16, 176, 47, 208, 64, 27, 6, 51, 22, 51, 38, 51, 54, 51, 70, 51, 86, 51, 102, 51, 118, 51, 134, 51, 150, 51, 166, 51, 182, 51, 198, 51, 13, 93, 180, 213, 51, 229, 51, 2, 93, 176, 0, 16, 176, 54, 208, 176, 36, 16, 176, 61, 220, 0, 176, 21, 47, 176, 42, 47, 178, 47, 42, 21, 17, 18, 57, 178, 54, 42, 21, 17, 18, 57, 48, 49, 5, 46, 3, 39, 55, 22, 22, 23, 17, 46, 3, 53, 52, 62, 2, 55, 53, 51, 21, 30, 3, 23, 7, 38, 38, 39, 17, 22, 22, 21, 20, 14, 2, 7, 21, 35, 1, 52, 38, 39, 17, 54, 54, 1, 20, 22, 23, 17, 14, 3, 1, 141, 84, 137, 100, 64, 12, 129, 23, 129, 116, 84, 131, 92, 47, 49, 90, 131, 84, 138, 75, 127, 92, 56, 6, 143, 13, 104, 96, 182, 182, 49, 94, 135, 86, 138, 1, 97, 109, 106, 116, 97, 253, 204, 115, 98, 55, 82, 51, 25, 16, 10, 63, 95, 122, 68, 33, 101, 149, 21, 2, 15, 31, 65, 84, 109, 73, 64, 112, 91, 57, 10, 164, 164, 10, 68, 98, 119, 61, 25, 88, 146, 20, 254, 41, 67, 175, 147, 68, 120, 95, 65, 8, 170, 2, 2, 86, 121, 47, 254, 34, 17, 125, 2, 237, 77, 103, 39, 1, 170, 8, 43, 57, 66, 0, 0, 5, 255, 236, 255, 229, 3, 193, 5, 55, 0, 19, 0, 23, 0, 43, 0, 55, 0, 67, 1, 69, 179, 50, 10, 10, 4, 43, 179, 0, 9, 44, 4, 43, 179, 24, 9, 56, 4, 43, 64, 27, 6, 0, 22, 0, 38, 0, 54, 0, 70, 0, 86, 0, 102, 0, 118, 0, 134, 0, 150, 0, 166, 0, 182, 0, 198, 0, 13, 93, 180, 213, 0, 229, 0, 2, 93, 178, 34, 44, 0, 17, 18, 57, 176, 34, 47, 180, 218, 34, 234, 34, 2, 93, 64, 27, 9, 34, 25, 34, 41, 34, 57, 34, 73, 34, 89, 34, 105, 34, 121, 34, 137, 34, 153, 34, 169, 34, 185, 34, 201, 34, 13, 93, 64, 15, 102, 50, 118, 50, 134, 50, 150, 50, 166, 50, 182, 50, 198, 50, 7, 93, 64, 13, 6, 50, 22, 50, 38, 50, 54, 50, 70, 50, 86, 50, 6, 93, 180, 213, 50, 229, 50, 2, 93, 180, 218, 56, 234, 56, 2, 93, 64, 27, 9, 56, 25, 56, 41, 56, 57, 56, 73, 56, 89, 56, 105, 56, 121, 56, 137, 56, 153, 56, 169, 56, 185, 56, 201, 56, 13, 93, 177, 62, 9, 244, 176, 24, 16, 176, 69, 220, 0, 176, 15, 47, 176, 23, 47, 176, 0, 69, 88, 176, 21, 47, 27, 177, 21, 15, 62, 89, 176, 0, 69, 88, 176, 29, 47, 27, 177, 29, 15, 62, 89, 179, 39, 2, 59, 4, 43, 179, 53, 1, 5, 4, 43, 176, 15, 16, 177, 47, 1, 244, 180, 217, 47, 233, 47, 2, 93, 64, 27, 8, 47, 24, 47, 40, 47, 56, 47, 72, 47, 88, 47, 104, 47, 120, 47, 136, 47, 152, 47, 168, 47, 184, 47, 200, 47, 13, 93, 176, 29, 16, 177, 65, 1, 244, 64, 27, 7, 65, 23, 65, 39, 65, 55, 65, 71, 65, 87, 65, 103, 65, 119, 65, 135, 65, 151, 65, 167, 65, 183, 65, 199, 65, 13, 93, 180, 214, 65, 230, 65, 2, 93, 48, 49, 1, 20, 14, 2, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 30, 2, 37, 1, 39, 1, 19, 20, 14, 2, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 30, 2, 1, 52, 38, 35, 34, 6, 21, 20, 22, 51, 50, 54, 1, 52, 38, 35, 34, 6, 21, 20, 22, 51, 50, 54, 1, 225, 39, 69, 92, 52, 51, 92, 68, 38, 38, 68, 92, 51, 52, 92, 69, 39, 1, 195, 252, 188, 94, 3, 70, 121, 41, 68, 94, 51, 52, 92, 67, 41, 41, 67, 92, 52, 51, 92, 70, 41, 253, 186, 86, 64, 63, 86, 86, 63, 64, 86, 1, 223, 88, 63, 64, 86, 86, 64, 63, 88, 4, 49, 51, 92, 68, 41, 41, 68, 92, 51, 51, 95, 67, 41, 41, 67, 95, 148, 250, 237, 60, 5, 22, 251, 174, 53, 90, 70, 39, 39, 68, 92, 53, 52, 92, 67, 39, 39, 67, 92, 3, 24, 64, 88, 88, 64, 63, 88, 88, 252, 243, 64, 86, 86, 64, 63, 88, 88, 0, 0, 3, 255, 231, 255, 229, 3, 188, 5, 47, 0, 39, 0, 50, 0, 66, 0, 227, 179, 48, 8, 14, 4, 43, 179, 30, 8, 59, 4, 43, 64, 27, 6, 48, 22, 48, 38, 48, 54, 48, 70, 48, 86, 48, 102, 48, 118, 48, 134, 48, 150, 48, 166, 48, 182, 48, 198, 48, 13, 93, 180, 213, 48, 229, 48, 2, 93, 178, 22, 14, 48, 17, 18, 57, 176, 22, 47, 177, 51, 8, 244, 180, 218, 59, 234, 59, 2, 93, 64, 27, 9, 59, 25, 59, 41, 59, 57, 59, 73, 59, 89, 59, 105, 59, 121, 59, 137, 59, 153, 59, 169, 59, 185, 59, 201, 59, 13, 93, 0, 176, 0, 69, 88, 176, 25, 47, 27, 177, 25, 21, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 15, 62, 89, 177, 40, 7, 244, 64, 27, 7, 40, 23, 40, 39, 40, 55, 40, 71, 40, 87, 40, 103, 40, 119, 40, 135, 40, 151, 40, 167, 40, 183, 40, 199, 40, 13, 93, 180, 214, 40, 230, 40, 2, 93, 176, 25, 16, 177, 62, 4, 244, 180, 217, 62, 233, 62, 2, 93, 64, 27, 8, 62, 24, 62, 40, 62, 56, 62, 72, 62, 88, 62, 104, 62, 120, 62, 136, 62, 152, 62, 168, 62, 184, 62, 200, 62, 13, 93, 48, 49, 1, 6, 6, 7, 23, 7, 39, 6, 6, 35, 34, 46, 2, 53, 52, 62, 2, 55, 38, 38, 53, 52, 54, 51, 50, 30, 2, 21, 20, 14, 2, 7, 1, 54, 54, 55, 1, 50, 54, 55, 1, 39, 6, 6, 21, 20, 22, 3, 20, 22, 23, 62, 3, 53, 52, 38, 35, 34, 14, 2, 3, 188, 18, 80, 59, 157, 94, 157, 74, 180, 105, 76, 135, 100, 60, 27, 47, 64, 37, 62, 68, 179, 149, 68, 119, 88, 49, 62, 94, 119, 57, 1, 104, 48, 61, 16, 254, 33, 78, 135, 53, 254, 168, 30, 52, 63, 125, 86, 35, 57, 51, 101, 77, 47, 104, 78, 43, 69, 50, 24, 2, 53, 86, 174, 78, 147, 107, 154, 66, 84, 56, 96, 129, 76, 63, 105, 84, 67, 29, 78, 153, 78, 154, 182, 41, 76, 108, 70, 78, 110, 84, 68, 37, 254, 174, 66, 145, 70, 254, 23, 59, 49, 1, 80, 29, 45, 117, 86, 96, 129, 3, 114, 47, 119, 75, 30, 58, 65, 80, 53, 78, 90, 35, 59, 78, 0, 1, 1, 117, 3, 68, 2, 47, 5, 25, 0, 3, 0, 19, 0, 176, 1, 47, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 21, 62, 89, 48, 49, 1, 3, 35, 3, 2, 47, 43, 102, 41, 5, 25, 254, 43, 1, 213, 0, 1, 0, 188, 254, 141, 2, 193, 5, 223, 0, 21, 0, 62, 179, 16, 13, 5, 4, 43, 64, 27, 6, 16, 22, 16, 38, 16, 54, 16, 70, 16, 86, 16, 102, 16, 118, 16, 134, 16, 150, 16, 166, 16, 182, 16, 198, 16, 13, 93, 180, 213, 16, 229, 16, 2, 93, 0, 176, 10, 47, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 17, 62, 89, 48, 49, 1, 46, 2, 2, 53, 52, 18, 54, 54, 55, 23, 14, 3, 21, 20, 30, 2, 23, 2, 121, 107, 166, 112, 60, 60, 112, 166, 107, 72, 95, 149, 103, 53, 53, 103, 147, 97, 254, 141, 84, 213, 242, 1, 8, 135, 135, 1, 7, 241, 213, 84, 90, 76, 192, 219, 238, 121, 123, 237, 217, 195, 76, 0, 1, 0, 229, 254, 141, 2, 236, 5, 223, 0, 21, 0, 62, 179, 0, 13, 11, 4, 43, 180, 218, 11, 234, 11, 2, 93, 64, 27, 9, 11, 25, 11, 41, 11, 57, 11, 73, 11, 89, 11, 105, 11, 121, 11, 137, 11, 153, 11, 169, 11, 185, 11, 201, 11, 13, 93, 0, 176, 17, 47, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 17, 62, 89, 48, 49, 1, 20, 2, 6, 6, 7, 39, 62, 3, 53, 52, 46, 2, 39, 55, 30, 2, 18, 2, 236, 60, 115, 165, 107, 72, 95, 149, 105, 53, 53, 105, 149, 95, 72, 107, 165, 115, 60, 2, 53, 135, 254, 250, 242, 213, 84, 90, 76, 193, 219, 237, 121, 121, 240, 219, 192, 76, 90, 84, 213, 241, 254, 247, 0, 0, 1, 0, 35, 0, 1, 3, 129, 3, 165, 0, 17, 0, 71, 0, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 19, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 178, 1, 5, 14, 17, 18, 57, 178, 4, 5, 14, 17, 18, 57, 178, 7, 5, 14, 17, 18, 57, 178, 10, 5, 14, 17, 18, 57, 178, 13, 5, 14, 17, 18, 57, 178, 16, 5, 14, 17, 18, 57, 48, 49, 1, 5, 5, 7, 37, 19, 35, 19, 5, 39, 37, 37, 55, 5, 3, 51, 3, 37, 3, 129, 254, 170, 1, 86, 55, 254, 180, 14, 116, 14, 254, 180, 55, 1, 86, 254, 170, 55, 1, 76, 14, 116, 14, 1, 76, 2, 140, 184, 189, 94, 203, 254, 125, 1, 131, 203, 94, 189, 184, 96, 205, 1, 134, 254, 122, 205, 0, 0, 1, 0, 0, 0, 13, 3, 164, 3, 176, 0, 11, 0, 55, 179, 2, 13, 3, 4, 43, 176, 3, 16, 176, 7, 208, 176, 2, 16, 176, 9, 208, 0, 176, 2, 47, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 19, 62, 89, 179, 11, 6, 0, 4, 43, 176, 0, 16, 176, 4, 208, 176, 11, 16, 176, 6, 208, 48, 49, 1, 33, 17, 35, 17, 33, 53, 33, 17, 51, 17, 33, 3, 164, 254, 104, 116, 254, 104, 1, 152, 116, 1, 152, 1, 164, 254, 105, 1, 151, 117, 1, 151, 254, 105, 0, 1, 0, 240, 254, 139, 2, 98, 0, 186, 0, 3, 0, 19, 0, 176, 0, 47, 176, 0, 69, 88, 176, 1, 47, 27, 177, 1, 17, 62, 89, 48, 49, 37, 1, 35, 19, 2, 98, 254, 238, 96, 186, 186, 253, 209, 2, 47, 0, 1, 0, 0, 1, 164, 3, 164, 2, 25, 0, 3, 0, 9, 0, 179, 3, 6, 0, 4, 43, 48, 49, 1, 33, 53, 33, 3, 164, 252, 92, 3, 164, 1, 164, 117, 0, 1, 1, 117, 0, 0, 2, 47, 0, 186, 0, 3, 0, 19, 0, 176, 2, 47, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 48, 49, 33, 35, 53, 51, 2, 47, 186, 186, 186, 0, 1, 0, 41, 255, 16, 3, 137, 5, 74, 0, 3, 0, 9, 0, 176, 1, 47, 176, 3, 47, 48, 49, 1, 1, 39, 1, 3, 137, 253, 2, 98, 2, 254, 5, 23, 249, 249, 52, 6, 6, 0, 0, 3, 255, 223, 255, 233, 3, 199, 5, 47, 0, 8, 0, 17, 0, 37, 0, 248, 176, 38, 47, 176, 39, 47, 176, 38, 16, 176, 18, 208, 176, 18, 47, 177, 0, 12, 244, 64, 27, 6, 0, 22, 0, 38, 0, 54, 0, 70, 0, 86, 0, 102, 0, 118, 0, 134, 0, 150, 0, 166, 0, 182, 0, 198, 0, 13, 93, 180, 213, 0, 229, 0, 2, 93, 176, 39, 16, 176, 28, 220, 178, 2, 18, 28, 17, 18, 57, 177, 14, 8, 244, 180, 218, 14, 234, 14, 2, 93, 64, 27, 9, 14, 25, 14, 41, 14, 57, 14, 73, 14, 89, 14, 105, 14, 121, 14, 137, 14, 153, 14, 169, 14, 185, 14, 201, 14, 13, 93, 178, 17, 18, 28, 17, 18, 57, 0, 176, 0, 69, 88, 176, 23, 47, 27, 177, 23, 21, 62, 89, 176, 0, 69, 88, 176, 33, 47, 27, 177, 33, 15, 62, 89, 178, 2, 33, 23, 17, 18, 57, 176, 23, 16, 177, 6, 6, 244, 180, 217, 6, 233, 6, 2, 93, 64, 27, 8, 6, 24, 6, 40, 6, 56, 6, 72, 6, 88, 6, 104, 6, 120, 6, 136, 6, 152, 6, 168, 6, 184, 6, 200, 6, 13, 93, 176, 33, 16, 177, 11, 6, 244, 64, 27, 7, 11, 23, 11, 39, 11, 55, 11, 71, 11, 87, 11, 103, 11, 119, 11, 135, 11, 151, 11, 167, 11, 183, 11, 199, 11, 13, 93, 180, 214, 11, 230, 11, 2, 93, 178, 17, 33, 23, 17, 18, 57, 48, 49, 19, 20, 23, 1, 38, 38, 35, 34, 2, 19, 22, 51, 50, 18, 17, 52, 38, 39, 1, 52, 62, 2, 51, 50, 30, 2, 21, 20, 14, 2, 35, 34, 46, 2, 104, 35, 2, 99, 48, 141, 94, 176, 187, 82, 99, 182, 172, 190, 18, 16, 252, 196, 56, 118, 191, 135, 135, 191, 120, 54, 54, 118, 191, 137, 137, 191, 119, 53, 2, 139, 145, 127, 2, 133, 90, 96, 254, 213, 253, 125, 176, 1, 43, 1, 4, 72, 129, 59, 254, 252, 131, 244, 188, 113, 113, 188, 244, 131, 131, 244, 186, 113, 113, 186, 244, 0, 0, 1, 0, 0, 0, 0, 2, 233, 5, 25, 0, 18, 0, 58, 179, 17, 8, 3, 4, 43, 176, 3, 16, 176, 15, 208, 0, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 177, 2, 6, 244, 178, 4, 0, 15, 17, 18, 57, 176, 17, 208, 176, 18, 208, 48, 49, 33, 33, 53, 51, 17, 14, 3, 35, 53, 50, 62, 2, 53, 51, 17, 51, 2, 233, 253, 209, 211, 18, 78, 106, 127, 68, 61, 140, 118, 78, 138, 210, 117, 3, 123, 41, 93, 77, 52, 142, 76, 118, 150, 74, 251, 92, 0, 1, 0, 10, 0, 0, 3, 119, 5, 47, 0, 32, 0, 114, 176, 5, 47, 179, 24, 11, 25, 4, 43, 179, 9, 8, 18, 4, 43, 176, 9, 16, 176, 0, 208, 176, 0, 47, 176, 9, 16, 177, 7, 13, 244, 176, 9, 16, 176, 34, 220, 0, 176, 0, 69, 88, 176, 28, 47, 27, 177, 28, 21, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 15, 62, 89, 177, 6, 6, 244, 176, 28, 16, 177, 21, 6, 244, 180, 217, 21, 233, 21, 2, 93, 64, 27, 8, 21, 24, 21, 40, 21, 56, 21, 72, 21, 88, 21, 104, 21, 120, 21, 136, 21, 152, 21, 168, 21, 184, 21, 200, 21, 13, 93, 48, 49, 1, 20, 14, 2, 7, 1, 33, 17, 51, 17, 33, 53, 1, 62, 3, 53, 52, 38, 35, 34, 6, 21, 35, 52, 54, 51, 50, 30, 2, 3, 115, 19, 49, 80, 61, 254, 57, 2, 39, 117, 252, 176, 1, 252, 39, 71, 56, 32, 159, 117, 164, 168, 127, 236, 223, 84, 149, 115, 66, 3, 199, 54, 86, 88, 98, 63, 254, 51, 1, 0, 254, 139, 121, 2, 4, 39, 78, 80, 86, 47, 120, 123, 182, 172, 221, 250, 49, 92, 133, 0, 0, 1, 0, 27, 255, 233, 3, 152, 5, 47, 0, 54, 0, 212, 179, 36, 11, 37, 4, 43, 179, 47, 12, 30, 4, 43, 176, 47, 16, 177, 19, 9, 244, 177, 0, 8, 244, 176, 36, 16, 176, 11, 208, 176, 11, 47, 180, 218, 30, 234, 30, 2, 93, 64, 27, 9, 30, 25, 30, 41, 30, 57, 30, 73, 30, 89, 30, 105, 30, 121, 30, 137, 30, 153, 30, 169, 30, 185, 30, 201, 30, 13, 93, 178, 50, 37, 0, 17, 18, 57, 176, 47, 16, 176, 56, 220, 0, 176, 0, 69, 88, 176, 42, 47, 27, 177, 42, 21, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 179, 25, 6, 24, 4, 43, 176, 5, 16, 177, 14, 6, 244, 64, 27, 7, 14, 23, 14, 39, 14, 55, 14, 71, 14, 87, 14, 103, 14, 119, 14, 135, 14, 151, 14, 167, 14, 183, 14, 199, 14, 13, 93, 180, 214, 14, 230, 14, 2, 93, 176, 42, 16, 177, 33, 6, 244, 180, 217, 33, 233, 33, 2, 93, 64, 27, 8, 33, 24, 33, 40, 33, 56, 33, 72, 33, 88, 33, 104, 33, 120, 33, 136, 33, 152, 33, 168, 33, 184, 33, 200, 33, 13, 93, 178, 50, 24, 25, 17, 18, 57, 48, 49, 1, 20, 14, 2, 35, 34, 46, 2, 39, 55, 22, 22, 51, 50, 62, 2, 53, 52, 46, 2, 35, 53, 50, 62, 2, 53, 52, 38, 35, 34, 6, 21, 35, 52, 62, 2, 51, 50, 30, 2, 21, 20, 6, 7, 30, 3, 3, 152, 70, 117, 153, 84, 95, 163, 125, 78, 8, 133, 12, 186, 138, 59, 104, 78, 45, 51, 96, 141, 93, 68, 127, 100, 62, 146, 116, 146, 176, 129, 66, 118, 166, 101, 84, 145, 109, 61, 133, 123, 70, 104, 70, 37, 1, 104, 86, 141, 100, 56, 52, 100, 152, 98, 18, 151, 152, 39, 72, 96, 59, 80, 101, 57, 20, 117, 23, 53, 88, 68, 110, 133, 153, 164, 102, 162, 111, 59, 49, 92, 133, 86, 111, 147, 19, 10, 59, 91, 110, 0, 0, 2, 0, 0, 0, 0, 3, 164, 5, 25, 0, 14, 0, 17, 0, 81, 179, 13, 12, 3, 4, 43, 176, 13, 16, 176, 8, 208, 176, 3, 16, 176, 15, 208, 0, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 179, 15, 3, 4, 4, 43, 176, 0, 16, 177, 2, 6, 244, 176, 15, 16, 176, 9, 208, 176, 4, 16, 176, 11, 208, 176, 2, 16, 176, 13, 208, 176, 14, 208, 48, 49, 33, 33, 53, 51, 17, 33, 53, 1, 51, 17, 51, 21, 35, 17, 51, 1, 17, 1, 3, 164, 253, 209, 211, 253, 184, 2, 35, 174, 211, 211, 211, 254, 164, 254, 73, 117, 1, 0, 119, 3, 45, 252, 211, 119, 255, 0, 1, 119, 2, 139, 253, 117, 0, 0, 1, 0, 4, 255, 233, 3, 170, 5, 25, 0, 42, 0, 166, 176, 43, 47, 176, 44, 47, 176, 0, 220, 177, 21, 12, 244, 180, 218, 21, 234, 21, 2, 93, 64, 27, 9, 21, 25, 21, 41, 21, 57, 21, 73, 21, 89, 21, 105, 21, 121, 21, 137, 21, 153, 21, 169, 21, 185, 21, 201, 21, 13, 93, 176, 43, 16, 176, 30, 208, 176, 30, 47, 177, 29, 12, 244, 176, 34, 208, 178, 35, 30, 0, 17, 18, 57, 0, 176, 0, 69, 88, 176, 31, 47, 27, 177, 31, 21, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 179, 38, 6, 26, 4, 43, 176, 5, 16, 177, 16, 6, 244, 64, 27, 7, 16, 23, 16, 39, 16, 55, 16, 71, 16, 87, 16, 103, 16, 119, 16, 135, 16, 151, 16, 167, 16, 183, 16, 199, 16, 13, 93, 180, 214, 16, 230, 16, 2, 93, 176, 31, 16, 177, 33, 6, 244, 178, 35, 5, 31, 17, 18, 57, 48, 49, 1, 20, 14, 2, 35, 34, 46, 2, 39, 55, 30, 3, 51, 50, 62, 2, 53, 52, 46, 2, 35, 34, 6, 7, 35, 17, 33, 21, 33, 17, 54, 54, 51, 50, 30, 2, 3, 170, 72, 125, 176, 104, 94, 160, 121, 74, 8, 133, 6, 52, 84, 114, 68, 80, 125, 88, 47, 47, 86, 125, 76, 80, 147, 54, 137, 3, 49, 253, 88, 60, 153, 80, 101, 168, 122, 68, 1, 182, 96, 168, 125, 72, 56, 104, 152, 98, 21, 68, 117, 82, 47, 53, 95, 125, 71, 74, 127, 92, 53, 67, 64, 2, 140, 117, 254, 104, 58, 63, 65, 119, 172, 0, 0, 2, 255, 248, 255, 233, 3, 190, 5, 47, 0, 34, 0, 54, 0, 223, 179, 25, 11, 10, 4, 43, 179, 0, 12, 35, 4, 43, 64, 27, 6, 25, 22, 25, 38, 25, 54, 25, 70, 25, 86, 25, 102, 25, 118, 25, 134, 25, 150, 25, 166, 25, 182, 25, 198, 25, 13, 93, 180, 213, 25, 229, 25, 2, 93, 180, 218, 35, 234, 35, 2, 93, 64, 27, 9, 35, 25, 35, 41, 35, 57, 35, 73, 35, 89, 35, 105, 35, 121, 35, 137, 35, 153, 35, 169, 35, 185, 35, 201, 35, 13, 93, 176, 10, 16, 177, 45, 8, 244, 0, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 21, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 179, 30, 6, 40, 4, 43, 176, 15, 16, 177, 20, 6, 244, 180, 217, 20, 233, 20, 2, 93, 64, 27, 8, 20, 24, 20, 40, 20, 56, 20, 72, 20, 88, 20, 104, 20, 120, 20, 136, 20, 152, 20, 168, 20, 184, 20, 200, 20, 13, 93, 178, 25, 5, 15, 17, 18, 57, 176, 5, 16, 177, 50, 6, 244, 64, 27, 7, 50, 23, 50, 39, 50, 55, 50, 71, 50, 87, 50, 103, 50, 119, 50, 135, 50, 151, 50, 167, 50, 183, 50, 199, 50, 13, 93, 180, 214, 50, 230, 50, 2, 93, 48, 49, 1, 20, 14, 2, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 23, 7, 38, 35, 34, 14, 2, 21, 62, 3, 51, 50, 30, 2, 7, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 62, 2, 3, 190, 71, 127, 174, 101, 139, 188, 115, 51, 69, 138, 207, 139, 194, 129, 90, 90, 143, 105, 161, 107, 53, 14, 78, 102, 119, 60, 102, 172, 123, 69, 137, 45, 84, 123, 77, 76, 127, 90, 49, 40, 84, 125, 86, 74, 123, 90, 49, 1, 188, 108, 172, 121, 66, 113, 186, 244, 131, 133, 244, 189, 110, 135, 80, 98, 80, 143, 201, 120, 51, 90, 65, 39, 69, 123, 172, 103, 74, 129, 94, 54, 50, 90, 123, 75, 74, 131, 100, 58, 49, 90, 132, 0, 1, 0, 49, 0, 0, 3, 152, 5, 25, 0, 16, 0, 75, 176, 17, 47, 176, 18, 47, 176, 5, 220, 177, 6, 8, 244, 176, 17, 16, 176, 14, 208, 176, 14, 47, 177, 13, 13, 244, 0, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 19, 62, 89, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 21, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 176, 15, 16, 177, 11, 6, 244, 48, 49, 1, 6, 10, 2, 7, 35, 54, 26, 2, 55, 33, 17, 35, 17, 33, 3, 152, 123, 148, 80, 28, 2, 144, 2, 35, 88, 152, 116, 253, 146, 117, 3, 103, 4, 160, 133, 254, 254, 254, 231, 254, 193, 193, 182, 1, 66, 1, 37, 1, 10, 125, 255, 0, 1, 117, 0, 3, 255, 248, 255, 233, 3, 174, 5, 47, 0, 39, 0, 51, 0, 71, 1, 49, 179, 62, 12, 10, 4, 43, 179, 30, 12, 40, 4, 43, 180, 218, 40, 234, 40, 2, 93, 64, 27, 9, 40, 25, 40, 41, 40, 57, 40, 73, 40, 89, 40, 105, 40, 121, 40, 137, 40, 153, 40, 169, 40, 185, 40, 201, 40, 13, 93, 178, 52, 40, 30, 17, 18, 57, 176, 52, 47, 180, 218, 52, 234, 52, 2, 93, 64, 27, 9, 52, 25, 52, 41, 52, 57, 52, 73, 52, 89, 52, 105, 52, 121, 52, 137, 52, 153, 52, 169, 52, 185, 52, 201, 52, 13, 93, 177, 0, 12, 244, 178, 15, 10, 0, 17, 18, 57, 64, 27, 6, 62, 22, 62, 38, 62, 54, 62, 70, 62, 86, 62, 102, 62, 118, 62, 134, 62, 150, 62, 166, 62, 182, 62, 198, 62, 13, 93, 180, 213, 62, 229, 62, 2, 93, 178, 20, 10, 62, 17, 18, 57, 176, 20, 47, 178, 35, 10, 0, 17, 18, 57, 177, 46, 12, 244, 0, 176, 0, 69, 88, 176, 25, 47, 27, 177, 25, 21, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 179, 49, 6, 57, 4, 43, 178, 15, 57, 49, 17, 18, 57, 178, 35, 57, 49, 17, 18, 57, 176, 25, 16, 177, 43, 6, 244, 180, 217, 43, 233, 43, 2, 93, 64, 23, 40, 43, 56, 43, 72, 43, 88, 43, 104, 43, 120, 43, 136, 43, 152, 43, 168, 43, 184, 43, 200, 43, 11, 93, 180, 8, 43, 24, 43, 2, 93, 176, 5, 16, 177, 67, 6, 244, 64, 27, 7, 67, 23, 67, 39, 67, 55, 67, 71, 67, 87, 67, 103, 67, 119, 67, 135, 67, 151, 67, 167, 67, 183, 67, 199, 67, 13, 93, 180, 214, 67, 230, 67, 2, 93, 48, 49, 1, 20, 14, 2, 35, 34, 46, 2, 53, 52, 62, 2, 55, 46, 3, 53, 52, 62, 2, 51, 50, 30, 2, 21, 20, 14, 2, 7, 30, 3, 3, 52, 38, 35, 34, 6, 21, 20, 22, 51, 50, 54, 19, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 62, 2, 3, 174, 74, 129, 174, 98, 100, 172, 129, 74, 39, 73, 105, 63, 55, 86, 59, 33, 70, 118, 156, 84, 84, 156, 118, 70, 33, 59, 88, 56, 64, 104, 74, 41, 184, 156, 135, 135, 156, 148, 143, 143, 148, 47, 55, 95, 120, 68, 68, 120, 95, 55, 55, 95, 120, 68, 68, 120, 95, 55, 1, 111, 103, 145, 96, 46, 46, 96, 145, 103, 53, 108, 93, 61, 8, 6, 60, 80, 94, 43, 88, 133, 88, 45, 45, 88, 133, 88, 43, 94, 80, 60, 6, 8, 61, 93, 108, 2, 41, 110, 127, 127, 110, 103, 122, 122, 254, 9, 71, 101, 63, 29, 29, 63, 101, 71, 70, 102, 68, 33, 33, 68, 102, 0, 2, 255, 233, 255, 233, 3, 176, 5, 47, 0, 35, 0, 55, 0, 229, 179, 36, 8, 0, 4, 43, 179, 10, 8, 46, 4, 43, 176, 10, 16, 177, 26, 11, 244, 64, 27, 6, 36, 22, 36, 38, 36, 54, 36, 70, 36, 86, 36, 102, 36, 118, 36, 134, 36, 150, 36, 166, 36, 182, 36, 198, 36, 13, 93, 180, 213, 36, 229, 36, 2, 93, 180, 218, 46, 234, 46, 2, 93, 64, 27, 9, 46, 25, 46, 41, 46, 57, 46, 73, 46, 89, 46, 105, 46, 121, 46, 137, 46, 153, 46, 169, 46, 185, 46, 201, 46, 13, 93, 176, 10, 16, 176, 57, 220, 0, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 21, 62, 89, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 15, 62, 89, 179, 41, 6, 31, 4, 43, 176, 15, 16, 177, 21, 6, 244, 64, 27, 7, 21, 23, 21, 39, 21, 55, 21, 71, 21, 87, 21, 103, 21, 119, 21, 135, 21, 151, 21, 167, 21, 183, 21, 199, 21, 13, 93, 180, 214, 21, 230, 21, 2, 93, 178, 26, 15, 5, 17, 18, 57, 176, 5, 16, 177, 51, 6, 244, 180, 217, 51, 233, 51, 2, 93, 64, 27, 8, 51, 24, 51, 40, 51, 56, 51, 72, 51, 88, 51, 104, 51, 120, 51, 136, 51, 152, 51, 168, 51, 184, 51, 200, 51, 13, 93, 48, 49, 3, 52, 62, 2, 51, 50, 30, 2, 21, 20, 14, 2, 35, 34, 39, 55, 22, 22, 51, 50, 62, 2, 53, 14, 3, 35, 34, 46, 2, 55, 20, 30, 2, 51, 50, 62, 2, 53, 52, 46, 2, 35, 34, 14, 2, 23, 72, 127, 174, 101, 137, 190, 115, 51, 70, 137, 209, 137, 194, 129, 90, 45, 119, 69, 105, 159, 109, 53, 16, 76, 102, 121, 58, 102, 172, 123, 70, 138, 45, 84, 123, 77, 76, 127, 90, 49, 41, 83, 125, 86, 74, 123, 90, 49, 3, 92, 109, 172, 121, 65, 113, 188, 242, 131, 133, 244, 188, 111, 136, 80, 50, 49, 80, 143, 201, 121, 51, 90, 66, 39, 70, 123, 172, 102, 74, 129, 94, 53, 49, 88, 125, 76, 74, 131, 100, 57, 49, 90, 131, 0, 2, 1, 117, 0, 0, 2, 47, 3, 164, 0, 3, 0, 7, 0, 47, 179, 0, 8, 1, 4, 43, 176, 0, 16, 176, 4, 208, 176, 1, 16, 176, 5, 208, 0, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 19, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 48, 49, 1, 35, 53, 51, 17, 35, 53, 51, 2, 47, 186, 186, 186, 186, 2, 233, 187, 252, 92, 186, 0, 0, 2, 0, 240, 254, 139, 2, 98, 3, 164, 0, 3, 0, 7, 0, 42, 179, 0, 8, 1, 4, 43, 0, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 19, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 17, 62, 89, 178, 4, 5, 2, 17, 18, 57, 48, 49, 1, 35, 53, 51, 19, 1, 35, 19, 2, 47, 186, 186, 51, 254, 238, 96, 186, 2, 233, 187, 253, 22, 253, 209, 2, 47, 0, 1, 0, 199, 255, 222, 3, 20, 3, 222, 0, 5, 0, 9, 0, 176, 1, 47, 176, 3, 47, 48, 49, 37, 7, 1, 1, 23, 1, 3, 20, 77, 254, 0, 2, 0, 77, 254, 80, 45, 79, 2, 0, 2, 0, 80, 254, 80, 0, 2, 0, 0, 0, 199, 3, 164, 2, 246, 0, 3, 0, 7, 0, 15, 0, 179, 7, 6, 4, 4, 43, 179, 3, 3, 0, 4, 43, 48, 49, 1, 33, 53, 33, 17, 33, 53, 33, 3, 164, 252, 92, 3, 164, 252, 92, 3, 164, 2, 127, 119, 253, 209, 117, 0, 0, 1, 0, 143, 255, 222, 2, 221, 3, 222, 0, 5, 0, 9, 0, 176, 1, 47, 176, 5, 47, 48, 49, 1, 1, 39, 1, 1, 55, 2, 221, 254, 0, 78, 1, 176, 254, 80, 78, 1, 222, 254, 0, 79, 1, 177, 1, 176, 80, 0, 0, 2, 0, 168, 0, 0, 3, 141, 5, 47, 0, 3, 0, 33, 0, 144, 179, 11, 8, 12, 4, 43, 179, 4, 8, 19, 4, 43, 176, 12, 16, 176, 1, 208, 176, 1, 47, 176, 12, 16, 177, 3, 8, 244, 180, 218, 19, 234, 19, 2, 93, 64, 27, 9, 19, 25, 19, 41, 19, 57, 19, 73, 19, 89, 19, 105, 19, 121, 19, 137, 19, 153, 19, 169, 19, 185, 19, 201, 19, 13, 93, 176, 4, 16, 176, 35, 220, 0, 176, 0, 69, 88, 176, 31, 47, 27, 177, 31, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 31, 16, 177, 22, 6, 244, 180, 217, 22, 233, 22, 2, 93, 64, 27, 8, 22, 24, 22, 40, 22, 56, 22, 72, 22, 88, 22, 104, 22, 120, 22, 136, 22, 152, 22, 168, 22, 184, 22, 200, 22, 13, 93, 48, 49, 33, 35, 53, 51, 1, 20, 14, 4, 21, 35, 52, 62, 4, 53, 52, 38, 35, 34, 14, 2, 7, 39, 54, 54, 51, 50, 22, 2, 47, 186, 186, 1, 94, 57, 86, 102, 86, 58, 145, 59, 86, 105, 86, 59, 108, 103, 63, 95, 65, 39, 6, 123, 18, 195, 176, 166, 186, 186, 3, 68, 78, 117, 98, 86, 92, 109, 69, 78, 122, 107, 94, 92, 99, 57, 88, 100, 41, 69, 96, 58, 19, 168, 194, 170, 0, 2, 255, 223, 255, 233, 3, 199, 5, 47, 0, 79, 0, 96, 1, 64, 179, 50, 9, 68, 4, 43, 179, 88, 12, 19, 4, 43, 179, 30, 12, 11, 4, 43, 179, 0, 9, 38, 4, 43, 176, 11, 16, 176, 27, 208, 182, 169, 38, 185, 38, 201, 38, 3, 93, 180, 218, 38, 234, 38, 2, 93, 64, 13, 73, 38, 89, 38, 105, 38, 121, 38, 137, 38, 153, 38, 6, 93, 64, 9, 9, 38, 25, 38, 41, 38, 57, 38, 4, 93, 64, 17, 86, 50, 102, 50, 118, 50, 134, 50, 150, 50, 166, 50, 182, 50, 198, 50, 8, 93, 64, 11, 6, 50, 22, 50, 38, 50, 54, 50, 70, 50, 5, 93, 180, 213, 50, 229, 50, 2, 93, 176, 11, 16, 176, 80, 208, 64, 17, 6, 88, 22, 88, 38, 88, 54, 88, 70, 88, 86, 88, 102, 88, 118, 88, 8, 93, 64, 11, 134, 88, 150, 88, 166, 88, 182, 88, 198, 88, 5, 93, 180, 213, 88, 229, 88, 2, 93, 0, 176, 0, 69, 88, 176, 75, 47, 27, 177, 75, 21, 62, 89, 176, 0, 69, 88, 176, 61, 47, 27, 177, 61, 15, 62, 89, 179, 91, 3, 14, 4, 43, 179, 24, 1, 83, 4, 43, 176, 14, 16, 176, 5, 208, 178, 11, 61, 75, 17, 18, 57, 178, 27, 83, 24, 17, 18, 57, 176, 91, 16, 176, 33, 208, 176, 33, 47, 176, 75, 16, 177, 45, 2, 244, 180, 217, 45, 233, 45, 2, 93, 64, 27, 8, 45, 24, 45, 40, 45, 56, 45, 72, 45, 88, 45, 104, 45, 120, 45, 136, 45, 152, 45, 168, 45, 184, 45, 200, 45, 13, 93, 176, 61, 16, 177, 55, 2, 244, 64, 27, 7, 55, 23, 55, 39, 55, 55, 55, 71, 55, 87, 55, 103, 55, 119, 55, 135, 55, 151, 55, 167, 55, 183, 55, 199, 55, 13, 93, 180, 214, 55, 230, 55, 2, 93, 48, 49, 1, 20, 14, 2, 35, 34, 46, 2, 53, 53, 6, 6, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 22, 23, 53, 51, 17, 20, 22, 51, 50, 62, 2, 53, 52, 46, 4, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 54, 55, 23, 6, 35, 34, 46, 4, 53, 52, 62, 4, 51, 50, 30, 2, 37, 38, 38, 35, 34, 14, 2, 21, 20, 22, 51, 50, 62, 2, 53, 3, 199, 22, 54, 90, 67, 29, 54, 42, 25, 22, 94, 62, 66, 88, 53, 22, 34, 68, 101, 67, 35, 78, 24, 131, 24, 23, 28, 40, 24, 11, 17, 39, 62, 89, 117, 74, 113, 152, 93, 40, 40, 93, 153, 112, 82, 130, 53, 59, 128, 196, 92, 145, 111, 79, 50, 23, 24, 50, 79, 112, 144, 91, 135, 191, 120, 54, 254, 129, 23, 63, 38, 38, 55, 36, 17, 57, 52, 37, 60, 42, 22, 2, 172, 68, 140, 113, 72, 20, 38, 51, 32, 28, 75, 94, 58, 96, 122, 64, 74, 135, 103, 61, 35, 37, 53, 253, 243, 32, 28, 54, 83, 100, 47, 69, 137, 123, 105, 77, 43, 96, 162, 212, 117, 115, 211, 162, 96, 58, 49, 68, 129, 51, 92, 126, 150, 168, 87, 89, 169, 150, 126, 91, 51, 111, 182, 230, 4, 49, 39, 45, 75, 95, 49, 109, 110, 45, 73, 91, 45, 0, 2, 255, 197, 0, 0, 3, 227, 5, 25, 0, 7, 0, 10, 0, 48, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 179, 8, 3, 2, 4, 43, 48, 49, 33, 35, 3, 33, 3, 35, 1, 51, 19, 3, 3, 3, 227, 147, 123, 253, 252, 121, 147, 1, 178, 186, 125, 219, 219, 1, 117, 254, 139, 5, 25, 252, 213, 2, 161, 253, 95, 0, 0, 3, 0, 49, 0, 0, 3, 162, 5, 25, 0, 14, 0, 27, 0, 36, 0, 135, 179, 33, 12, 4, 4, 43, 179, 11, 12, 15, 4, 43, 176, 11, 16, 177, 28, 10, 244, 177, 0, 12, 244, 178, 13, 4, 0, 17, 18, 57, 180, 218, 15, 234, 15, 2, 93, 64, 27, 9, 15, 25, 15, 41, 15, 57, 15, 73, 15, 89, 15, 105, 15, 121, 15, 137, 15, 153, 15, 169, 15, 185, 15, 201, 15, 13, 93, 176, 33, 16, 176, 21, 208, 176, 11, 16, 176, 38, 220, 0, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 21, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 179, 23, 1, 31, 4, 43, 178, 13, 31, 23, 17, 18, 57, 176, 5, 16, 177, 20, 6, 244, 176, 3, 16, 177, 33, 6, 244, 48, 49, 1, 20, 6, 35, 33, 17, 33, 50, 30, 2, 21, 20, 7, 22, 3, 52, 46, 2, 35, 33, 17, 33, 50, 62, 2, 19, 52, 38, 35, 33, 17, 33, 50, 54, 3, 162, 242, 223, 254, 96, 1, 137, 82, 158, 125, 78, 203, 248, 182, 58, 90, 108, 50, 255, 0, 1, 0, 56, 108, 86, 56, 45, 175, 153, 254, 233, 1, 23, 153, 175, 1, 117, 187, 186, 5, 25, 27, 74, 131, 106, 203, 74, 76, 1, 97, 69, 88, 47, 17, 254, 69, 17, 49, 86, 253, 244, 135, 123, 253, 254, 129, 0, 1, 255, 236, 255, 233, 3, 172, 5, 47, 0, 37, 0, 227, 176, 38, 47, 176, 39, 47, 176, 18, 220, 176, 0, 208, 176, 0, 47, 176, 38, 16, 176, 8, 208, 176, 8, 47, 176, 18, 16, 177, 17, 13, 244, 176, 20, 208, 176, 8, 16, 177, 30, 12, 244, 64, 27, 6, 30, 22, 30, 38, 30, 54, 30, 70, 30, 86, 30, 102, 30, 118, 30, 134, 30, 150, 30, 166, 30, 182, 30, 198, 30, 13, 93, 180, 213, 30, 229, 30, 2, 93, 176, 17, 16, 176, 37, 208, 176, 37, 47, 0, 176, 0, 69, 88, 176, 17, 47, 27, 177, 17, 21, 62, 89, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 21, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 178, 16, 3, 13, 17, 18, 57, 176, 13, 16, 177, 25, 6, 244, 180, 217, 25, 233, 25, 2, 93, 182, 8, 25, 24, 25, 40, 25, 3, 93, 64, 21, 56, 25, 72, 25, 88, 25, 104, 25, 120, 25, 136, 25, 152, 25, 168, 25, 184, 25, 200, 25, 10, 93, 176, 3, 16, 177, 35, 6, 244, 64, 27, 7, 35, 23, 35, 39, 35, 55, 35, 71, 35, 87, 35, 103, 35, 119, 35, 135, 35, 151, 35, 167, 35, 183, 35, 199, 35, 13, 93, 180, 214, 35, 230, 35, 2, 93, 48, 49, 1, 6, 6, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 22, 23, 53, 51, 17, 35, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 19, 3, 172, 51, 232, 176, 137, 190, 121, 53, 53, 121, 190, 137, 121, 172, 41, 117, 117, 53, 90, 123, 68, 106, 139, 84, 35, 35, 84, 139, 106, 244, 96, 1, 86, 168, 197, 113, 186, 244, 131, 131, 244, 188, 113, 86, 88, 152, 254, 84, 69, 123, 90, 51, 100, 162, 198, 99, 98, 199, 159, 101, 1, 39, 0, 0, 2, 0, 49, 0, 0, 3, 207, 5, 25, 0, 12, 0, 21, 0, 112, 176, 22, 47, 176, 23, 47, 176, 0, 220, 176, 22, 16, 176, 6, 208, 176, 6, 47, 176, 0, 16, 177, 13, 12, 244, 180, 218, 13, 234, 13, 2, 93, 64, 27, 9, 13, 25, 13, 41, 13, 57, 13, 73, 13, 89, 13, 105, 13, 121, 13, 137, 13, 153, 13, 169, 13, 185, 13, 201, 13, 13, 93, 176, 6, 16, 177, 18, 12, 244, 0, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 21, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 176, 7, 16, 177, 16, 6, 244, 176, 5, 16, 177, 18, 6, 244, 48, 49, 1, 20, 14, 2, 35, 33, 17, 33, 50, 30, 2, 7, 16, 2, 35, 33, 17, 33, 50, 18, 3, 207, 55, 121, 191, 135, 254, 88, 1, 168, 133, 191, 121, 57, 137, 193, 172, 254, 225, 1, 31, 172, 193, 2, 139, 131, 237, 179, 104, 5, 25, 107, 180, 236, 131, 1, 0, 1, 25, 251, 209, 1, 22, 0, 0, 1, 0, 49, 0, 0, 3, 115, 5, 25, 0, 11, 0, 61, 179, 10, 12, 1, 4, 43, 176, 10, 16, 176, 5, 208, 0, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 179, 7, 6, 8, 4, 43, 176, 2, 16, 177, 4, 6, 244, 176, 0, 16, 177, 10, 6, 244, 48, 49, 33, 33, 17, 33, 21, 33, 17, 33, 21, 33, 17, 33, 3, 115, 252, 190, 3, 66, 253, 71, 2, 2, 253, 254, 2, 185, 5, 25, 117, 254, 45, 117, 254, 25, 0, 0, 1, 0, 49, 0, 0, 3, 115, 5, 25, 0, 9, 0, 54, 179, 6, 12, 7, 4, 43, 176, 6, 16, 176, 1, 208, 0, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 21, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 179, 3, 6, 4, 4, 43, 176, 8, 16, 177, 0, 6, 244, 48, 49, 1, 33, 17, 33, 21, 33, 17, 35, 17, 33, 3, 115, 253, 71, 2, 2, 253, 254, 137, 3, 66, 4, 164, 254, 45, 117, 253, 164, 5, 25, 0, 1, 255, 236, 255, 233, 3, 215, 5, 47, 0, 43, 0, 211, 179, 32, 12, 10, 4, 43, 179, 20, 13, 19, 4, 43, 176, 19, 16, 176, 22, 208, 64, 27, 6, 32, 22, 32, 38, 32, 54, 32, 70, 32, 86, 32, 102, 32, 118, 32, 134, 32, 150, 32, 166, 32, 182, 32, 198, 32, 13, 93, 180, 213, 32, 229, 32, 2, 93, 176, 19, 16, 177, 43, 8, 244, 176, 20, 16, 176, 45, 220, 0, 176, 0, 69, 88, 176, 19, 47, 27, 177, 19, 21, 62, 89, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 21, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 179, 43, 6, 40, 4, 43, 178, 18, 5, 15, 17, 18, 57, 176, 15, 16, 177, 27, 6, 244, 180, 217, 27, 233, 27, 2, 93, 64, 27, 8, 27, 24, 27, 40, 27, 56, 27, 72, 27, 88, 27, 104, 27, 120, 27, 136, 27, 152, 27, 168, 27, 184, 27, 200, 27, 13, 93, 176, 5, 16, 177, 37, 6, 244, 64, 27, 7, 37, 23, 37, 39, 37, 55, 37, 71, 37, 87, 37, 103, 37, 119, 37, 135, 37, 151, 37, 167, 37, 183, 37, 199, 37, 13, 93, 180, 214, 37, 230, 37, 2, 93, 48, 49, 1, 20, 14, 2, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 22, 23, 53, 51, 17, 35, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 54, 55, 33, 53, 33, 3, 215, 55, 121, 191, 135, 137, 190, 121, 53, 53, 121, 190, 137, 121, 172, 41, 117, 117, 53, 90, 123, 68, 106, 139, 84, 35, 35, 84, 139, 106, 158, 182, 17, 254, 223, 1, 178, 2, 137, 133, 242, 186, 111, 113, 186, 244, 131, 131, 244, 188, 113, 86, 88, 152, 254, 84, 71, 123, 88, 51, 100, 162, 198, 99, 98, 199, 159, 101, 244, 221, 117, 0, 0, 1, 0, 49, 0, 0, 3, 115, 5, 25, 0, 11, 0, 96, 176, 12, 47, 176, 13, 47, 176, 0, 220, 177, 1, 8, 244, 176, 12, 16, 176, 5, 208, 176, 5, 47, 177, 4, 12, 244, 176, 7, 208, 176, 1, 16, 176, 9, 208, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 179, 9, 6, 2, 4, 43, 48, 49, 33, 35, 17, 33, 17, 35, 17, 51, 17, 33, 17, 51, 3, 115, 138, 253, 209, 137, 137, 2, 47, 138, 2, 92, 253, 164, 5, 25, 253, 184, 2, 72, 0, 1, 0, 186, 0, 0, 2, 233, 5, 25, 0, 11, 0, 61, 179, 10, 8, 3, 4, 43, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 177, 2, 6, 244, 176, 6, 16, 177, 4, 6, 244, 176, 8, 208, 176, 9, 208, 176, 2, 16, 176, 10, 208, 176, 11, 208, 48, 49, 33, 33, 53, 51, 17, 35, 53, 33, 21, 35, 17, 51, 2, 233, 253, 209, 211, 211, 2, 47, 210, 210, 117, 4, 47, 117, 117, 251, 209, 0, 1, 255, 254, 255, 233, 3, 115, 5, 25, 0, 17, 0, 76, 179, 0, 8, 15, 4, 43, 0, 176, 0, 69, 88, 176, 16, 47, 27, 177, 16, 21, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 177, 10, 6, 244, 64, 27, 7, 10, 23, 10, 39, 10, 55, 10, 71, 10, 87, 10, 103, 10, 119, 10, 135, 10, 151, 10, 167, 10, 183, 10, 199, 10, 13, 93, 180, 214, 10, 230, 10, 2, 93, 48, 49, 1, 20, 2, 35, 34, 38, 39, 55, 22, 22, 51, 50, 62, 2, 53, 17, 51, 3, 115, 211, 217, 174, 236, 47, 119, 43, 170, 125, 92, 115, 61, 22, 138, 1, 242, 248, 254, 239, 183, 182, 45, 162, 131, 74, 115, 143, 72, 3, 39, 0, 0, 1, 0, 49, 0, 0, 3, 158, 5, 25, 0, 11, 0, 74, 179, 4, 12, 5, 4, 43, 176, 4, 16, 176, 7, 208, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 178, 8, 0, 6, 17, 18, 57, 48, 49, 33, 35, 1, 7, 17, 35, 17, 51, 17, 1, 51, 1, 3, 158, 168, 254, 78, 138, 137, 137, 2, 47, 181, 254, 0, 2, 127, 154, 254, 27, 5, 25, 253, 133, 2, 123, 253, 198, 0, 1, 0, 49, 0, 0, 3, 115, 5, 25, 0, 5, 0, 39, 179, 4, 12, 1, 4, 43, 0, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 177, 4, 6, 244, 48, 49, 33, 33, 17, 51, 17, 33, 3, 115, 252, 190, 137, 2, 185, 5, 25, 251, 92, 0, 1, 0, 49, 0, 0, 3, 115, 5, 25, 0, 12, 0, 109, 176, 13, 47, 176, 14, 47, 176, 0, 220, 177, 1, 8, 244, 176, 13, 16, 176, 7, 208, 176, 7, 47, 177, 6, 12, 244, 178, 10, 7, 0, 17, 18, 57, 0, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 21, 62, 89, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 178, 2, 0, 8, 17, 18, 57, 178, 5, 0, 8, 17, 18, 57, 178, 10, 0, 8, 17, 18, 57, 48, 49, 33, 35, 17, 3, 35, 3, 17, 35, 17, 51, 19, 19, 51, 3, 115, 138, 231, 98, 230, 137, 178, 238, 240, 178, 4, 63, 253, 95, 2, 161, 251, 193, 5, 25, 253, 86, 2, 170, 0, 0, 1, 0, 49, 0, 0, 3, 115, 5, 25, 0, 9, 0, 98, 176, 10, 47, 176, 11, 47, 176, 0, 220, 176, 10, 16, 176, 4, 208, 176, 4, 47, 177, 3, 12, 244, 176, 0, 16, 177, 7, 8, 244, 0, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 21, 62, 89, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 178, 2, 0, 5, 17, 18, 57, 178, 7, 0, 5, 17, 18, 57, 48, 49, 33, 35, 1, 17, 35, 17, 51, 1, 17, 51, 3, 115, 170, 253, 241, 137, 193, 1, 247, 138, 4, 80, 251, 176, 5, 25, 251, 227, 4, 29, 0, 2, 255, 223, 255, 233, 3, 199, 5, 47, 0, 19, 0, 39, 0, 226, 176, 40, 47, 176, 41, 47, 176, 0, 220, 176, 40, 16, 176, 10, 208, 176, 10, 47, 176, 0, 16, 177, 20, 8, 244, 180, 218, 20, 234, 20, 2, 93, 64, 27, 9, 20, 25, 20, 41, 20, 57, 20, 73, 20, 89, 20, 105, 20, 121, 20, 137, 20, 153, 20, 169, 20, 185, 20, 201, 20, 13, 93, 176, 10, 16, 177, 30, 12, 244, 64, 23, 6, 30, 22, 30, 38, 30, 54, 30, 70, 30, 86, 30, 102, 30, 118, 30, 134, 30, 150, 30, 166, 30, 11, 93, 180, 182, 30, 198, 30, 2, 93, 180, 213, 30, 229, 30, 2, 93, 0, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 21, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 176, 15, 16, 177, 25, 6, 244, 180, 217, 25, 233, 25, 2, 93, 64, 27, 8, 25, 24, 25, 40, 25, 56, 25, 72, 25, 88, 25, 104, 25, 120, 25, 136, 25, 152, 25, 168, 25, 184, 25, 200, 25, 13, 93, 176, 5, 16, 177, 35, 6, 244, 64, 27, 7, 35, 23, 35, 39, 35, 55, 35, 71, 35, 87, 35, 103, 35, 119, 35, 135, 35, 151, 35, 167, 35, 183, 35, 199, 35, 13, 93, 180, 214, 35, 230, 35, 2, 93, 48, 49, 1, 20, 14, 2, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 30, 2, 7, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 62, 2, 3, 199, 54, 118, 191, 137, 137, 191, 119, 53, 53, 121, 191, 135, 135, 191, 118, 56, 138, 49, 92, 135, 86, 107, 139, 84, 33, 33, 84, 139, 107, 106, 140, 84, 32, 2, 139, 131, 244, 186, 113, 113, 186, 244, 131, 131, 244, 188, 113, 113, 188, 244, 131, 129, 207, 146, 77, 100, 162, 198, 99, 98, 199, 159, 101, 101, 159, 199, 0, 2, 0, 49, 0, 0, 3, 162, 5, 25, 0, 10, 0, 19, 0, 114, 176, 20, 47, 176, 21, 47, 176, 0, 220, 176, 20, 16, 176, 6, 208, 176, 6, 47, 177, 5, 12, 244, 176, 0, 16, 177, 11, 12, 244, 180, 218, 11, 234, 11, 2, 93, 64, 27, 9, 11, 25, 11, 41, 11, 57, 11, 73, 11, 89, 11, 105, 11, 121, 11, 137, 11, 153, 11, 169, 11, 185, 11, 201, 11, 13, 93, 176, 5, 16, 176, 15, 208, 0, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 21, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 179, 17, 6, 3, 4, 43, 176, 7, 16, 177, 14, 6, 244, 48, 49, 1, 20, 6, 35, 33, 17, 35, 17, 33, 50, 22, 7, 52, 38, 35, 33, 17, 33, 50, 54, 3, 162, 236, 213, 254, 217, 137, 1, 174, 215, 236, 137, 170, 142, 254, 217, 1, 39, 142, 170, 3, 164, 189, 184, 253, 209, 5, 25, 187, 186, 135, 121, 254, 0, 121, 0, 0, 2, 255, 223, 254, 141, 3, 199, 5, 47, 0, 32, 0, 48, 1, 28, 176, 49, 47, 176, 50, 47, 176, 0, 220, 177, 33, 8, 244, 180, 218, 33, 234, 33, 2, 93, 64, 27, 9, 33, 25, 33, 41, 33, 57, 33, 73, 33, 89, 33, 105, 33, 121, 33, 137, 33, 153, 33, 169, 33, 185, 33, 201, 33, 13, 93, 176, 8, 208, 176, 8, 47, 176, 33, 16, 176, 15, 208, 176, 15, 47, 176, 49, 16, 176, 23, 208, 176, 23, 47, 177, 43, 12, 244, 64, 27, 6, 43, 22, 43, 38, 43, 54, 43, 70, 43, 86, 43, 102, 43, 118, 43, 134, 43, 150, 43, 166, 43, 182, 43, 198, 43, 13, 93, 180, 213, 43, 229, 43, 2, 93, 0, 176, 0, 69, 88, 176, 28, 47, 27, 177, 28, 21, 62, 89, 176, 0, 69, 88, 176, 12, 47, 27, 177, 12, 17, 62, 89, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 17, 62, 89, 176, 0, 69, 88, 176, 18, 47, 27, 177, 18, 15, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 176, 15, 16, 177, 8, 6, 244, 64, 27, 7, 8, 23, 8, 39, 8, 55, 8, 71, 8, 87, 8, 103, 8, 119, 8, 135, 8, 151, 8, 167, 8, 183, 8, 199, 8, 13, 93, 180, 214, 8, 230, 8, 2, 93, 176, 11, 208, 176, 11, 47, 176, 28, 16, 177, 38, 6, 244, 180, 217, 38, 233, 38, 2, 93, 64, 27, 8, 38, 24, 38, 40, 38, 56, 38, 72, 38, 88, 38, 104, 38, 120, 38, 136, 38, 152, 38, 168, 38, 184, 38, 200, 38, 13, 93, 176, 18, 16, 177, 46, 1, 244, 48, 49, 1, 20, 14, 2, 7, 22, 22, 51, 50, 54, 55, 21, 6, 6, 35, 34, 38, 39, 46, 3, 53, 52, 62, 2, 51, 50, 30, 2, 7, 52, 46, 2, 35, 34, 14, 2, 21, 16, 18, 51, 50, 18, 3, 199, 47, 105, 168, 119, 23, 139, 135, 35, 49, 23, 29, 53, 25, 204, 207, 23, 110, 162, 103, 49, 53, 121, 191, 135, 135, 191, 118, 56, 138, 34, 82, 142, 104, 107, 139, 84, 33, 189, 174, 172, 190, 2, 139, 125, 231, 182, 119, 12, 134, 102, 2, 2, 117, 2, 2, 174, 181, 14, 115, 178, 231, 129, 131, 244, 188, 113, 113, 188, 244, 131, 99, 198, 162, 100, 100, 162, 198, 99, 254, 252, 254, 215, 1, 41, 0, 2, 0, 49, 0, 0, 3, 176, 5, 25, 0, 15, 0, 24, 0, 142, 176, 25, 47, 176, 26, 47, 176, 10, 220, 176, 0, 208, 176, 0, 47, 176, 25, 16, 176, 5, 208, 176, 5, 47, 177, 4, 12, 244, 176, 10, 16, 177, 16, 8, 244, 180, 218, 16, 234, 16, 2, 93, 64, 27, 9, 16, 25, 16, 41, 16, 57, 16, 73, 16, 89, 16, 105, 16, 121, 16, 137, 16, 153, 16, 169, 16, 185, 16, 201, 16, 13, 93, 176, 4, 16, 176, 20, 208, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 179, 22, 1, 15, 4, 43, 176, 15, 16, 176, 2, 208, 176, 2, 47, 176, 6, 16, 177, 19, 6, 244, 48, 49, 33, 35, 1, 35, 17, 35, 17, 33, 50, 22, 21, 20, 14, 2, 7, 19, 52, 38, 35, 33, 17, 33, 50, 54, 3, 176, 174, 254, 131, 203, 137, 1, 174, 215, 236, 58, 100, 139, 82, 237, 165, 144, 254, 219, 1, 37, 144, 165, 2, 47, 253, 209, 5, 25, 187, 186, 82, 131, 92, 56, 6, 1, 111, 133, 123, 254, 0, 121, 0, 1, 0, 25, 255, 233, 3, 131, 5, 47, 0, 63, 0, 220, 179, 12, 10, 32, 4, 43, 179, 42, 11, 41, 4, 43, 176, 41, 16, 177, 0, 8, 244, 176, 12, 16, 176, 8, 208, 176, 41, 16, 176, 44, 208, 176, 32, 16, 177, 54, 12, 244, 176, 42, 16, 176, 65, 220, 0, 176, 0, 69, 88, 176, 41, 47, 27, 177, 41, 21, 62, 89, 176, 0, 69, 88, 176, 43, 47, 27, 177, 43, 19, 62, 89, 176, 0, 69, 88, 176, 37, 47, 27, 177, 37, 21, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 15, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 179, 59, 4, 27, 4, 43, 178, 8, 5, 37, 17, 18, 57, 176, 5, 16, 177, 17, 6, 244, 64, 27, 7, 17, 23, 17, 39, 17, 55, 17, 71, 17, 87, 17, 103, 17, 119, 17, 135, 17, 151, 17, 167, 17, 183, 17, 199, 17, 13, 93, 180, 214, 17, 230, 17, 2, 93, 178, 40, 5, 37, 17, 18, 57, 176, 37, 16, 177, 49, 6, 244, 180, 217, 49, 233, 49, 2, 93, 64, 27, 8, 49, 24, 49, 40, 49, 56, 49, 72, 49, 88, 49, 104, 49, 120, 49, 136, 49, 152, 49, 168, 49, 184, 49, 200, 49, 13, 93, 48, 49, 1, 20, 14, 2, 35, 34, 38, 39, 21, 35, 17, 51, 20, 30, 2, 51, 50, 62, 2, 53, 52, 46, 2, 39, 46, 3, 53, 52, 62, 2, 51, 50, 22, 23, 53, 51, 17, 35, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 23, 30, 3, 3, 131, 68, 114, 148, 80, 110, 184, 54, 116, 116, 62, 96, 125, 65, 58, 98, 74, 43, 55, 93, 116, 60, 71, 142, 112, 70, 68, 110, 146, 77, 95, 161, 45, 121, 121, 49, 84, 108, 60, 53, 96, 72, 43, 51, 86, 113, 59, 74, 146, 116, 74, 1, 84, 82, 133, 96, 52, 82, 80, 139, 1, 141, 67, 111, 80, 45, 33, 61, 88, 56, 63, 90, 64, 45, 22, 25, 55, 84, 121, 90, 80, 125, 86, 45, 78, 80, 136, 254, 139, 59, 103, 73, 43, 24, 53, 84, 58, 51, 72, 55, 45, 23, 26, 64, 90, 131, 0, 0, 1, 0, 0, 0, 0, 3, 164, 5, 25, 0, 15, 0, 107, 176, 16, 47, 176, 13, 208, 176, 13, 47, 176, 9, 220, 178, 64, 9, 1, 93, 176, 1, 220, 178, 64, 1, 1, 93, 177, 0, 13, 244, 176, 9, 16, 177, 4, 8, 244, 176, 13, 16, 177, 12, 13, 244, 176, 0, 16, 176, 17, 220, 0, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 21, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 176, 14, 16, 177, 2, 6, 244, 176, 6, 16, 177, 4, 6, 244, 176, 8, 208, 176, 9, 208, 176, 2, 16, 176, 10, 208, 176, 11, 208, 48, 49, 1, 35, 17, 33, 17, 51, 21, 33, 53, 51, 17, 33, 17, 35, 17, 33, 3, 164, 117, 254, 232, 210, 253, 209, 211, 254, 232, 117, 3, 164, 3, 96, 1, 68, 251, 209, 117, 117, 4, 47, 254, 188, 1, 185, 0, 0, 1, 0, 49, 255, 233, 3, 115, 5, 25, 0, 25, 0, 112, 176, 26, 47, 176, 27, 47, 176, 0, 220, 176, 26, 16, 176, 10, 208, 176, 10, 47, 177, 13, 12, 244, 176, 0, 16, 177, 23, 8, 244, 0, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 21, 62, 89, 176, 0, 69, 88, 176, 24, 47, 27, 177, 24, 21, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 177, 18, 6, 244, 64, 27, 7, 18, 23, 18, 39, 18, 55, 18, 71, 18, 87, 18, 103, 18, 119, 18, 135, 18, 151, 18, 167, 18, 183, 18, 199, 18, 13, 93, 180, 214, 18, 230, 18, 2, 93, 48, 49, 1, 20, 14, 2, 35, 34, 46, 2, 53, 17, 51, 17, 20, 30, 2, 51, 50, 62, 2, 53, 17, 51, 3, 115, 49, 103, 158, 108, 109, 157, 101, 49, 137, 21, 61, 109, 88, 88, 111, 61, 20, 138, 1, 209, 111, 180, 127, 70, 70, 127, 182, 111, 3, 70, 252, 184, 59, 132, 108, 72, 72, 108, 132, 59, 3, 72, 0, 1, 255, 197, 0, 0, 3, 227, 5, 25, 0, 6, 0, 49, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 21, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 21, 62, 89, 176, 0, 69, 88, 176, 1, 47, 27, 177, 1, 15, 62, 89, 178, 5, 1, 0, 17, 18, 57, 48, 49, 1, 1, 35, 1, 51, 1, 1, 3, 227, 254, 76, 186, 254, 80, 145, 1, 125, 1, 123, 5, 25, 250, 231, 5, 25, 251, 114, 4, 142, 0, 1, 255, 193, 0, 0, 3, 227, 5, 25, 0, 12, 0, 89, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 21, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 19, 62, 89, 176, 0, 69, 88, 176, 1, 47, 27, 177, 1, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 178, 3, 1, 0, 17, 18, 57, 178, 8, 1, 0, 17, 18, 57, 178, 11, 1, 0, 17, 18, 57, 48, 49, 1, 3, 35, 3, 3, 35, 3, 51, 19, 19, 51, 19, 19, 3, 227, 235, 162, 133, 135, 160, 233, 145, 184, 131, 135, 132, 184, 5, 25, 250, 231, 2, 125, 253, 131, 5, 25, 251, 206, 2, 189, 253, 67, 4, 50, 0, 1, 255, 233, 0, 0, 3, 186, 5, 25, 0, 27, 0, 122, 0, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 21, 62, 89, 176, 0, 69, 88, 176, 21, 47, 27, 177, 21, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 15, 62, 89, 177, 2, 6, 244, 176, 3, 208, 178, 4, 0, 14, 17, 18, 57, 176, 5, 208, 176, 6, 208, 176, 9, 208, 176, 10, 208, 176, 14, 16, 177, 12, 6, 244, 176, 16, 208, 176, 17, 208, 178, 18, 0, 14, 17, 18, 57, 176, 19, 208, 176, 20, 208, 176, 23, 208, 176, 24, 208, 176, 10, 16, 176, 26, 208, 176, 27, 208, 48, 49, 33, 33, 53, 51, 3, 3, 51, 21, 33, 53, 51, 1, 1, 35, 53, 33, 21, 35, 19, 19, 35, 53, 33, 21, 35, 1, 1, 51, 3, 186, 254, 142, 88, 205, 207, 88, 254, 141, 127, 1, 27, 254, 234, 109, 1, 117, 109, 203, 197, 105, 1, 117, 113, 254, 240, 1, 24, 127, 117, 1, 172, 254, 84, 117, 117, 2, 28, 2, 19, 117, 117, 254, 94, 1, 162, 117, 117, 253, 237, 253, 228, 0, 0, 1, 255, 236, 0, 0, 3, 184, 5, 25, 0, 20, 0, 103, 179, 3, 8, 8, 4, 43, 178, 16, 8, 3, 17, 18, 57, 0, 176, 0, 69, 88, 176, 12, 47, 27, 177, 12, 21, 62, 89, 176, 0, 69, 88, 176, 19, 47, 27, 177, 19, 21, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 176, 19, 16, 177, 0, 6, 244, 176, 5, 16, 177, 3, 6, 244, 176, 7, 208, 176, 8, 208, 176, 0, 16, 176, 10, 208, 176, 11, 208, 176, 14, 208, 176, 15, 208, 178, 16, 5, 12, 17, 18, 57, 176, 17, 208, 176, 18, 208, 48, 49, 1, 35, 1, 17, 51, 21, 33, 53, 51, 17, 1, 35, 53, 33, 21, 35, 19, 19, 35, 53, 33, 3, 184, 106, 254, 201, 210, 253, 209, 211, 254, 201, 106, 1, 112, 108, 227, 225, 108, 1, 112, 4, 164, 253, 143, 254, 66, 117, 117, 1, 190, 2, 113, 117, 117, 254, 20, 1, 236, 117, 0, 0, 1, 0, 49, 0, 0, 3, 119, 5, 25, 0, 13, 0, 85, 176, 14, 47, 176, 15, 47, 176, 0, 220, 176, 14, 16, 176, 6, 208, 176, 6, 47, 176, 1, 208, 178, 3, 6, 0, 17, 18, 57, 176, 6, 16, 177, 5, 13, 244, 176, 0, 16, 177, 11, 13, 244, 0, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 7, 16, 177, 3, 6, 244, 176, 0, 16, 177, 10, 6, 244, 48, 49, 33, 33, 53, 1, 33, 17, 35, 17, 33, 21, 1, 33, 17, 51, 3, 119, 252, 186, 2, 144, 253, 229, 117, 3, 49, 253, 119, 2, 41, 117, 117, 4, 47, 254, 192, 1, 181, 117, 251, 209, 1, 69, 0, 0, 1, 1, 117, 254, 139, 2, 233, 5, 211, 0, 7, 0, 45, 179, 6, 9, 1, 4, 43, 176, 1, 16, 177, 0, 14, 244, 176, 3, 208, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 17, 62, 89, 179, 3, 1, 4, 4, 43, 176, 0, 16, 177, 6, 1, 244, 48, 49, 1, 33, 17, 33, 21, 33, 17, 33, 2, 233, 254, 140, 1, 116, 254, 250, 1, 6, 254, 139, 7, 72, 111, 249, 152, 0, 1, 0, 133, 255, 16, 3, 229, 5, 74, 0, 3, 0, 9, 0, 176, 1, 47, 176, 3, 47, 48, 49, 5, 7, 1, 55, 3, 229, 98, 253, 2, 98, 188, 52, 6, 7, 51, 0, 1, 0, 186, 254, 139, 2, 47, 5, 211, 0, 7, 0, 48, 179, 0, 14, 1, 4, 43, 176, 0, 16, 177, 3, 9, 244, 176, 1, 16, 176, 5, 208, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 17, 62, 89, 179, 7, 1, 4, 4, 43, 176, 0, 16, 177, 2, 1, 244, 48, 49, 1, 33, 53, 33, 17, 33, 53, 33, 2, 47, 254, 139, 1, 7, 254, 249, 1, 117, 254, 139, 113, 6, 104, 111, 0, 1, 0, 2, 2, 47, 3, 166, 5, 25, 0, 6, 0, 29, 0, 176, 0, 47, 176, 3, 47, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 21, 62, 89, 178, 2, 0, 5, 17, 18, 57, 48, 49, 1, 35, 1, 1, 35, 1, 51, 3, 166, 152, 254, 197, 254, 199, 152, 1, 117, 184, 2, 47, 2, 101, 253, 155, 2, 234, 0, 0, 1, 0, 0, 255, 70, 3, 164, 255, 187, 0, 3, 0, 9, 0, 179, 3, 6, 0, 4, 43, 48, 49, 5, 33, 53, 33, 3, 164, 252, 92, 3, 164, 186, 117, 0, 0, 1, 0, 229, 3, 244, 2, 188, 5, 84, 0, 3, 0, 9, 0, 176, 1, 47, 176, 3, 47, 48, 49, 1, 7, 37, 55, 2, 188, 41, 254, 82, 66, 4, 53, 65, 243, 109, 0, 2, 255, 254, 255, 233, 3, 115, 3, 186, 0, 38, 0, 55, 0, 237, 176, 56, 47, 176, 57, 47, 176, 56, 16, 176, 0, 208, 176, 0, 47, 176, 57, 16, 176, 28, 220, 177, 11, 8, 244, 176, 30, 208, 178, 31, 0, 28, 17, 18, 57, 176, 11, 16, 176, 44, 208, 176, 0, 16, 177, 53, 12, 244, 64, 27, 6, 53, 22, 53, 38, 53, 54, 53, 70, 53, 86, 53, 102, 53, 118, 53, 134, 53, 150, 53, 166, 53, 182, 53, 198, 53, 13, 93, 180, 213, 53, 229, 53, 2, 93, 0, 176, 0, 69, 88, 176, 23, 47, 27, 177, 23, 19, 62, 89, 176, 0, 69, 88, 176, 29, 47, 27, 177, 29, 15, 62, 89, 176, 0, 69, 88, 176, 36, 47, 27, 177, 36, 15, 62, 89, 179, 5, 6, 48, 4, 43, 176, 23, 16, 177, 16, 6, 244, 180, 217, 16, 233, 16, 2, 93, 64, 27, 8, 16, 24, 16, 40, 16, 56, 16, 72, 16, 88, 16, 104, 16, 120, 16, 136, 16, 152, 16, 168, 16, 184, 16, 200, 16, 13, 93, 178, 31, 36, 23, 17, 18, 57, 176, 36, 16, 177, 39, 6, 244, 64, 27, 7, 39, 23, 39, 39, 39, 55, 39, 71, 39, 87, 39, 103, 39, 119, 39, 135, 39, 151, 39, 167, 39, 183, 39, 199, 39, 13, 93, 180, 214, 39, 230, 39, 2, 93, 176, 48, 16, 176, 45, 208, 176, 45, 47, 48, 49, 39, 52, 62, 2, 51, 50, 30, 2, 23, 53, 52, 46, 2, 35, 34, 6, 7, 39, 54, 54, 51, 50, 30, 2, 21, 17, 35, 53, 14, 3, 35, 34, 38, 5, 50, 62, 2, 53, 53, 38, 38, 35, 34, 14, 2, 21, 20, 22, 2, 88, 143, 185, 96, 37, 59, 53, 54, 32, 59, 86, 94, 33, 104, 176, 76, 62, 84, 209, 125, 76, 147, 117, 70, 138, 36, 91, 100, 100, 45, 185, 190, 1, 119, 86, 137, 96, 53, 67, 123, 45, 74, 137, 102, 62, 115, 252, 88, 119, 69, 31, 2, 4, 6, 4, 67, 68, 88, 51, 21, 56, 47, 103, 51, 65, 39, 81, 132, 92, 253, 158, 156, 45, 68, 43, 23, 142, 25, 51, 76, 86, 35, 88, 10, 2, 20, 45, 72, 53, 59, 99, 0, 0, 2, 0, 49, 255, 233, 3, 164, 5, 25, 0, 20, 0, 36, 0, 236, 176, 37, 47, 176, 38, 47, 176, 0, 220, 176, 37, 16, 176, 10, 208, 176, 10, 47, 177, 9, 12, 244, 176, 12, 208, 178, 13, 10, 0, 17, 18, 57, 176, 0, 16, 177, 21, 8, 244, 180, 218, 21, 234, 21, 2, 93, 64, 27, 9, 21, 25, 21, 41, 21, 57, 21, 73, 21, 89, 21, 105, 21, 121, 21, 137, 21, 153, 21, 169, 21, 185, 21, 201, 21, 13, 93, 176, 9, 16, 176, 28, 208, 0, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 21, 62, 89, 176, 0, 69, 88, 176, 16, 47, 27, 177, 16, 19, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 15, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 177, 32, 6, 244, 64, 27, 7, 32, 23, 32, 39, 32, 55, 32, 71, 32, 87, 32, 103, 32, 119, 32, 135, 32, 151, 32, 167, 32, 183, 32, 199, 32, 13, 93, 180, 214, 32, 230, 32, 2, 93, 178, 8, 5, 32, 17, 18, 57, 176, 16, 16, 177, 26, 6, 244, 180, 217, 26, 233, 26, 2, 93, 64, 27, 8, 26, 24, 26, 40, 26, 56, 26, 72, 26, 88, 26, 104, 26, 120, 26, 136, 26, 152, 26, 168, 26, 184, 26, 200, 26, 13, 93, 178, 13, 16, 26, 17, 18, 57, 48, 49, 1, 20, 14, 2, 35, 34, 38, 39, 21, 35, 17, 51, 17, 54, 54, 51, 50, 30, 2, 7, 52, 46, 2, 35, 34, 7, 17, 22, 22, 51, 50, 62, 2, 3, 164, 66, 123, 174, 108, 76, 139, 60, 137, 137, 60, 139, 76, 108, 174, 123, 66, 139, 41, 84, 125, 82, 158, 117, 60, 137, 78, 82, 123, 84, 43, 1, 209, 107, 180, 129, 72, 54, 53, 84, 5, 25, 254, 53, 51, 57, 73, 129, 181, 106, 80, 135, 100, 58, 125, 254, 14, 65, 56, 58, 100, 135, 0, 1, 0, 0, 255, 233, 3, 129, 3, 186, 0, 40, 0, 215, 176, 41, 47, 176, 42, 47, 176, 20, 220, 176, 0, 208, 176, 0, 47, 176, 41, 16, 176, 8, 208, 176, 8, 47, 176, 20, 16, 177, 19, 11, 244, 176, 22, 208, 176, 8, 16, 177, 32, 12, 244, 64, 27, 6, 32, 22, 32, 38, 32, 54, 32, 70, 32, 86, 32, 102, 32, 118, 32, 134, 32, 150, 32, 166, 32, 182, 32, 198, 32, 13, 93, 180, 213, 32, 229, 32, 2, 93, 0, 176, 0, 69, 88, 176, 19, 47, 27, 177, 19, 19, 62, 89, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 19, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 178, 18, 3, 13, 17, 18, 57, 176, 13, 16, 177, 27, 6, 244, 180, 217, 27, 233, 27, 2, 93, 64, 27, 8, 27, 24, 27, 40, 27, 56, 27, 72, 27, 88, 27, 104, 27, 120, 27, 136, 27, 152, 27, 168, 27, 184, 27, 200, 27, 13, 93, 176, 3, 16, 177, 37, 6, 244, 64, 27, 7, 37, 23, 37, 39, 37, 55, 37, 71, 37, 87, 37, 103, 37, 119, 37, 135, 37, 151, 37, 167, 37, 183, 37, 199, 37, 13, 93, 180, 214, 37, 230, 37, 2, 93, 48, 49, 37, 6, 6, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 30, 2, 23, 53, 51, 17, 35, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 54, 55, 3, 129, 59, 205, 141, 109, 182, 129, 72, 66, 122, 177, 108, 43, 90, 80, 64, 16, 123, 123, 45, 78, 108, 62, 84, 125, 84, 43, 49, 93, 131, 82, 104, 162, 43, 178, 92, 109, 72, 129, 178, 109, 106, 181, 129, 73, 20, 41, 57, 39, 135, 254, 139, 62, 102, 74, 41, 58, 100, 135, 80, 80, 135, 98, 58, 82, 68, 0, 0, 2, 255, 254, 255, 233, 3, 115, 5, 25, 0, 22, 0, 38, 0, 232, 176, 39, 47, 176, 40, 47, 176, 0, 220, 177, 1, 8, 244, 176, 39, 16, 176, 10, 208, 176, 10, 47, 176, 1, 16, 176, 18, 208, 176, 1, 16, 176, 23, 208, 176, 10, 16, 177, 31, 12, 244, 64, 27, 6, 31, 22, 31, 38, 31, 54, 31, 70, 31, 86, 31, 102, 31, 118, 31, 134, 31, 150, 31, 166, 31, 182, 31, 198, 31, 13, 93, 180, 213, 31, 229, 31, 2, 93, 0, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 19, 62, 89, 176, 0, 69, 88, 176, 21, 47, 27, 177, 21, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 177, 36, 6, 244, 64, 27, 7, 36, 23, 36, 39, 36, 55, 36, 71, 36, 87, 36, 103, 36, 119, 36, 135, 36, 151, 36, 167, 36, 183, 36, 199, 36, 13, 93, 180, 214, 36, 230, 36, 2, 93, 178, 2, 5, 36, 17, 18, 57, 176, 21, 16, 177, 19, 6, 244, 176, 15, 16, 177, 26, 6, 244, 180, 217, 26, 233, 26, 2, 93, 64, 27, 8, 26, 24, 26, 40, 26, 56, 26, 72, 26, 88, 26, 104, 26, 120, 26, 136, 26, 152, 26, 168, 26, 184, 26, 200, 26, 13, 93, 48, 49, 33, 35, 53, 6, 6, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 22, 23, 17, 35, 53, 33, 3, 38, 38, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 55, 3, 115, 138, 59, 141, 74, 111, 176, 121, 65, 65, 121, 176, 111, 74, 141, 59, 186, 1, 68, 138, 59, 139, 78, 82, 125, 84, 43, 43, 84, 125, 82, 158, 118, 86, 53, 56, 72, 129, 180, 107, 106, 181, 129, 73, 53, 53, 1, 84, 117, 253, 178, 65, 58, 58, 100, 135, 80, 80, 135, 100, 58, 125, 0, 2, 255, 252, 255, 233, 3, 174, 3, 186, 0, 25, 0, 34, 0, 123, 0, 176, 0, 69, 88, 176, 20, 47, 27, 177, 20, 19, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 15, 62, 89, 179, 34, 6, 0, 4, 43, 176, 10, 16, 177, 3, 6, 244, 64, 27, 7, 3, 23, 3, 39, 3, 55, 3, 71, 3, 87, 3, 103, 3, 119, 3, 135, 3, 151, 3, 167, 3, 183, 3, 199, 3, 13, 93, 180, 214, 3, 230, 3, 2, 93, 176, 20, 16, 177, 29, 6, 244, 180, 217, 29, 233, 29, 2, 93, 64, 27, 8, 29, 24, 29, 40, 29, 56, 29, 72, 29, 88, 29, 104, 29, 120, 29, 136, 29, 152, 29, 168, 29, 184, 29, 200, 29, 13, 93, 48, 49, 19, 22, 22, 51, 50, 54, 55, 23, 6, 6, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 30, 2, 21, 39, 38, 38, 35, 34, 14, 2, 7, 137, 15, 186, 149, 105, 164, 41, 96, 70, 194, 142, 108, 180, 131, 72, 65, 123, 176, 109, 119, 178, 119, 57, 145, 23, 176, 129, 66, 112, 86, 58, 8, 1, 162, 148, 176, 86, 64, 66, 98, 103, 72, 129, 178, 109, 106, 179, 131, 73, 80, 141, 196, 119, 117, 153, 150, 43, 80, 113, 67, 0, 1, 0, 186, 0, 0, 3, 164, 5, 47, 0, 25, 0, 159, 179, 2, 8, 7, 4, 43, 176, 7, 16, 176, 11, 208, 176, 2, 16, 176, 24, 208, 0, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 21, 62, 89, 176, 0, 69, 88, 176, 17, 47, 27, 177, 17, 21, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 19, 62, 89, 176, 0, 69, 88, 176, 24, 47, 27, 177, 24, 19, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 176, 24, 16, 177, 0, 6, 244, 176, 4, 16, 177, 2, 6, 244, 176, 6, 208, 176, 7, 208, 176, 0, 16, 176, 8, 208, 176, 9, 208, 176, 14, 16, 177, 21, 6, 244, 180, 217, 21, 233, 21, 2, 93, 64, 27, 8, 21, 24, 21, 40, 21, 56, 21, 72, 21, 88, 21, 104, 21, 120, 21, 136, 21, 152, 21, 168, 21, 184, 21, 200, 21, 13, 93, 48, 49, 1, 33, 17, 51, 21, 33, 53, 51, 17, 35, 53, 51, 52, 54, 51, 50, 22, 23, 21, 38, 38, 35, 34, 6, 21, 33, 3, 164, 254, 115, 210, 253, 209, 211, 211, 211, 199, 201, 47, 65, 23, 29, 63, 43, 131, 131, 1, 141, 3, 47, 253, 70, 117, 117, 2, 186, 117, 192, 203, 6, 4, 117, 4, 6, 133, 145, 0, 0, 2, 255, 254, 254, 117, 3, 115, 3, 186, 0, 31, 0, 46, 1, 1, 176, 47, 47, 176, 48, 47, 176, 0, 220, 176, 47, 16, 176, 21, 208, 176, 21, 47, 177, 40, 12, 244, 64, 27, 6, 40, 22, 40, 38, 40, 54, 40, 70, 40, 86, 40, 102, 40, 118, 40, 134, 40, 150, 40, 166, 40, 182, 40, 198, 40, 13, 93, 180, 213, 40, 229, 40, 2, 93, 176, 9, 208, 176, 9, 47, 176, 0, 16, 177, 15, 8, 244, 176, 29, 208, 176, 15, 16, 176, 32, 208, 0, 176, 0, 69, 88, 176, 30, 47, 27, 177, 30, 19, 62, 89, 176, 0, 69, 88, 176, 26, 47, 27, 177, 26, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 15, 62, 89, 176, 0, 69, 88, 176, 18, 47, 27, 177, 18, 15, 62, 89, 179, 12, 4, 5, 4, 43, 176, 18, 16, 177, 43, 6, 244, 64, 27, 7, 43, 23, 43, 39, 43, 55, 43, 71, 43, 87, 43, 103, 43, 119, 43, 135, 43, 151, 43, 167, 43, 183, 43, 199, 43, 13, 93, 180, 214, 43, 230, 43, 2, 93, 178, 16, 18, 43, 17, 18, 57, 176, 26, 16, 177, 35, 6, 244, 180, 217, 35, 233, 35, 2, 93, 64, 27, 8, 35, 24, 35, 40, 35, 56, 35, 72, 35, 88, 35, 104, 35, 120, 35, 136, 35, 152, 35, 168, 35, 184, 35, 200, 35, 13, 93, 178, 29, 26, 35, 17, 18, 57, 48, 49, 37, 20, 14, 2, 35, 34, 38, 39, 55, 22, 22, 51, 50, 54, 53, 53, 6, 35, 34, 38, 53, 52, 62, 2, 51, 50, 22, 23, 53, 51, 7, 38, 38, 35, 34, 14, 2, 21, 20, 22, 51, 50, 54, 55, 3, 115, 66, 119, 161, 99, 139, 195, 71, 96, 43, 162, 104, 142, 165, 122, 156, 219, 250, 65, 121, 174, 109, 76, 143, 59, 138, 138, 59, 141, 78, 82, 125, 82, 43, 166, 166, 78, 141, 59, 10, 96, 150, 104, 55, 104, 98, 74, 65, 88, 143, 135, 100, 108, 250, 217, 106, 179, 131, 73, 53, 53, 84, 217, 65, 58, 58, 100, 137, 78, 160, 190, 59, 66, 0, 0, 1, 0, 49, 0, 0, 3, 115, 5, 25, 0, 19, 0, 142, 176, 20, 47, 176, 21, 47, 176, 0, 220, 177, 1, 8, 244, 176, 20, 16, 176, 12, 208, 176, 12, 47, 177, 11, 12, 244, 176, 14, 208, 178, 15, 12, 0, 17, 18, 57, 0, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 21, 62, 89, 176, 0, 69, 88, 176, 17, 47, 27, 177, 17, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 15, 62, 89, 176, 17, 16, 177, 5, 6, 244, 180, 217, 5, 233, 5, 2, 93, 64, 27, 8, 5, 24, 5, 40, 5, 56, 5, 72, 5, 88, 5, 104, 5, 120, 5, 136, 5, 152, 5, 168, 5, 184, 5, 200, 5, 13, 93, 178, 15, 0, 13, 17, 18, 57, 48, 49, 33, 35, 17, 52, 38, 35, 34, 14, 2, 21, 17, 35, 17, 51, 17, 18, 51, 32, 17, 3, 115, 138, 108, 121, 76, 123, 86, 45, 137, 137, 99, 254, 1, 88, 2, 63, 125, 138, 70, 117, 151, 82, 254, 94, 5, 25, 253, 161, 1, 0, 254, 133, 0, 2, 0, 186, 0, 0, 2, 233, 5, 25, 0, 3, 0, 13, 0, 95, 179, 12, 14, 6, 4, 43, 178, 1, 6, 12, 17, 18, 57, 176, 1, 47, 177, 0, 8, 244, 176, 12, 16, 177, 7, 8, 244, 176, 6, 16, 176, 9, 208, 0, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 21, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 19, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 177, 6, 6, 244, 176, 10, 16, 177, 8, 6, 244, 176, 6, 16, 176, 12, 208, 176, 13, 208, 48, 49, 1, 35, 53, 51, 19, 33, 53, 51, 17, 35, 53, 33, 17, 51, 2, 47, 186, 186, 186, 253, 209, 211, 211, 1, 93, 210, 4, 94, 187, 250, 231, 117, 2, 186, 117, 252, 209, 0, 2, 0, 4, 254, 117, 2, 233, 5, 25, 0, 3, 0, 22, 0, 62, 179, 0, 8, 1, 4, 43, 178, 15, 1, 0, 17, 18, 57, 176, 15, 47, 177, 20, 12, 244, 0, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 21, 62, 89, 176, 0, 69, 88, 176, 18, 47, 27, 177, 18, 19, 62, 89, 179, 10, 6, 4, 4, 43, 176, 18, 16, 177, 16, 6, 244, 48, 49, 1, 35, 53, 51, 1, 34, 39, 55, 22, 22, 51, 50, 62, 2, 53, 17, 35, 53, 33, 17, 20, 6, 2, 233, 186, 186, 254, 115, 246, 98, 105, 36, 117, 86, 68, 92, 53, 23, 211, 1, 92, 189, 4, 94, 187, 249, 92, 202, 72, 76, 82, 39, 72, 102, 66, 3, 47, 117, 252, 92, 180, 215, 0, 1, 0, 49, 0, 0, 3, 162, 5, 25, 0, 11, 0, 81, 179, 4, 12, 5, 4, 43, 176, 4, 16, 176, 7, 208, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 178, 8, 0, 6, 17, 18, 57, 178, 10, 0, 6, 17, 18, 57, 48, 49, 33, 35, 1, 7, 17, 35, 17, 51, 17, 1, 51, 1, 3, 162, 195, 254, 131, 168, 137, 137, 2, 19, 196, 254, 45, 1, 162, 154, 254, 248, 5, 25, 252, 149, 1, 246, 254, 84, 0, 0, 1, 0, 186, 0, 0, 2, 233, 5, 25, 0, 9, 0, 68, 179, 8, 14, 2, 4, 43, 176, 8, 16, 177, 3, 8, 244, 176, 2, 16, 176, 5, 208, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 177, 2, 6, 244, 176, 6, 16, 177, 4, 6, 244, 176, 2, 16, 176, 8, 208, 176, 9, 208, 48, 49, 33, 33, 53, 51, 17, 35, 53, 33, 17, 51, 2, 233, 253, 209, 211, 211, 1, 93, 210, 117, 4, 47, 117, 251, 92, 0, 0, 1, 0, 0, 0, 0, 3, 164, 3, 186, 0, 33, 0, 218, 176, 34, 47, 176, 21, 208, 176, 21, 47, 176, 10, 220, 178, 239, 10, 1, 93, 178, 64, 10, 1, 93, 176, 1, 220, 178, 239, 1, 1, 93, 178, 64, 1, 1, 93, 177, 0, 12, 244, 176, 10, 16, 177, 9, 8, 244, 176, 21, 16, 177, 20, 12, 244, 176, 23, 208, 178, 24, 21, 10, 17, 18, 57, 178, 28, 10, 1, 17, 18, 57, 176, 0, 16, 176, 35, 220, 0, 176, 0, 69, 88, 176, 22, 47, 27, 177, 22, 19, 62, 89, 176, 0, 69, 88, 176, 26, 47, 27, 177, 26, 19, 62, 89, 176, 0, 69, 88, 176, 30, 47, 27, 177, 30, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 15, 62, 89, 176, 0, 69, 88, 176, 20, 47, 27, 177, 20, 15, 62, 89, 176, 30, 16, 177, 5, 6, 244, 180, 217, 5, 233, 5, 2, 93, 64, 27, 8, 5, 24, 5, 40, 5, 56, 5, 72, 5, 88, 5, 104, 5, 120, 5, 136, 5, 152, 5, 168, 5, 184, 5, 200, 5, 13, 93, 176, 14, 208, 178, 24, 0, 26, 17, 18, 57, 178, 28, 0, 26, 17, 18, 57, 48, 49, 33, 35, 17, 52, 38, 35, 34, 6, 21, 17, 35, 17, 52, 38, 35, 34, 14, 2, 21, 17, 35, 17, 51, 21, 54, 51, 50, 23, 54, 51, 50, 22, 21, 3, 164, 137, 56, 53, 78, 73, 138, 57, 53, 49, 58, 33, 10, 137, 137, 43, 144, 137, 49, 68, 124, 119, 111, 2, 158, 80, 88, 164, 148, 253, 242, 2, 158, 80, 88, 58, 90, 110, 54, 253, 242, 3, 164, 135, 157, 137, 137, 141, 143, 0, 0, 1, 0, 49, 0, 0, 3, 115, 3, 186, 0, 19, 0, 142, 176, 20, 47, 176, 21, 47, 176, 0, 220, 177, 1, 8, 244, 176, 20, 16, 176, 12, 208, 176, 12, 47, 177, 11, 12, 244, 176, 14, 208, 178, 15, 12, 0, 17, 18, 57, 0, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 19, 62, 89, 176, 0, 69, 88, 176, 17, 47, 27, 177, 17, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 15, 62, 89, 176, 17, 16, 177, 5, 6, 244, 180, 217, 5, 233, 5, 2, 93, 64, 27, 8, 5, 24, 5, 40, 5, 56, 5, 72, 5, 88, 5, 104, 5, 120, 5, 136, 5, 152, 5, 168, 5, 184, 5, 200, 5, 13, 93, 178, 15, 0, 17, 17, 18, 57, 48, 49, 33, 35, 17, 52, 38, 35, 34, 14, 2, 21, 17, 35, 17, 51, 21, 18, 51, 32, 17, 3, 115, 138, 108, 121, 76, 123, 86, 45, 137, 137, 99, 254, 1, 88, 2, 63, 125, 138, 70, 117, 151, 82, 254, 94, 3, 164, 234, 1, 0, 254, 133, 0, 0, 2, 255, 236, 255, 233, 3, 188, 3, 186, 0, 19, 0, 39, 0, 226, 176, 40, 47, 176, 41, 47, 176, 0, 220, 176, 40, 16, 176, 10, 208, 176, 10, 47, 176, 0, 16, 177, 20, 12, 244, 180, 218, 20, 234, 20, 2, 93, 64, 27, 9, 20, 25, 20, 41, 20, 57, 20, 73, 20, 89, 20, 105, 20, 121, 20, 137, 20, 153, 20, 169, 20, 185, 20, 201, 20, 13, 93, 176, 10, 16, 177, 30, 12, 244, 64, 23, 6, 30, 22, 30, 38, 30, 54, 30, 70, 30, 86, 30, 102, 30, 118, 30, 134, 30, 150, 30, 166, 30, 11, 93, 180, 182, 30, 198, 30, 2, 93, 180, 213, 30, 229, 30, 2, 93, 0, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 19, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 176, 15, 16, 177, 25, 6, 244, 180, 217, 25, 233, 25, 2, 93, 64, 27, 8, 25, 24, 25, 40, 25, 56, 25, 72, 25, 88, 25, 104, 25, 120, 25, 136, 25, 152, 25, 168, 25, 184, 25, 200, 25, 13, 93, 176, 5, 16, 177, 35, 6, 244, 64, 27, 7, 35, 23, 35, 39, 35, 55, 35, 71, 35, 87, 35, 103, 35, 119, 35, 135, 35, 151, 35, 167, 35, 183, 35, 199, 35, 13, 93, 180, 214, 35, 230, 35, 2, 93, 48, 49, 1, 20, 14, 2, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 30, 2, 7, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 62, 2, 3, 188, 69, 129, 180, 111, 109, 180, 129, 69, 69, 129, 180, 109, 111, 180, 129, 69, 137, 47, 92, 131, 82, 82, 131, 90, 47, 47, 90, 131, 82, 82, 131, 92, 47, 1, 207, 109, 178, 127, 72, 72, 127, 178, 109, 106, 183, 129, 73, 73, 129, 183, 106, 80, 135, 102, 58, 58, 102, 135, 80, 80, 135, 98, 56, 56, 98, 135, 0, 2, 0, 49, 254, 139, 3, 164, 3, 186, 0, 19, 0, 36, 0, 236, 176, 37, 47, 176, 38, 47, 176, 0, 220, 176, 37, 16, 176, 10, 208, 176, 10, 47, 177, 9, 12, 244, 176, 12, 208, 178, 13, 10, 0, 17, 18, 57, 176, 0, 16, 177, 20, 12, 244, 180, 218, 20, 234, 20, 2, 93, 64, 27, 9, 20, 25, 20, 41, 20, 57, 20, 73, 20, 89, 20, 105, 20, 121, 20, 137, 20, 153, 20, 169, 20, 185, 20, 201, 20, 13, 93, 176, 9, 16, 176, 28, 208, 0, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 19, 62, 89, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 19, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 17, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 177, 32, 6, 244, 64, 27, 7, 32, 23, 32, 39, 32, 55, 32, 71, 32, 87, 32, 103, 32, 119, 32, 135, 32, 151, 32, 167, 32, 183, 32, 199, 32, 13, 93, 180, 214, 32, 230, 32, 2, 93, 178, 8, 5, 32, 17, 18, 57, 176, 15, 16, 177, 25, 6, 244, 180, 217, 25, 233, 25, 2, 93, 64, 27, 8, 25, 24, 25, 40, 25, 56, 25, 72, 25, 88, 25, 104, 25, 120, 25, 136, 25, 152, 25, 168, 25, 184, 25, 200, 25, 13, 93, 178, 13, 15, 25, 17, 18, 57, 48, 49, 1, 20, 14, 2, 35, 34, 38, 39, 17, 35, 17, 51, 21, 54, 51, 50, 30, 2, 7, 52, 46, 2, 35, 34, 6, 7, 17, 22, 22, 51, 50, 62, 2, 3, 164, 68, 123, 174, 108, 74, 139, 60, 137, 137, 127, 146, 108, 174, 123, 68, 137, 43, 86, 125, 82, 78, 135, 60, 60, 135, 78, 82, 125, 86, 43, 1, 209, 109, 178, 129, 72, 54, 53, 254, 55, 5, 25, 86, 108, 71, 131, 181, 106, 78, 137, 100, 58, 58, 65, 254, 12, 65, 56, 58, 100, 135, 0, 2, 0, 0, 254, 139, 3, 115, 3, 186, 0, 19, 0, 36, 0, 242, 176, 37, 47, 176, 38, 47, 176, 37, 16, 176, 0, 208, 176, 0, 47, 176, 38, 16, 176, 9, 220, 177, 8, 8, 244, 176, 11, 208, 178, 12, 0, 9, 17, 18, 57, 176, 0, 16, 177, 20, 12, 244, 64, 27, 6, 20, 22, 20, 38, 20, 54, 20, 70, 20, 86, 20, 102, 20, 118, 20, 134, 20, 150, 20, 166, 20, 182, 20, 198, 20, 13, 93, 180, 213, 20, 229, 20, 2, 93, 176, 8, 16, 176, 28, 208, 0, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 19, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 19, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 17, 62, 89, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 15, 62, 89, 176, 5, 16, 177, 32, 6, 244, 180, 217, 32, 233, 32, 2, 93, 64, 27, 8, 32, 24, 32, 40, 32, 56, 32, 72, 32, 88, 32, 104, 32, 120, 32, 136, 32, 152, 32, 168, 32, 184, 32, 200, 32, 13, 93, 178, 7, 5, 32, 17, 18, 57, 176, 15, 16, 177, 25, 6, 244, 64, 27, 7, 25, 23, 25, 39, 25, 55, 25, 71, 25, 87, 25, 103, 25, 119, 25, 135, 25, 151, 25, 167, 25, 183, 25, 199, 25, 13, 93, 180, 214, 25, 230, 25, 2, 93, 178, 12, 15, 25, 17, 18, 57, 48, 49, 17, 52, 62, 2, 51, 50, 23, 53, 51, 17, 35, 17, 6, 6, 35, 34, 46, 2, 55, 20, 30, 2, 51, 50, 54, 55, 17, 38, 38, 35, 34, 14, 2, 68, 122, 175, 108, 145, 127, 138, 138, 59, 139, 74, 108, 175, 122, 68, 137, 43, 86, 125, 82, 78, 135, 59, 59, 135, 78, 82, 125, 86, 43, 1, 209, 106, 181, 131, 71, 108, 86, 250, 231, 1, 201, 53, 54, 72, 129, 178, 109, 78, 135, 100, 58, 56, 65, 1, 244, 65, 58, 58, 100, 137, 0, 1, 0, 0, 0, 0, 3, 158, 3, 186, 0, 23, 0, 131, 179, 8, 14, 12, 4, 43, 176, 8, 16, 177, 13, 12, 244, 176, 12, 16, 176, 15, 208, 176, 8, 16, 176, 17, 208, 0, 176, 0, 69, 88, 176, 16, 47, 27, 177, 16, 19, 62, 89, 176, 0, 69, 88, 176, 20, 47, 27, 177, 20, 19, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 15, 62, 89, 176, 20, 16, 177, 2, 6, 244, 180, 217, 2, 233, 2, 2, 93, 64, 27, 8, 2, 24, 2, 40, 2, 56, 2, 72, 2, 88, 2, 104, 2, 120, 2, 136, 2, 152, 2, 168, 2, 184, 2, 200, 2, 13, 93, 176, 10, 16, 177, 8, 6, 244, 176, 12, 208, 176, 13, 208, 178, 18, 10, 20, 17, 18, 57, 48, 49, 1, 38, 35, 34, 14, 2, 21, 17, 51, 21, 33, 53, 51, 17, 35, 53, 33, 21, 18, 33, 50, 22, 23, 3, 113, 74, 102, 84, 132, 92, 49, 211, 253, 209, 211, 211, 1, 92, 94, 1, 7, 71, 105, 45, 3, 33, 37, 72, 117, 151, 80, 254, 211, 117, 117, 2, 186, 117, 234, 1, 0, 18, 23, 0, 1, 255, 246, 255, 233, 3, 139, 3, 186, 0, 50, 0, 223, 176, 51, 47, 176, 52, 47, 176, 0, 220, 177, 14, 12, 244, 180, 218, 14, 234, 14, 2, 93, 64, 27, 9, 14, 25, 14, 41, 14, 57, 14, 73, 14, 89, 14, 105, 14, 121, 14, 137, 14, 153, 14, 169, 14, 185, 14, 201, 14, 13, 93, 176, 51, 16, 176, 24, 208, 176, 24, 47, 177, 41, 12, 244, 64, 27, 6, 41, 22, 41, 38, 41, 54, 41, 70, 41, 86, 41, 102, 41, 118, 41, 134, 41, 150, 41, 166, 41, 182, 41, 198, 41, 13, 93, 180, 213, 41, 229, 41, 2, 93, 0, 176, 0, 69, 88, 176, 29, 47, 27, 177, 29, 19, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 179, 46, 5, 19, 4, 43, 176, 5, 16, 177, 12, 6, 244, 64, 27, 7, 12, 23, 12, 39, 12, 55, 12, 71, 12, 87, 12, 103, 12, 119, 12, 135, 12, 151, 12, 167, 12, 183, 12, 199, 12, 13, 93, 180, 214, 12, 230, 12, 2, 93, 176, 29, 16, 177, 36, 6, 244, 180, 217, 36, 233, 36, 2, 93, 64, 27, 8, 36, 24, 36, 40, 36, 56, 36, 72, 36, 88, 36, 104, 36, 120, 36, 136, 36, 152, 36, 168, 36, 184, 36, 200, 36, 13, 93, 48, 49, 1, 20, 14, 2, 35, 34, 38, 39, 55, 22, 22, 51, 32, 53, 52, 46, 2, 39, 46, 3, 53, 52, 62, 2, 51, 50, 22, 23, 7, 38, 38, 35, 34, 14, 2, 21, 20, 30, 2, 23, 30, 3, 3, 139, 82, 129, 159, 76, 127, 252, 92, 61, 103, 200, 107, 1, 53, 51, 86, 111, 61, 78, 154, 127, 77, 71, 119, 160, 86, 123, 194, 78, 55, 80, 164, 96, 43, 105, 90, 61, 51, 86, 111, 61, 76, 155, 127, 78, 1, 2, 82, 108, 64, 27, 74, 60, 118, 65, 70, 160, 39, 49, 31, 18, 8, 11, 30, 60, 100, 82, 70, 102, 68, 32, 57, 53, 107, 56, 45, 15, 37, 59, 45, 39, 47, 31, 18, 8, 11, 30, 58, 100, 0, 0, 1, 0, 0, 255, 233, 3, 174, 5, 25, 0, 27, 0, 133, 179, 19, 12, 8, 4, 43, 176, 8, 16, 176, 12, 208, 176, 19, 16, 176, 14, 208, 0, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 21, 62, 89, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 19, 62, 89, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 19, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 176, 15, 16, 177, 9, 6, 244, 176, 10, 208, 176, 17, 208, 176, 18, 208, 176, 3, 16, 177, 24, 6, 244, 64, 27, 7, 24, 23, 24, 39, 24, 55, 24, 71, 24, 87, 24, 103, 24, 119, 24, 135, 24, 151, 24, 167, 24, 183, 24, 199, 24, 13, 93, 180, 214, 24, 230, 24, 2, 93, 48, 49, 1, 6, 6, 35, 34, 46, 2, 53, 17, 35, 53, 51, 17, 51, 17, 33, 21, 33, 17, 20, 30, 2, 51, 50, 54, 55, 3, 174, 16, 199, 149, 82, 136, 96, 53, 211, 211, 137, 1, 141, 254, 115, 33, 59, 84, 54, 102, 137, 10, 1, 41, 147, 173, 54, 96, 135, 80, 1, 217, 117, 1, 117, 254, 139, 117, 254, 39, 51, 90, 68, 39, 127, 101, 0, 1, 0, 49, 255, 233, 3, 115, 3, 164, 0, 19, 0, 142, 176, 20, 47, 176, 21, 47, 176, 20, 16, 176, 0, 208, 176, 0, 47, 177, 1, 12, 244, 176, 21, 16, 176, 12, 220, 177, 11, 8, 244, 176, 14, 208, 178, 15, 0, 12, 17, 18, 57, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 19, 62, 89, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 19, 62, 89, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 15, 62, 89, 176, 0, 69, 88, 176, 17, 47, 27, 177, 17, 15, 62, 89, 177, 5, 6, 244, 64, 27, 7, 5, 23, 5, 39, 5, 55, 5, 71, 5, 87, 5, 103, 5, 119, 5, 135, 5, 151, 5, 167, 5, 183, 5, 199, 5, 13, 93, 180, 214, 5, 230, 5, 2, 93, 178, 15, 17, 0, 17, 18, 57, 48, 49, 19, 51, 17, 20, 22, 51, 50, 62, 2, 53, 17, 51, 17, 35, 53, 2, 35, 32, 17, 49, 137, 109, 121, 76, 122, 86, 45, 138, 138, 98, 254, 254, 168, 3, 164, 253, 192, 125, 137, 70, 117, 151, 82, 1, 162, 252, 92, 233, 255, 0, 1, 123, 0, 1, 255, 225, 0, 0, 3, 195, 3, 164, 0, 6, 0, 49, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 19, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 19, 62, 89, 176, 0, 69, 88, 176, 1, 47, 27, 177, 1, 15, 62, 89, 178, 5, 1, 0, 17, 18, 57, 48, 49, 1, 1, 35, 1, 51, 1, 1, 3, 195, 254, 108, 184, 254, 106, 164, 1, 78, 1, 76, 3, 164, 252, 92, 3, 164, 252, 207, 3, 49, 0, 1, 255, 229, 0, 0, 3, 195, 3, 164, 0, 12, 0, 89, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 19, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 19, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 19, 62, 89, 176, 0, 69, 88, 176, 1, 47, 27, 177, 1, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 178, 3, 1, 0, 17, 18, 57, 178, 8, 1, 0, 17, 18, 57, 178, 11, 1, 0, 17, 18, 57, 48, 49, 1, 3, 35, 3, 3, 35, 3, 51, 19, 19, 51, 19, 19, 3, 195, 189, 160, 149, 141, 160, 191, 146, 135, 145, 136, 149, 135, 3, 164, 252, 92, 2, 172, 253, 84, 3, 164, 253, 22, 2, 234, 253, 22, 2, 234, 0, 1, 255, 236, 0, 0, 3, 186, 3, 164, 0, 27, 0, 119, 0, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 19, 62, 89, 176, 0, 69, 88, 176, 21, 47, 27, 177, 21, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 15, 62, 89, 177, 2, 3, 244, 178, 4, 0, 14, 17, 18, 57, 176, 5, 208, 176, 6, 208, 176, 9, 208, 176, 10, 208, 176, 14, 16, 177, 12, 4, 244, 176, 16, 208, 176, 17, 208, 178, 18, 0, 14, 17, 18, 57, 176, 19, 208, 176, 20, 208, 176, 23, 208, 176, 24, 208, 176, 10, 16, 176, 26, 208, 176, 27, 208, 48, 49, 33, 33, 53, 51, 3, 3, 51, 21, 33, 53, 51, 1, 3, 35, 53, 33, 21, 35, 23, 55, 35, 53, 33, 21, 35, 3, 1, 51, 3, 186, 254, 127, 82, 184, 182, 75, 254, 132, 145, 1, 0, 246, 135, 1, 127, 86, 170, 172, 94, 1, 131, 131, 246, 1, 0, 143, 121, 1, 14, 254, 242, 121, 121, 1, 96, 1, 80, 123, 123, 254, 254, 123, 123, 254, 176, 254, 160, 0, 1, 255, 225, 254, 117, 3, 193, 3, 164, 0, 18, 0, 35, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 19, 62, 89, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 19, 62, 89, 179, 10, 6, 4, 4, 43, 48, 49, 1, 1, 6, 6, 35, 34, 39, 55, 22, 22, 51, 50, 54, 55, 55, 1, 51, 1, 1, 3, 193, 254, 8, 39, 142, 86, 96, 96, 27, 47, 90, 28, 68, 51, 19, 57, 254, 96, 162, 1, 80, 1, 74, 3, 164, 251, 112, 98, 61, 35, 118, 20, 17, 66, 45, 141, 3, 191, 252, 209, 3, 47, 0, 0, 1, 0, 47, 0, 0, 3, 119, 3, 164, 0, 13, 0, 88, 176, 14, 47, 176, 15, 47, 176, 0, 220, 176, 14, 16, 176, 6, 208, 176, 6, 47, 176, 1, 208, 176, 1, 47, 178, 3, 1, 0, 17, 18, 57, 176, 6, 16, 177, 5, 13, 244, 176, 0, 16, 177, 11, 13, 244, 0, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 7, 16, 177, 3, 6, 244, 176, 0, 16, 177, 10, 6, 244, 48, 49, 33, 33, 53, 1, 33, 17, 35, 17, 33, 21, 1, 33, 17, 51, 3, 119, 252, 184, 2, 123, 253, 252, 117, 3, 47, 253, 133, 2, 29, 117, 117, 2, 186, 255, 0, 1, 117, 117, 253, 70, 1, 0, 0, 1, 0, 186, 254, 139, 2, 231, 5, 211, 0, 38, 0, 70, 179, 35, 9, 6, 4, 43, 176, 6, 16, 176, 12, 208, 176, 6, 16, 177, 38, 14, 244, 176, 19, 208, 176, 35, 16, 176, 23, 208, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 17, 62, 89, 179, 19, 1, 20, 4, 43, 179, 10, 1, 9, 4, 43, 178, 29, 9, 10, 17, 18, 57, 176, 0, 16, 177, 37, 1, 244, 48, 49, 1, 35, 34, 46, 2, 53, 17, 52, 35, 53, 50, 53, 17, 52, 62, 2, 51, 51, 21, 35, 34, 21, 17, 20, 14, 2, 7, 30, 3, 21, 17, 20, 51, 51, 2, 231, 92, 61, 103, 73, 41, 187, 187, 41, 73, 103, 61, 92, 92, 170, 26, 45, 64, 37, 37, 62, 47, 26, 170, 92, 254, 139, 43, 74, 104, 62, 1, 168, 168, 112, 168, 1, 174, 62, 102, 74, 41, 111, 168, 254, 82, 34, 74, 64, 47, 6, 6, 45, 64, 73, 35, 254, 88, 170, 0, 1, 1, 141, 255, 70, 2, 23, 5, 211, 0, 3, 0, 15, 179, 0, 8, 1, 4, 43, 0, 176, 2, 47, 176, 0, 47, 48, 49, 5, 35, 17, 51, 2, 23, 138, 138, 186, 6, 141, 0, 1, 0, 186, 254, 139, 2, 231, 5, 211, 0, 38, 0, 70, 179, 3, 14, 10, 4, 43, 176, 3, 16, 177, 13, 9, 244, 176, 24, 208, 176, 10, 16, 176, 28, 208, 176, 3, 16, 176, 35, 208, 0, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 17, 62, 89, 179, 30, 1, 27, 4, 43, 179, 38, 1, 0, 4, 43, 176, 8, 16, 177, 10, 1, 244, 178, 19, 0, 38, 17, 18, 57, 48, 49, 1, 34, 21, 17, 20, 14, 2, 35, 35, 53, 51, 50, 53, 17, 52, 62, 2, 55, 46, 3, 53, 17, 52, 35, 35, 53, 51, 50, 30, 2, 21, 17, 20, 51, 2, 231, 184, 41, 76, 102, 61, 93, 93, 167, 27, 47, 64, 37, 37, 66, 45, 27, 167, 93, 93, 61, 102, 76, 41, 184, 1, 246, 168, 254, 86, 62, 102, 76, 41, 113, 168, 1, 170, 35, 75, 64, 43, 6, 8, 45, 64, 74, 34, 1, 174, 168, 111, 43, 74, 102, 60, 254, 82, 168, 0, 1, 255, 252, 0, 246, 3, 168, 2, 176, 0, 35, 0, 0, 1, 50, 62, 2, 55, 23, 14, 3, 35, 34, 46, 4, 35, 34, 14, 2, 7, 39, 62, 3, 51, 50, 30, 4, 2, 139, 37, 51, 33, 21, 8, 135, 6, 43, 70, 102, 64, 61, 84, 57, 43, 41, 50, 34, 37, 51, 33, 21, 8, 135, 6, 43, 70, 100, 66, 61, 84, 59, 43, 41, 47, 1, 117, 47, 82, 115, 65, 14, 90, 154, 112, 66, 47, 70, 80, 69, 47, 47, 82, 112, 66, 15, 88, 155, 113, 65, 47, 69, 82, 70, 47, 0, 255, 255, 255, 197, 0, 0, 3, 227, 6, 140, 2, 38, 0, 34, 0, 0, 0, 7, 0, 140, 0, 0, 1, 115, 0, 3, 255, 197, 0, 0, 3, 227, 6, 139, 0, 22, 0, 25, 0, 37, 0, 104, 179, 10, 10, 32, 4, 43, 180, 218, 32, 234, 32, 2, 93, 64, 27, 9, 32, 25, 32, 41, 32, 57, 32, 73, 32, 89, 32, 105, 32, 121, 32, 137, 32, 153, 32, 169, 32, 185, 32, 201, 32, 13, 93, 178, 23, 32, 10, 17, 18, 57, 0, 176, 0, 69, 88, 176, 29, 47, 27, 177, 29, 21, 62, 89, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 15, 62, 89, 176, 0, 69, 88, 176, 18, 47, 27, 177, 18, 15, 62, 89, 179, 5, 2, 35, 4, 43, 179, 23, 3, 16, 4, 43, 48, 49, 19, 52, 62, 2, 51, 50, 30, 2, 21, 20, 6, 7, 1, 35, 3, 33, 3, 35, 1, 38, 38, 1, 3, 3, 19, 20, 22, 51, 50, 54, 53, 52, 38, 35, 34, 6, 242, 34, 62, 82, 47, 47, 82, 61, 35, 63, 51, 1, 161, 147, 123, 253, 252, 121, 147, 1, 159, 51, 63, 1, 188, 219, 219, 84, 80, 55, 55, 80, 80, 55, 55, 80, 5, 170, 47, 82, 61, 35, 35, 61, 82, 47, 66, 102, 29, 251, 27, 1, 117, 254, 139, 4, 227, 29, 104, 252, 134, 2, 161, 253, 95, 3, 188, 55, 80, 80, 55, 55, 80, 80, 0, 1, 255, 236, 254, 141, 3, 172, 5, 47, 0, 46, 0, 234, 179, 39, 12, 17, 4, 43, 179, 4, 13, 11, 4, 43, 179, 27, 13, 26, 4, 43, 176, 26, 16, 176, 29, 208, 64, 27, 6, 39, 22, 39, 38, 39, 54, 39, 70, 39, 86, 39, 102, 39, 118, 39, 134, 39, 150, 39, 166, 39, 182, 39, 198, 39, 13, 93, 180, 213, 39, 229, 39, 2, 93, 176, 27, 16, 176, 48, 220, 0, 176, 0, 69, 88, 176, 26, 47, 27, 177, 26, 21, 62, 89, 176, 0, 69, 88, 176, 22, 47, 27, 177, 22, 21, 62, 89, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 17, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 176, 0, 69, 88, 176, 12, 47, 27, 177, 12, 15, 62, 89, 177, 9, 5, 244, 178, 25, 8, 22, 17, 18, 57, 176, 22, 16, 177, 34, 6, 244, 180, 217, 34, 233, 34, 2, 93, 64, 27, 8, 34, 24, 34, 40, 34, 56, 34, 72, 34, 88, 34, 104, 34, 120, 34, 136, 34, 152, 34, 168, 34, 184, 34, 200, 34, 13, 93, 176, 12, 16, 177, 44, 1, 244, 64, 27, 7, 44, 23, 44, 39, 44, 55, 44, 71, 44, 87, 44, 103, 44, 119, 44, 135, 44, 151, 44, 167, 44, 183, 44, 199, 44, 13, 93, 180, 214, 44, 230, 44, 2, 93, 48, 49, 1, 6, 6, 7, 21, 20, 7, 6, 35, 53, 50, 53, 53, 46, 3, 53, 52, 62, 2, 51, 50, 22, 23, 53, 51, 17, 35, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 19, 3, 172, 45, 193, 143, 82, 88, 147, 202, 127, 178, 110, 49, 53, 121, 190, 137, 121, 172, 41, 117, 117, 53, 90, 123, 68, 106, 139, 84, 35, 35, 84, 139, 106, 244, 96, 1, 86, 149, 189, 20, 25, 147, 88, 95, 117, 213, 21, 8, 116, 185, 235, 127, 131, 244, 188, 113, 86, 88, 152, 254, 84, 69, 123, 90, 51, 100, 162, 198, 99, 98, 199, 159, 101, 1, 39, 0, 255, 255, 0, 49, 0, 0, 3, 115, 6, 199, 2, 38, 0, 38, 0, 0, 0, 7, 0, 139, 0, 0, 1, 115, 255, 255, 0, 49, 0, 0, 3, 115, 6, 115, 2, 38, 0, 47, 0, 0, 0, 7, 0, 215, 0, 0, 1, 115, 255, 255, 255, 223, 255, 233, 3, 199, 6, 140, 2, 38, 0, 48, 0, 0, 0, 7, 0, 140, 0, 0, 1, 115, 255, 255, 0, 49, 255, 233, 3, 115, 6, 140, 2, 38, 0, 54, 0, 0, 0, 7, 0, 140, 0, 0, 1, 115, 255, 255, 0, 0, 255, 233, 3, 117, 5, 83, 2, 38, 0, 66, 2, 0, 0, 6, 0, 139, 0, 255, 255, 255, 0, 0, 255, 233, 3, 117, 5, 84, 2, 38, 0, 66, 2, 0, 0, 6, 0, 65, 0, 0, 255, 255, 0, 0, 255, 233, 3, 117, 5, 87, 2, 38, 0, 66, 2, 0, 0, 6, 0, 214, 0, 255, 255, 255, 0, 0, 255, 233, 3, 117, 5, 25, 2, 38, 0, 66, 2, 0, 0, 6, 0, 140, 0, 0, 255, 255, 0, 0, 255, 233, 3, 117, 4, 255, 2, 38, 0, 66, 2, 0, 0, 6, 0, 215, 0, 255, 255, 255, 0, 0, 255, 233, 3, 117, 5, 202, 2, 38, 0, 66, 2, 0, 0, 6, 0, 219, 0, 255, 0, 1, 0, 0, 254, 141, 3, 129, 3, 186, 0, 49, 0, 234, 179, 41, 12, 17, 4, 43, 179, 4, 13, 11, 4, 43, 179, 29, 11, 28, 4, 43, 176, 28, 16, 176, 31, 208, 64, 27, 6, 41, 22, 41, 38, 41, 54, 41, 70, 41, 86, 41, 102, 41, 118, 41, 134, 41, 150, 41, 166, 41, 182, 41, 198, 41, 13, 93, 180, 213, 41, 229, 41, 2, 93, 176, 29, 16, 176, 51, 220, 0, 176, 0, 69, 88, 176, 28, 47, 27, 177, 28, 19, 62, 89, 176, 0, 69, 88, 176, 22, 47, 27, 177, 22, 19, 62, 89, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 17, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 176, 0, 69, 88, 176, 12, 47, 27, 177, 12, 15, 62, 89, 177, 9, 5, 244, 178, 27, 8, 22, 17, 18, 57, 176, 22, 16, 177, 36, 6, 244, 180, 217, 36, 233, 36, 2, 93, 64, 27, 8, 36, 24, 36, 40, 36, 56, 36, 72, 36, 88, 36, 104, 36, 120, 36, 136, 36, 152, 36, 168, 36, 184, 36, 200, 36, 13, 93, 176, 12, 16, 177, 46, 1, 244, 64, 27, 7, 46, 23, 46, 39, 46, 55, 46, 71, 46, 87, 46, 103, 46, 119, 46, 135, 46, 151, 46, 167, 46, 183, 46, 199, 46, 13, 93, 180, 214, 46, 230, 46, 2, 93, 48, 49, 37, 6, 6, 7, 21, 20, 7, 6, 35, 53, 50, 53, 53, 46, 3, 53, 52, 62, 2, 51, 50, 30, 2, 23, 53, 51, 17, 35, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 54, 55, 3, 129, 53, 170, 115, 82, 88, 147, 202, 100, 164, 117, 63, 66, 122, 177, 108, 43, 90, 80, 64, 16, 123, 123, 45, 78, 108, 62, 84, 125, 84, 43, 49, 93, 131, 82, 104, 162, 43, 178, 82, 102, 12, 23, 147, 88, 95, 117, 213, 21, 8, 75, 127, 172, 103, 106, 181, 129, 73, 20, 41, 57, 39, 135, 254, 139, 62, 102, 74, 41, 58, 100, 135, 80, 80, 135, 98, 58, 82, 68, 0, 255, 255, 255, 252, 255, 233, 3, 174, 5, 83, 2, 38, 0, 70, 0, 0, 0, 6, 0, 139, 0, 255, 255, 255, 255, 252, 255, 233, 3, 174, 5, 84, 2, 38, 0, 70, 0, 0, 0, 6, 0, 65, 0, 0, 255, 255, 255, 252, 255, 233, 3, 174, 5, 87, 2, 38, 0, 70, 0, 0, 0, 6, 0, 214, 0, 255, 255, 255, 255, 252, 255, 233, 3, 174, 5, 25, 2, 38, 0, 70, 0, 0, 0, 6, 0, 140, 0, 0, 255, 255, 0, 186, 0, 0, 2, 233, 5, 83, 2, 38, 0, 213, 0, 0, 0, 6, 0, 139, 0, 255, 255, 255, 0, 186, 0, 0, 2, 233, 5, 84, 2, 38, 0, 213, 0, 0, 0, 6, 0, 65, 0, 0, 255, 255, 0, 170, 0, 0, 2, 252, 5, 87, 2, 38, 0, 213, 0, 0, 0, 6, 0, 214, 0, 255, 255, 255, 0, 186, 0, 0, 2, 233, 5, 25, 2, 38, 0, 213, 0, 0, 0, 6, 0, 140, 0, 0, 255, 255, 0, 49, 0, 0, 3, 115, 4, 255, 2, 38, 0, 79, 0, 0, 0, 6, 0, 215, 0, 255, 255, 255, 255, 236, 255, 233, 3, 188, 5, 83, 2, 38, 0, 80, 0, 0, 0, 6, 0, 139, 0, 255, 255, 255, 255, 236, 255, 233, 3, 188, 5, 84, 2, 38, 0, 80, 0, 0, 0, 6, 0, 65, 0, 0, 255, 255, 255, 236, 255, 233, 3, 188, 5, 87, 2, 38, 0, 80, 0, 0, 0, 6, 0, 214, 0, 255, 255, 255, 255, 236, 255, 233, 3, 188, 5, 25, 2, 38, 0, 80, 0, 0, 0, 6, 0, 140, 0, 0, 255, 255, 255, 236, 255, 233, 3, 188, 4, 255, 2, 38, 0, 80, 0, 0, 0, 6, 0, 215, 0, 255, 255, 255, 0, 49, 255, 233, 3, 115, 5, 84, 2, 38, 0, 86, 0, 0, 0, 6, 0, 139, 0, 0, 255, 255, 0, 49, 255, 233, 3, 115, 5, 86, 2, 38, 0, 86, 0, 0, 0, 6, 0, 65, 0, 2, 255, 255, 0, 49, 255, 233, 3, 115, 5, 88, 2, 38, 0, 86, 0, 0, 0, 6, 0, 214, 0, 0, 255, 255, 0, 49, 255, 233, 3, 115, 5, 25, 2, 38, 0, 86, 0, 0, 0, 6, 0, 140, 0, 0, 0, 1, 0, 186, 1, 117, 2, 233, 5, 25, 0, 11, 0, 19, 0, 176, 2, 47, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 21, 62, 89, 48, 49, 1, 39, 19, 35, 19, 7, 53, 23, 39, 51, 7, 55, 2, 233, 237, 12, 110, 14, 238, 238, 14, 110, 12, 237, 3, 201, 14, 253, 158, 2, 98, 14, 112, 14, 238, 238, 14, 0, 2, 0, 0, 2, 233, 2, 233, 5, 211, 0, 19, 0, 39, 0, 124, 176, 40, 47, 176, 41, 47, 176, 40, 16, 176, 0, 208, 176, 0, 47, 176, 41, 16, 176, 10, 220, 176, 0, 16, 177, 20, 10, 244, 64, 27, 6, 20, 22, 20, 38, 20, 54, 20, 70, 20, 86, 20, 102, 20, 118, 20, 134, 20, 150, 20, 166, 20, 182, 20, 198, 20, 13, 93, 180, 213, 20, 229, 20, 2, 93, 176, 10, 16, 177, 30, 10, 244, 180, 218, 30, 234, 30, 2, 93, 64, 27, 9, 30, 25, 30, 41, 30, 57, 30, 73, 30, 89, 30, 105, 30, 121, 30, 137, 30, 153, 30, 169, 30, 185, 30, 201, 30, 13, 93, 0, 179, 25, 2, 15, 4, 43, 179, 5, 2, 35, 4, 43, 48, 49, 17, 52, 62, 2, 51, 50, 30, 2, 21, 20, 14, 2, 35, 34, 46, 2, 55, 20, 30, 2, 51, 50, 62, 2, 53, 52, 46, 2, 35, 34, 14, 2, 59, 101, 135, 78, 76, 137, 100, 59, 59, 100, 137, 76, 78, 135, 101, 59, 92, 43, 78, 100, 60, 57, 102, 78, 43, 43, 78, 102, 57, 60, 100, 78, 43, 4, 94, 76, 137, 101, 59, 59, 101, 137, 76, 78, 135, 100, 60, 60, 100, 135, 78, 59, 101, 77, 43, 43, 77, 101, 59, 58, 102, 78, 43, 43, 78, 102, 0, 2, 0, 8, 0, 0, 3, 137, 5, 25, 0, 28, 0, 35, 0, 141, 176, 36, 47, 176, 37, 47, 176, 26, 220, 177, 0, 8, 244, 176, 36, 16, 176, 3, 208, 176, 3, 47, 176, 0, 16, 176, 8, 208, 176, 26, 16, 176, 10, 208, 176, 26, 16, 176, 18, 208, 176, 3, 16, 177, 29, 12, 244, 64, 27, 6, 29, 22, 29, 38, 29, 54, 29, 70, 29, 86, 29, 102, 29, 118, 29, 134, 29, 150, 29, 166, 29, 182, 29, 198, 29, 13, 93, 180, 213, 29, 229, 29, 2, 93, 176, 0, 16, 176, 32, 208, 0, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 21, 62, 89, 176, 0, 69, 88, 176, 27, 47, 27, 177, 27, 15, 62, 89, 179, 11, 6, 18, 4, 43, 176, 11, 16, 176, 8, 208, 176, 8, 47, 178, 32, 27, 9, 17, 18, 57, 48, 49, 37, 38, 2, 53, 52, 62, 2, 55, 53, 51, 21, 22, 22, 23, 7, 38, 38, 39, 17, 54, 54, 55, 23, 6, 6, 7, 21, 35, 3, 20, 22, 23, 17, 6, 6, 1, 141, 178, 211, 55, 103, 143, 88, 138, 127, 186, 57, 96, 41, 141, 92, 92, 141, 41, 96, 57, 186, 127, 138, 252, 131, 121, 121, 131, 170, 33, 1, 0, 192, 94, 162, 125, 82, 16, 175, 166, 6, 107, 86, 66, 62, 80, 6, 253, 25, 8, 78, 63, 66, 86, 106, 8, 162, 2, 139, 133, 194, 33, 2, 207, 31, 195, 0, 0, 1, 0, 49, 0, 0, 3, 211, 5, 47, 0, 44, 0, 129, 179, 20, 12, 1, 4, 43, 176, 20, 16, 176, 23, 208, 178, 27, 1, 20, 17, 18, 57, 176, 1, 16, 176, 42, 208, 0, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 21, 62, 89, 176, 0, 69, 88, 176, 34, 47, 27, 177, 34, 15, 62, 89, 179, 21, 6, 22, 4, 43, 176, 21, 16, 176, 0, 208, 176, 7, 16, 177, 16, 6, 244, 180, 217, 16, 233, 16, 2, 93, 64, 27, 8, 16, 24, 16, 40, 16, 56, 16, 72, 16, 88, 16, 104, 16, 120, 16, 136, 16, 152, 16, 168, 16, 184, 16, 200, 16, 13, 93, 176, 34, 16, 177, 27, 6, 244, 176, 36, 208, 176, 37, 208, 176, 22, 16, 176, 43, 208, 48, 49, 19, 51, 17, 52, 62, 2, 51, 50, 30, 2, 23, 7, 38, 38, 35, 34, 6, 21, 17, 51, 21, 35, 17, 20, 6, 7, 51, 32, 55, 23, 6, 4, 35, 33, 53, 51, 50, 62, 2, 53, 17, 35, 49, 187, 45, 84, 120, 78, 51, 95, 75, 56, 12, 125, 22, 82, 60, 98, 92, 186, 186, 51, 41, 206, 1, 15, 112, 109, 66, 254, 252, 166, 254, 74, 62, 34, 48, 30, 13, 187, 2, 199, 1, 8, 76, 131, 92, 53, 35, 63, 94, 60, 28, 90, 73, 123, 112, 254, 248, 117, 254, 242, 80, 105, 22, 223, 59, 142, 139, 117, 33, 49, 57, 23, 1, 59, 0, 0, 2, 0, 20, 255, 70, 3, 154, 6, 139, 0, 63, 0, 79, 0, 160, 176, 80, 47, 176, 81, 47, 176, 80, 16, 176, 0, 208, 176, 0, 47, 177, 64, 12, 244, 64, 27, 6, 64, 22, 64, 38, 64, 54, 64, 70, 64, 86, 64, 102, 64, 118, 64, 134, 64, 150, 64, 166, 64, 182, 64, 198, 64, 13, 93, 180, 213, 64, 229, 64, 2, 93, 176, 3, 208, 176, 3, 47, 176, 0, 16, 176, 6, 208, 176, 81, 16, 176, 32, 220, 176, 16, 208, 176, 16, 47, 176, 32, 16, 177, 72, 8, 244, 180, 218, 72, 234, 72, 2, 93, 64, 27, 9, 72, 25, 72, 41, 72, 57, 72, 73, 72, 89, 72, 105, 72, 121, 72, 137, 72, 153, 72, 169, 72, 185, 72, 201, 72, 13, 93, 176, 17, 208, 176, 64, 16, 176, 25, 208, 176, 32, 16, 176, 38, 208, 176, 72, 16, 176, 57, 208, 0, 179, 52, 6, 43, 4, 43, 179, 11, 6, 20, 4, 43, 48, 49, 19, 52, 54, 55, 38, 38, 53, 52, 62, 2, 51, 50, 30, 2, 23, 7, 38, 38, 35, 34, 14, 2, 21, 20, 30, 4, 21, 20, 6, 7, 22, 22, 21, 20, 14, 2, 35, 34, 46, 2, 39, 55, 22, 22, 51, 50, 62, 2, 53, 52, 46, 4, 55, 20, 30, 2, 23, 54, 54, 53, 52, 46, 2, 39, 6, 6, 68, 63, 72, 60, 75, 63, 109, 145, 82, 80, 149, 123, 82, 12, 129, 22, 160, 135, 45, 94, 76, 47, 106, 160, 184, 160, 107, 56, 59, 51, 64, 66, 113, 149, 82, 86, 158, 131, 96, 21, 127, 29, 186, 150, 55, 101, 73, 43, 106, 160, 184, 160, 106, 137, 94, 143, 172, 80, 41, 49, 84, 129, 159, 76, 70, 61, 3, 61, 76, 131, 54, 40, 121, 92, 80, 123, 84, 45, 43, 88, 133, 92, 21, 132, 129, 23, 51, 82, 60, 73, 90, 70, 66, 96, 145, 115, 72, 133, 53, 43, 123, 88, 80, 135, 94, 53, 43, 88, 137, 96, 33, 139, 142, 31, 59, 86, 58, 88, 108, 74, 62, 88, 135, 112, 73, 92, 66, 57, 39, 33, 88, 51, 78, 102, 72, 57, 33, 35, 94, 0, 0, 1, 0, 186, 0, 186, 3, 164, 3, 164, 0, 19, 0, 19, 0, 176, 15, 47, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 19, 62, 89, 48, 49, 19, 52, 62, 2, 51, 50, 30, 2, 21, 20, 14, 2, 35, 34, 46, 2, 186, 60, 100, 135, 78, 76, 137, 100, 60, 60, 100, 137, 76, 78, 135, 100, 60, 2, 47, 76, 137, 100, 60, 60, 100, 137, 76, 78, 135, 100, 60, 60, 100, 135, 0, 0, 3, 0, 31, 0, 0, 3, 139, 5, 25, 0, 11, 0, 15, 0, 21, 0, 146, 179, 19, 8, 8, 4, 43, 179, 4, 8, 5, 4, 43, 179, 0, 12, 1, 4, 43, 176, 1, 16, 176, 12, 208, 176, 4, 16, 176, 14, 208, 176, 5, 16, 176, 16, 208, 64, 27, 6, 19, 22, 19, 38, 19, 54, 19, 70, 19, 86, 19, 102, 19, 118, 19, 134, 19, 150, 19, 166, 19, 182, 19, 198, 19, 13, 93, 180, 213, 19, 229, 19, 2, 93, 0, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 179, 12, 4, 2, 4, 43, 176, 2, 16, 176, 6, 208, 176, 6, 47, 176, 10, 16, 177, 13, 6, 244, 176, 12, 16, 176, 21, 208, 176, 21, 47, 48, 49, 33, 35, 17, 35, 17, 35, 17, 36, 17, 16, 33, 33, 3, 17, 35, 17, 3, 6, 6, 21, 20, 23, 3, 139, 137, 235, 138, 254, 146, 1, 243, 1, 121, 137, 235, 138, 114, 113, 227, 2, 47, 253, 209, 2, 55, 39, 1, 70, 1, 117, 253, 145, 1, 250, 254, 6, 1, 240, 19, 125, 102, 201, 39, 0, 0, 1, 0, 49, 255, 233, 3, 164, 5, 47, 0, 59, 1, 6, 179, 36, 12, 37, 4, 43, 179, 53, 8, 22, 4, 43, 179, 48, 12, 27, 4, 43, 179, 0, 8, 15, 4, 43, 180, 218, 15, 234, 15, 2, 93, 64, 27, 9, 15, 25, 15, 41, 15, 57, 15, 73, 15, 89, 15, 105, 15, 121, 15, 137, 15, 153, 15, 169, 15, 185, 15, 201, 15, 13, 93, 180, 218, 27, 234, 27, 2, 93, 64, 27, 9, 27, 25, 27, 41, 27, 57, 27, 73, 27, 89, 27, 105, 27, 121, 27, 137, 27, 153, 27, 169, 27, 185, 27, 201, 27, 13, 93, 64, 27, 6, 53, 22, 53, 38, 53, 54, 53, 70, 53, 86, 53, 102, 53, 118, 53, 134, 53, 150, 53, 166, 53, 182, 53, 198, 53, 13, 93, 180, 213, 53, 229, 53, 2, 93, 0, 176, 0, 69, 88, 176, 43, 47, 27, 177, 43, 21, 62, 89, 176, 0, 69, 88, 176, 36, 47, 27, 177, 36, 15, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 177, 12, 6, 244, 64, 27, 7, 12, 23, 12, 39, 12, 55, 12, 71, 12, 87, 12, 103, 12, 119, 12, 135, 12, 151, 12, 167, 12, 183, 12, 199, 12, 13, 93, 180, 214, 12, 230, 12, 2, 93, 176, 43, 16, 177, 30, 6, 244, 180, 217, 30, 233, 30, 2, 93, 64, 27, 8, 30, 24, 30, 40, 30, 56, 30, 72, 30, 88, 30, 104, 30, 120, 30, 136, 30, 152, 30, 168, 30, 184, 30, 200, 30, 13, 93, 48, 49, 1, 20, 14, 2, 35, 34, 38, 39, 55, 22, 22, 51, 50, 54, 53, 52, 46, 4, 53, 52, 62, 2, 53, 52, 38, 35, 34, 14, 2, 21, 17, 35, 17, 52, 62, 2, 51, 50, 30, 2, 21, 20, 14, 2, 21, 20, 30, 4, 3, 164, 53, 95, 129, 75, 99, 143, 66, 78, 53, 109, 68, 92, 121, 60, 86, 104, 86, 60, 66, 80, 65, 82, 100, 74, 94, 53, 19, 137, 25, 80, 149, 123, 76, 119, 81, 43, 65, 80, 65, 59, 88, 102, 88, 60, 1, 12, 61, 107, 77, 46, 56, 53, 104, 49, 47, 86, 90, 56, 75, 56, 49, 57, 78, 57, 68, 76, 63, 74, 61, 70, 100, 59, 102, 131, 72, 252, 178, 3, 76, 76, 170, 143, 94, 45, 76, 104, 62, 82, 98, 65, 52, 34, 27, 43, 47, 57, 80, 111, 0, 4, 0, 0, 1, 117, 4, 94, 5, 211, 0, 19, 0, 39, 0, 55, 0, 64, 0, 189, 179, 30, 10, 10, 4, 43, 179, 44, 8, 45, 4, 43, 179, 52, 8, 56, 4, 43, 179, 0, 10, 20, 4, 43, 180, 218, 20, 234, 20, 2, 93, 64, 27, 9, 20, 25, 20, 41, 20, 57, 20, 73, 20, 89, 20, 105, 20, 121, 20, 137, 20, 153, 20, 169, 20, 185, 20, 201, 20, 13, 93, 64, 27, 6, 30, 22, 30, 38, 30, 54, 30, 70, 30, 86, 30, 102, 30, 118, 30, 134, 30, 150, 30, 166, 30, 182, 30, 198, 30, 13, 93, 180, 213, 30, 229, 30, 2, 93, 178, 40, 10, 0, 17, 18, 57, 178, 55, 10, 0, 17, 18, 57, 180, 218, 56, 234, 56, 2, 93, 64, 27, 9, 56, 25, 56, 41, 56, 57, 56, 73, 56, 89, 56, 105, 56, 121, 56, 137, 56, 153, 56, 169, 56, 185, 56, 201, 56, 13, 93, 176, 44, 16, 176, 60, 208, 0, 176, 0, 69, 88, 176, 61, 47, 27, 177, 61, 19, 62, 89, 179, 35, 2, 5, 4, 43, 179, 15, 2, 25, 4, 43, 179, 47, 1, 59, 4, 43, 48, 49, 1, 20, 14, 2, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 30, 2, 7, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 62, 2, 7, 35, 39, 35, 21, 35, 17, 33, 50, 30, 2, 21, 20, 6, 7, 55, 52, 38, 35, 35, 21, 51, 50, 54, 4, 94, 84, 147, 205, 121, 108, 203, 156, 94, 88, 152, 204, 117, 113, 200, 154, 90, 65, 76, 133, 180, 103, 102, 180, 136, 77, 77, 133, 181, 104, 101, 180, 133, 78, 187, 186, 174, 35, 143, 1, 12, 51, 94, 72, 41, 98, 94, 51, 58, 59, 125, 125, 55, 62, 3, 164, 111, 203, 153, 92, 80, 147, 205, 127, 115, 204, 152, 88, 84, 152, 204, 119, 100, 178, 136, 79, 75, 133, 181, 104, 105, 180, 133, 76, 76, 133, 180, 231, 242, 242, 2, 164, 27, 55, 80, 55, 80, 121, 10, 211, 45, 63, 215, 60, 0, 3, 0, 2, 0, 184, 4, 98, 5, 25, 0, 25, 0, 45, 0, 65, 0, 213, 179, 56, 10, 36, 4, 43, 179, 20, 8, 7, 4, 43, 179, 26, 10, 46, 4, 43, 64, 27, 6, 20, 22, 20, 38, 20, 54, 20, 70, 20, 86, 20, 102, 20, 118, 20, 134, 20, 150, 20, 166, 20, 182, 20, 198, 20, 13, 93, 180, 213, 20, 229, 20, 2, 93, 180, 218, 46, 234, 46, 2, 93, 64, 27, 9, 46, 25, 46, 41, 46, 57, 46, 73, 46, 89, 46, 105, 46, 121, 46, 137, 46, 153, 46, 169, 46, 185, 46, 201, 46, 13, 93, 64, 27, 6, 56, 22, 56, 38, 56, 54, 56, 70, 56, 86, 56, 102, 56, 118, 56, 134, 56, 150, 56, 166, 56, 182, 56, 198, 56, 13, 93, 180, 213, 56, 229, 56, 2, 93, 176, 26, 16, 176, 67, 220, 0, 176, 0, 69, 88, 176, 41, 47, 27, 177, 41, 21, 62, 89, 179, 61, 2, 31, 4, 43, 179, 23, 3, 2, 4, 43, 179, 12, 3, 17, 4, 43, 176, 41, 16, 177, 51, 2, 244, 180, 217, 51, 233, 51, 2, 93, 64, 27, 8, 51, 24, 51, 40, 51, 56, 51, 72, 51, 88, 51, 104, 51, 120, 51, 136, 51, 152, 51, 168, 51, 184, 51, 200, 51, 13, 93, 48, 49, 1, 6, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 23, 7, 38, 35, 34, 6, 21, 20, 22, 51, 50, 55, 37, 20, 14, 2, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 30, 2, 7, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 62, 2, 3, 98, 96, 205, 80, 133, 96, 53, 51, 94, 133, 84, 205, 96, 106, 55, 140, 102, 117, 113, 106, 140, 55, 1, 106, 84, 149, 205, 121, 108, 203, 156, 94, 88, 152, 204, 117, 113, 203, 153, 90, 65, 78, 133, 180, 103, 102, 180, 136, 77, 77, 134, 180, 104, 101, 180, 135, 78, 2, 18, 147, 53, 96, 134, 79, 76, 131, 99, 57, 147, 72, 100, 139, 105, 100, 143, 100, 141, 110, 203, 154, 92, 80, 148, 204, 127, 115, 205, 154, 88, 86, 150, 207, 119, 101, 180, 135, 80, 78, 133, 180, 105, 104, 180, 133, 76, 76, 133, 180, 0, 2, 0, 0, 2, 233, 4, 94, 5, 25, 0, 12, 0, 20, 0, 110, 179, 15, 9, 16, 4, 43, 179, 6, 9, 7, 4, 43, 179, 0, 9, 1, 4, 43, 178, 10, 16, 0, 17, 18, 57, 0, 176, 0, 47, 176, 6, 47, 176, 15, 47, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 21, 62, 89, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 21, 62, 89, 176, 0, 69, 88, 176, 19, 47, 27, 177, 19, 21, 62, 89, 178, 2, 0, 8, 17, 18, 57, 178, 5, 0, 8, 17, 18, 57, 178, 10, 0, 8, 17, 18, 57, 176, 8, 16, 177, 13, 1, 244, 176, 17, 208, 176, 18, 208, 48, 49, 1, 35, 17, 3, 35, 3, 17, 35, 17, 51, 19, 19, 51, 5, 35, 17, 35, 17, 35, 53, 33, 4, 94, 110, 129, 78, 129, 111, 158, 121, 121, 157, 253, 115, 176, 113, 176, 1, 209, 2, 233, 1, 138, 254, 178, 1, 78, 254, 118, 2, 48, 254, 184, 1, 72, 113, 254, 65, 1, 191, 113, 0, 0, 1, 0, 242, 3, 244, 2, 199, 5, 84, 0, 3, 0, 9, 0, 176, 1, 47, 176, 3, 47, 48, 49, 1, 5, 39, 1, 2, 199, 254, 80, 37, 1, 147, 4, 231, 243, 65, 1, 31, 0, 2, 0, 186, 4, 94, 2, 233, 5, 25, 0, 3, 0, 7, 0, 48, 179, 0, 8, 1, 4, 43, 0, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 21, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 2, 16, 177, 0, 5, 244, 176, 4, 208, 176, 5, 208, 48, 49, 1, 35, 53, 51, 5, 35, 53, 51, 2, 233, 186, 186, 254, 140, 187, 187, 4, 94, 187, 187, 187, 0, 0, 1, 0, 0, 0, 0, 3, 164, 3, 164, 0, 19, 0, 65, 0, 176, 0, 69, 88, 176, 12, 47, 27, 177, 12, 19, 62, 89, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 15, 62, 89, 179, 19, 1, 0, 4, 43, 179, 11, 1, 8, 4, 43, 176, 0, 16, 176, 4, 208, 176, 19, 16, 176, 6, 208, 176, 11, 16, 176, 14, 208, 176, 8, 16, 176, 16, 208, 48, 49, 37, 33, 7, 35, 55, 33, 53, 33, 19, 33, 53, 33, 55, 51, 7, 33, 21, 33, 3, 33, 3, 164, 253, 223, 90, 111, 90, 254, 236, 1, 74, 162, 254, 20, 2, 33, 90, 110, 90, 1, 21, 254, 182, 162, 1, 236, 187, 187, 187, 112, 1, 80, 111, 186, 186, 111, 254, 176, 0, 0, 2, 255, 193, 0, 0, 3, 164, 5, 25, 0, 15, 0, 18, 0, 86, 179, 14, 8, 1, 4, 43, 176, 14, 16, 176, 9, 208, 176, 1, 16, 176, 16, 208, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 179, 16, 3, 2, 4, 43, 179, 11, 3, 12, 4, 43, 176, 6, 16, 177, 8, 3, 244, 176, 0, 16, 177, 14, 4, 244, 48, 49, 33, 33, 17, 35, 3, 35, 1, 33, 21, 33, 17, 33, 21, 33, 17, 33, 1, 17, 3, 3, 164, 254, 6, 233, 111, 145, 1, 139, 2, 88, 254, 145, 1, 21, 254, 235, 1, 111, 254, 6, 197, 1, 117, 254, 139, 5, 25, 121, 254, 55, 121, 254, 29, 1, 115, 2, 147, 253, 109, 0, 0, 3, 255, 211, 255, 233, 3, 211, 5, 47, 0, 27, 0, 38, 0, 50, 1, 27, 176, 51, 47, 176, 52, 47, 176, 51, 16, 176, 4, 208, 176, 4, 47, 176, 0, 208, 176, 0, 47, 176, 52, 16, 176, 18, 220, 176, 13, 208, 176, 13, 47, 176, 18, 16, 177, 28, 8, 244, 180, 218, 28, 234, 28, 2, 93, 64, 27, 9, 28, 25, 28, 41, 28, 57, 28, 73, 28, 89, 28, 105, 28, 121, 28, 137, 28, 153, 28, 169, 28, 185, 28, 201, 28, 13, 93, 178, 30, 0, 13, 17, 18, 57, 176, 4, 16, 177, 39, 12, 244, 180, 182, 39, 198, 39, 2, 93, 64, 23, 6, 39, 22, 39, 38, 39, 54, 39, 70, 39, 86, 39, 102, 39, 118, 39, 134, 39, 150, 39, 166, 39, 11, 93, 180, 213, 39, 229, 39, 2, 93, 178, 42, 0, 13, 17, 18, 57, 0, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 21, 62, 89, 176, 0, 69, 88, 176, 23, 47, 27, 177, 23, 15, 62, 89, 176, 9, 16, 177, 46, 6, 244, 180, 217, 46, 233, 46, 2, 93, 64, 27, 8, 46, 24, 46, 40, 46, 56, 46, 72, 46, 88, 46, 104, 46, 120, 46, 136, 46, 152, 46, 168, 46, 184, 46, 200, 46, 13, 93, 178, 13, 9, 46, 17, 18, 57, 176, 23, 16, 177, 34, 6, 244, 64, 27, 7, 34, 23, 34, 39, 34, 55, 34, 71, 34, 87, 34, 103, 34, 119, 34, 135, 34, 151, 34, 167, 34, 183, 34, 199, 34, 13, 93, 180, 214, 34, 230, 34, 2, 93, 178, 27, 23, 34, 17, 18, 57, 178, 30, 23, 9, 17, 18, 57, 178, 42, 23, 9, 17, 18, 57, 48, 49, 39, 55, 38, 38, 53, 52, 62, 2, 51, 50, 22, 23, 55, 21, 7, 22, 22, 21, 20, 14, 2, 35, 34, 38, 39, 7, 1, 52, 39, 1, 22, 22, 51, 50, 62, 2, 37, 20, 22, 23, 1, 38, 38, 35, 34, 14, 2, 45, 78, 35, 31, 53, 121, 191, 135, 131, 186, 60, 135, 82, 35, 35, 54, 118, 191, 137, 135, 185, 59, 133, 3, 106, 34, 253, 153, 41, 139, 107, 106, 140, 84, 32, 253, 43, 15, 18, 2, 101, 48, 141, 94, 107, 139, 84, 33, 188, 84, 84, 191, 104, 131, 244, 188, 113, 106, 91, 146, 160, 86, 84, 190, 105, 131, 244, 186, 113, 103, 90, 141, 2, 110, 150, 121, 253, 114, 78, 96, 101, 159, 199, 98, 69, 138, 63, 2, 139, 86, 92, 100, 162, 198, 0, 3, 255, 248, 0, 220, 3, 182, 2, 197, 0, 31, 0, 41, 0, 51, 0, 82, 179, 47, 10, 16, 4, 43, 64, 27, 6, 47, 22, 47, 38, 47, 54, 47, 70, 47, 86, 47, 102, 47, 118, 47, 134, 47, 150, 47, 166, 47, 182, 47, 198, 47, 13, 93, 180, 213, 47, 229, 47, 2, 93, 0, 179, 39, 2, 5, 4, 43, 179, 27, 2, 35, 4, 43, 176, 5, 16, 176, 11, 208, 176, 27, 16, 176, 21, 208, 176, 35, 16, 176, 44, 208, 176, 39, 16, 176, 50, 208, 48, 49, 1, 20, 14, 2, 35, 34, 38, 39, 6, 6, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 22, 23, 54, 54, 51, 50, 30, 2, 7, 52, 38, 35, 34, 7, 22, 51, 50, 54, 37, 38, 35, 34, 6, 21, 20, 22, 51, 50, 3, 182, 35, 63, 88, 51, 72, 117, 53, 53, 111, 78, 49, 86, 65, 37, 37, 63, 86, 51, 78, 111, 53, 53, 117, 72, 49, 86, 65, 37, 90, 86, 59, 127, 74, 74, 127, 59, 84, 254, 82, 70, 131, 59, 86, 82, 63, 129, 1, 209, 51, 90, 66, 38, 67, 90, 88, 69, 38, 66, 90, 51, 51, 91, 65, 37, 70, 90, 90, 70, 37, 65, 91, 51, 72, 84, 156, 159, 94, 65, 156, 88, 68, 65, 94, 0, 0, 2, 0, 0, 255, 70, 3, 164, 3, 176, 0, 11, 0, 15, 0, 45, 179, 2, 9, 3, 4, 43, 176, 3, 16, 176, 7, 208, 176, 2, 16, 176, 9, 208, 0, 179, 15, 1, 12, 4, 43, 179, 11, 1, 0, 4, 43, 176, 0, 16, 176, 4, 208, 176, 11, 16, 176, 6, 208, 48, 49, 1, 33, 17, 35, 17, 33, 53, 33, 17, 51, 17, 33, 17, 33, 53, 33, 3, 164, 254, 102, 112, 254, 102, 1, 154, 112, 1, 154, 252, 92, 3, 164, 1, 166, 254, 90, 1, 166, 113, 1, 153, 254, 103, 253, 47, 113, 0, 0, 2, 0, 186, 255, 70, 3, 164, 3, 222, 0, 5, 0, 9, 0, 12, 0, 176, 3, 47, 179, 9, 1, 6, 4, 43, 48, 49, 37, 7, 1, 1, 23, 1, 1, 33, 53, 33, 3, 20, 77, 254, 0, 2, 0, 77, 254, 80, 2, 64, 253, 22, 2, 234, 45, 77, 1, 254, 2, 0, 78, 254, 78, 253, 104, 113, 0, 2, 0, 186, 255, 70, 3, 164, 3, 222, 0, 5, 0, 9, 0, 12, 0, 176, 5, 47, 179, 9, 1, 6, 4, 43, 48, 49, 1, 1, 39, 1, 1, 55, 1, 33, 53, 33, 3, 152, 254, 0, 78, 1, 176, 254, 80, 78, 2, 12, 253, 22, 2, 234, 1, 222, 254, 2, 77, 1, 177, 1, 178, 78, 251, 104, 113, 0, 0, 1, 0, 0, 0, 0, 3, 164, 5, 25, 0, 25, 0, 110, 179, 2, 12, 3, 4, 43, 176, 3, 16, 176, 7, 208, 178, 16, 3, 2, 17, 18, 57, 176, 2, 16, 176, 23, 208, 0, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 21, 62, 89, 176, 0, 69, 88, 176, 17, 47, 27, 177, 17, 21, 62, 89, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 15, 62, 89, 179, 25, 3, 0, 4, 43, 179, 12, 3, 9, 4, 43, 176, 0, 16, 176, 4, 208, 176, 25, 16, 176, 6, 208, 178, 16, 2, 13, 17, 18, 57, 176, 12, 16, 176, 19, 208, 176, 9, 16, 176, 21, 208, 48, 49, 1, 33, 17, 35, 17, 33, 53, 33, 53, 39, 33, 53, 51, 3, 51, 1, 51, 1, 51, 3, 51, 21, 33, 7, 21, 33, 3, 164, 254, 115, 136, 254, 113, 1, 143, 108, 254, 221, 229, 204, 153, 1, 33, 2, 1, 33, 153, 204, 225, 254, 225, 110, 1, 141, 1, 152, 254, 104, 1, 152, 120, 35, 215, 121, 1, 150, 253, 172, 2, 84, 254, 106, 121, 215, 35, 0, 0, 1, 0, 49, 254, 139, 3, 115, 3, 164, 0, 21, 0, 158, 176, 22, 47, 176, 23, 47, 176, 0, 220, 177, 1, 8, 244, 176, 22, 16, 176, 8, 208, 176, 8, 47, 177, 7, 12, 244, 176, 10, 208, 176, 1, 16, 176, 19, 208, 0, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 19, 62, 89, 176, 0, 69, 88, 176, 20, 47, 27, 177, 20, 19, 62, 89, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 17, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 178, 2, 7, 9, 17, 18, 57, 177, 14, 6, 244, 64, 27, 7, 14, 23, 14, 39, 14, 55, 14, 71, 14, 87, 14, 103, 14, 119, 14, 135, 14, 151, 14, 167, 14, 183, 14, 199, 14, 13, 93, 180, 214, 14, 230, 14, 2, 93, 178, 6, 4, 14, 17, 18, 57, 48, 49, 33, 35, 53, 2, 33, 34, 39, 17, 35, 17, 51, 17, 20, 22, 51, 50, 62, 2, 53, 17, 51, 3, 115, 138, 96, 255, 0, 123, 84, 137, 137, 109, 121, 76, 122, 86, 45, 138, 236, 254, 253, 56, 254, 106, 5, 25, 253, 194, 125, 139, 70, 117, 151, 82, 1, 162, 0, 2, 255, 236, 255, 233, 3, 182, 5, 47, 0, 21, 0, 37, 0, 190, 176, 38, 47, 176, 39, 47, 176, 38, 16, 176, 0, 208, 176, 0, 47, 176, 39, 16, 176, 14, 220, 178, 5, 0, 14, 17, 18, 57, 177, 22, 12, 244, 180, 218, 22, 234, 22, 2, 93, 64, 27, 9, 22, 25, 22, 41, 22, 57, 22, 73, 22, 89, 22, 105, 22, 121, 22, 137, 22, 153, 22, 169, 22, 185, 22, 201, 22, 13, 93, 176, 0, 16, 177, 30, 12, 244, 64, 27, 6, 30, 22, 30, 38, 30, 54, 30, 70, 30, 86, 30, 102, 30, 118, 30, 134, 30, 150, 30, 166, 30, 182, 30, 198, 30, 13, 93, 180, 213, 30, 229, 30, 2, 93, 0, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 21, 62, 89, 176, 0, 69, 88, 176, 19, 47, 27, 177, 19, 15, 62, 89, 178, 5, 19, 9, 17, 18, 57, 177, 33, 6, 244, 64, 27, 7, 33, 23, 33, 39, 33, 55, 33, 71, 33, 87, 33, 103, 33, 119, 33, 135, 33, 151, 33, 167, 33, 183, 33, 199, 33, 13, 93, 180, 214, 33, 230, 33, 2, 93, 48, 49, 3, 52, 54, 54, 36, 55, 38, 36, 39, 55, 30, 3, 21, 20, 14, 2, 35, 34, 38, 1, 52, 38, 39, 14, 3, 21, 20, 22, 51, 50, 62, 2, 20, 116, 203, 1, 16, 156, 78, 254, 248, 166, 45, 135, 250, 189, 112, 71, 136, 192, 121, 205, 245, 3, 65, 16, 17, 145, 244, 176, 98, 168, 145, 92, 142, 98, 51, 1, 98, 105, 162, 122, 84, 25, 125, 174, 59, 117, 53, 137, 189, 248, 163, 129, 207, 146, 78, 193, 1, 111, 55, 100, 47, 16, 70, 98, 125, 76, 116, 144, 64, 116, 164, 0, 0, 1, 0, 43, 0, 0, 3, 115, 5, 25, 0, 15, 0, 67, 179, 7, 11, 8, 4, 43, 176, 7, 16, 176, 0, 208, 176, 8, 16, 176, 13, 208, 176, 7, 16, 176, 17, 220, 0, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 5, 16, 177, 9, 6, 244, 176, 0, 16, 177, 12, 6, 244, 48, 49, 33, 33, 53, 1, 1, 53, 33, 17, 35, 17, 33, 1, 1, 33, 17, 51, 3, 115, 252, 184, 1, 72, 254, 184, 3, 72, 121, 253, 213, 1, 69, 254, 187, 2, 43, 121, 117, 2, 24, 2, 23, 117, 254, 71, 1, 68, 253, 233, 253, 232, 1, 69, 0, 0, 1, 0, 0, 0, 0, 3, 164, 5, 25, 0, 11, 0, 87, 176, 12, 47, 176, 13, 47, 176, 2, 220, 177, 3, 12, 244, 176, 12, 16, 176, 7, 208, 176, 7, 47, 177, 6, 8, 244, 0, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 21, 62, 89, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 15, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 176, 10, 16, 177, 0, 6, 244, 176, 4, 208, 176, 5, 208, 176, 8, 208, 176, 9, 208, 48, 49, 1, 35, 17, 35, 17, 33, 17, 35, 17, 35, 53, 33, 3, 164, 187, 137, 254, 228, 138, 186, 3, 164, 4, 164, 251, 92, 4, 164, 251, 92, 4, 164, 117, 0, 1, 0, 0, 255, 233, 3, 178, 3, 164, 0, 27, 0, 148, 176, 28, 47, 176, 29, 47, 176, 0, 220, 177, 14, 12, 244, 176, 28, 16, 176, 22, 208, 176, 22, 47, 177, 16, 12, 244, 0, 176, 0, 69, 88, 176, 24, 47, 27, 177, 24, 19, 62, 89, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 15, 62, 89, 176, 0, 69, 88, 176, 18, 47, 27, 177, 18, 15, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 15, 62, 89, 177, 3, 3, 244, 64, 27, 7, 3, 23, 3, 39, 3, 55, 3, 71, 3, 87, 3, 103, 3, 119, 3, 135, 3, 151, 3, 167, 3, 183, 3, 199, 3, 13, 93, 180, 214, 3, 230, 3, 2, 93, 178, 6, 9, 24, 17, 18, 57, 176, 24, 16, 177, 15, 4, 244, 176, 22, 208, 176, 23, 208, 176, 26, 208, 176, 27, 208, 48, 49, 37, 20, 22, 51, 50, 54, 55, 23, 6, 35, 34, 46, 2, 53, 17, 35, 16, 3, 35, 54, 18, 53, 35, 53, 33, 21, 35, 2, 209, 70, 51, 28, 35, 15, 26, 41, 82, 45, 86, 67, 41, 236, 43, 139, 22, 23, 211, 3, 164, 211, 207, 53, 56, 8, 9, 113, 25, 31, 58, 86, 55, 2, 90, 254, 115, 254, 100, 201, 1, 147, 205, 123, 123, 0, 0, 1, 0, 4, 254, 117, 3, 164, 6, 162, 0, 25, 0, 39, 179, 7, 8, 19, 4, 43, 0, 179, 16, 6, 9, 4, 43, 179, 22, 6, 3, 4, 43, 176, 9, 16, 176, 12, 208, 176, 12, 47, 176, 22, 16, 176, 25, 208, 176, 25, 47, 48, 49, 1, 38, 38, 35, 34, 6, 21, 17, 16, 33, 34, 38, 39, 53, 22, 22, 51, 50, 54, 53, 17, 16, 33, 50, 22, 23, 3, 164, 29, 63, 41, 129, 135, 254, 114, 31, 67, 35, 29, 59, 45, 127, 133, 1, 146, 30, 68, 35, 6, 39, 4, 2, 121, 143, 250, 203, 254, 133, 4, 4, 115, 4, 3, 121, 142, 5, 53, 1, 125, 6, 4, 0, 3, 255, 248, 1, 0, 2, 188, 5, 43, 0, 37, 0, 52, 0, 56, 0, 196, 176, 57, 47, 176, 58, 47, 176, 57, 16, 176, 0, 208, 176, 0, 47, 176, 58, 16, 176, 28, 220, 177, 11, 8, 244, 176, 30, 208, 178, 31, 0, 28, 17, 18, 57, 176, 11, 16, 176, 43, 208, 176, 0, 16, 177, 50, 8, 244, 64, 27, 6, 50, 22, 50, 38, 50, 54, 50, 70, 50, 86, 50, 102, 50, 118, 50, 134, 50, 150, 50, 166, 50, 182, 50, 198, 50, 13, 93, 180, 213, 50, 229, 50, 2, 93, 176, 28, 16, 176, 53, 208, 176, 0, 16, 176, 54, 208, 176, 54, 47, 0, 176, 0, 69, 88, 176, 23, 47, 27, 177, 23, 21, 62, 89, 179, 56, 6, 53, 4, 43, 179, 38, 6, 33, 4, 43, 179, 5, 1, 47, 4, 43, 176, 5, 16, 176, 10, 208, 176, 10, 47, 176, 23, 16, 177, 16, 6, 244, 180, 217, 16, 233, 16, 2, 93, 64, 27, 8, 16, 24, 16, 40, 16, 56, 16, 72, 16, 88, 16, 104, 16, 120, 16, 136, 16, 152, 16, 168, 16, 184, 16, 200, 16, 13, 93, 176, 47, 16, 176, 44, 208, 176, 44, 47, 48, 49, 3, 52, 62, 2, 51, 50, 50, 22, 22, 23, 53, 52, 46, 2, 35, 34, 6, 7, 39, 54, 54, 51, 50, 30, 2, 21, 17, 35, 53, 6, 35, 34, 46, 2, 5, 50, 62, 2, 53, 53, 38, 38, 35, 34, 6, 21, 20, 22, 1, 33, 53, 33, 8, 69, 117, 146, 77, 31, 37, 31, 32, 27, 39, 55, 66, 26, 86, 133, 64, 55, 61, 162, 115, 61, 117, 92, 57, 141, 117, 168, 61, 102, 76, 43, 1, 26, 68, 107, 71, 39, 53, 68, 37, 118, 150, 72, 1, 239, 253, 68, 2, 188, 2, 248, 69, 99, 61, 27, 4, 4, 4, 75, 37, 49, 29, 12, 35, 45, 109, 41, 47, 27, 59, 92, 66, 253, 248, 111, 129, 28, 58, 80, 50, 33, 47, 54, 22, 80, 8, 2, 67, 76, 45, 58, 254, 111, 117, 0, 0, 3, 255, 238, 1, 0, 2, 254, 5, 45, 0, 19, 0, 37, 0, 41, 0, 178, 176, 42, 47, 176, 43, 47, 176, 0, 220, 176, 42, 16, 176, 10, 208, 176, 10, 47, 176, 0, 16, 177, 20, 12, 244, 180, 218, 20, 234, 20, 2, 93, 64, 27, 9, 20, 25, 20, 41, 20, 57, 20, 73, 20, 89, 20, 105, 20, 121, 20, 137, 20, 153, 20, 169, 20, 185, 20, 201, 20, 13, 93, 176, 10, 16, 177, 30, 12, 244, 64, 27, 6, 30, 22, 30, 38, 30, 54, 30, 70, 30, 86, 30, 102, 30, 118, 30, 134, 30, 150, 30, 166, 30, 182, 30, 198, 30, 13, 93, 180, 213, 30, 229, 30, 2, 93, 0, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 21, 62, 89, 179, 41, 6, 38, 4, 43, 179, 33, 6, 5, 4, 43, 176, 15, 16, 177, 25, 6, 244, 180, 217, 25, 233, 25, 2, 93, 64, 27, 8, 25, 24, 25, 40, 25, 56, 25, 72, 25, 88, 25, 104, 25, 120, 25, 136, 25, 152, 25, 168, 25, 184, 25, 200, 25, 13, 93, 48, 49, 1, 20, 14, 2, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 30, 2, 7, 52, 46, 2, 35, 34, 14, 2, 21, 20, 22, 51, 50, 62, 2, 19, 33, 53, 33, 2, 254, 61, 105, 145, 82, 84, 142, 106, 59, 59, 106, 142, 84, 82, 145, 105, 61, 137, 41, 70, 92, 53, 54, 92, 69, 39, 143, 111, 55, 92, 70, 39, 116, 253, 23, 2, 233, 3, 164, 86, 146, 102, 57, 55, 102, 144, 90, 88, 145, 105, 55, 55, 105, 145, 88, 61, 103, 73, 39, 39, 73, 103, 61, 125, 150, 39, 72, 102, 253, 154, 117, 0, 0, 1, 255, 236, 0, 0, 3, 188, 5, 47, 0, 45, 0, 199, 179, 23, 12, 36, 4, 43, 179, 0, 12, 13, 4, 43, 180, 218, 13, 234, 13, 2, 93, 64, 27, 9, 13, 25, 13, 41, 13, 57, 13, 73, 13, 89, 13, 105, 13, 121, 13, 137, 13, 153, 13, 169, 13, 185, 13, 201, 13, 13, 93, 64, 15, 102, 23, 118, 23, 134, 23, 150, 23, 166, 23, 182, 23, 198, 23, 7, 93, 64, 13, 6, 23, 22, 23, 38, 23, 54, 23, 70, 23, 86, 23, 6, 93, 180, 213, 23, 229, 23, 2, 93, 176, 36, 16, 177, 28, 14, 244, 0, 176, 0, 69, 88, 176, 41, 47, 27, 177, 41, 21, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 176, 0, 69, 88, 176, 29, 47, 27, 177, 29, 15, 62, 89, 176, 6, 16, 177, 4, 6, 244, 176, 41, 16, 177, 18, 1, 244, 180, 217, 18, 233, 18, 2, 93, 64, 27, 8, 18, 24, 18, 40, 18, 56, 18, 72, 18, 88, 18, 104, 18, 120, 18, 136, 18, 152, 18, 168, 18, 184, 18, 200, 18, 13, 93, 176, 4, 16, 176, 31, 208, 176, 32, 208, 48, 49, 1, 20, 2, 7, 21, 51, 21, 33, 17, 62, 3, 53, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 23, 17, 33, 53, 51, 53, 38, 2, 53, 52, 62, 2, 51, 50, 30, 2, 3, 188, 110, 125, 211, 254, 164, 67, 90, 56, 22, 39, 86, 133, 94, 90, 133, 86, 41, 22, 54, 88, 67, 254, 164, 211, 121, 110, 63, 123, 182, 119, 119, 182, 125, 63, 2, 229, 145, 254, 240, 93, 114, 117, 1, 35, 26, 103, 123, 135, 63, 82, 168, 137, 86, 86, 137, 168, 82, 63, 135, 123, 103, 26, 254, 221, 117, 114, 86, 1, 19, 149, 113, 213, 162, 98, 98, 162, 213, 0, 0, 3, 255, 219, 255, 233, 3, 186, 3, 186, 0, 53, 0, 60, 0, 75, 1, 27, 176, 76, 47, 176, 77, 47, 176, 60, 220, 177, 16, 12, 244, 178, 0, 60, 16, 17, 18, 57, 176, 76, 16, 176, 8, 208, 176, 8, 47, 178, 32, 60, 16, 17, 18, 57, 176, 60, 16, 176, 41, 208, 176, 16, 16, 176, 61, 208, 176, 8, 16, 177, 67, 12, 244, 64, 27, 6, 67, 22, 67, 38, 67, 54, 67, 70, 67, 86, 67, 102, 67, 118, 67, 134, 67, 150, 67, 166, 67, 182, 67, 198, 67, 13, 93, 180, 213, 67, 229, 67, 2, 93, 0, 176, 0, 69, 88, 176, 29, 47, 27, 177, 29, 19, 62, 89, 176, 0, 69, 88, 176, 35, 47, 27, 177, 35, 19, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 176, 0, 69, 88, 176, 51, 47, 27, 177, 51, 15, 62, 89, 179, 13, 5, 41, 4, 43, 178, 0, 5, 29, 17, 18, 57, 176, 13, 16, 176, 16, 208, 176, 16, 47, 176, 29, 16, 177, 20, 1, 244, 180, 217, 20, 233, 20, 2, 93, 64, 27, 8, 20, 24, 20, 40, 20, 56, 20, 72, 20, 88, 20, 104, 20, 120, 20, 136, 20, 152, 20, 168, 20, 184, 20, 200, 20, 13, 93, 178, 32, 5, 29, 17, 18, 57, 176, 51, 16, 177, 44, 4, 244, 64, 27, 7, 44, 23, 44, 39, 44, 55, 44, 71, 44, 87, 44, 103, 44, 119, 44, 135, 44, 151, 44, 167, 44, 183, 44, 199, 44, 13, 93, 180, 214, 44, 230, 44, 2, 93, 176, 20, 16, 176, 57, 208, 176, 13, 16, 177, 64, 6, 244, 176, 44, 16, 176, 70, 208, 48, 49, 37, 14, 3, 35, 34, 38, 53, 52, 62, 2, 51, 50, 22, 23, 53, 52, 38, 35, 34, 6, 7, 39, 62, 3, 51, 50, 22, 23, 54, 54, 51, 50, 30, 2, 21, 33, 20, 22, 51, 50, 54, 55, 23, 6, 6, 35, 34, 38, 1, 52, 38, 35, 34, 6, 21, 7, 38, 38, 35, 34, 6, 21, 20, 22, 51, 50, 62, 2, 53, 1, 193, 13, 43, 61, 78, 49, 117, 125, 57, 93, 120, 64, 22, 48, 22, 70, 71, 41, 94, 35, 86, 26, 70, 70, 65, 25, 78, 112, 23, 28, 132, 69, 92, 107, 51, 14, 254, 84, 78, 78, 47, 72, 18, 117, 35, 125, 102, 76, 127, 1, 80, 64, 71, 66, 80, 137, 12, 45, 23, 86, 123, 60, 59, 33, 61, 47, 29, 170, 35, 67, 56, 35, 158, 119, 80, 117, 73, 35, 2, 4, 96, 76, 115, 72, 59, 84, 43, 61, 39, 18, 69, 78, 78, 69, 112, 164, 186, 74, 166, 148, 58, 65, 37, 108, 105, 101, 1, 205, 163, 138, 133, 168, 101, 2, 2, 96, 102, 54, 86, 31, 53, 72, 41, 0, 3, 255, 213, 255, 233, 3, 209, 3, 186, 0, 25, 0, 36, 0, 47, 0, 252, 176, 48, 47, 176, 49, 47, 176, 48, 16, 176, 3, 208, 176, 3, 47, 176, 49, 16, 176, 16, 220, 177, 26, 12, 244, 180, 218, 26, 234, 26, 2, 93, 64, 27, 9, 26, 25, 26, 41, 26, 57, 26, 73, 26, 89, 26, 105, 26, 121, 26, 137, 26, 153, 26, 169, 26, 185, 26, 201, 26, 13, 93, 176, 11, 208, 176, 11, 47, 176, 3, 16, 177, 37, 12, 244, 64, 23, 6, 37, 22, 37, 38, 37, 54, 37, 70, 37, 86, 37, 102, 37, 118, 37, 134, 37, 150, 37, 166, 37, 11, 93, 180, 182, 37, 198, 37, 2, 93, 180, 213, 37, 229, 37, 2, 93, 176, 24, 208, 176, 24, 47, 0, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 19, 62, 89, 176, 0, 69, 88, 176, 21, 47, 27, 177, 21, 15, 62, 89, 176, 8, 16, 177, 43, 6, 244, 180, 217, 43, 233, 43, 2, 93, 64, 27, 8, 43, 24, 43, 40, 43, 56, 43, 72, 43, 88, 43, 104, 43, 120, 43, 136, 43, 152, 43, 168, 43, 184, 43, 200, 43, 13, 93, 178, 12, 8, 43, 17, 18, 57, 176, 21, 16, 177, 32, 6, 244, 64, 27, 7, 32, 23, 32, 39, 32, 55, 32, 71, 32, 87, 32, 103, 32, 119, 32, 135, 32, 151, 32, 167, 32, 183, 32, 199, 32, 13, 93, 180, 214, 32, 230, 32, 2, 93, 178, 25, 21, 32, 17, 18, 57, 48, 49, 39, 55, 38, 53, 52, 62, 2, 51, 50, 22, 23, 55, 21, 7, 22, 21, 20, 14, 2, 35, 34, 38, 39, 7, 1, 52, 39, 1, 22, 22, 51, 50, 62, 2, 37, 20, 23, 1, 38, 38, 35, 34, 14, 2, 43, 92, 69, 69, 129, 180, 109, 113, 180, 65, 152, 94, 73, 69, 129, 180, 111, 113, 182, 66, 149, 3, 94, 43, 253, 201, 47, 127, 84, 82, 131, 92, 47, 253, 66, 39, 2, 57, 47, 129, 82, 82, 131, 90, 47, 119, 74, 116, 154, 106, 183, 129, 73, 75, 68, 121, 119, 76, 121, 153, 109, 178, 127, 72, 74, 68, 119, 1, 207, 106, 84, 254, 60, 49, 58, 56, 98, 135, 80, 107, 77, 1, 196, 49, 58, 58, 102, 135, 0, 2, 0, 209, 255, 233, 3, 182, 5, 25, 0, 3, 0, 31, 0, 148, 179, 19, 8, 4, 4, 43, 179, 12, 8, 3, 4, 43, 176, 12, 16, 176, 1, 208, 176, 1, 47, 176, 12, 16, 177, 11, 8, 244, 64, 27, 6, 19, 22, 19, 38, 19, 54, 19, 70, 19, 86, 19, 102, 19, 118, 19, 134, 19, 150, 19, 166, 19, 182, 19, 198, 19, 13, 93, 180, 213, 19, 229, 19, 2, 93, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 21, 62, 89, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 19, 62, 89, 176, 0, 69, 88, 176, 29, 47, 27, 177, 29, 15, 62, 89, 177, 22, 6, 244, 64, 27, 7, 22, 23, 22, 39, 22, 55, 22, 71, 22, 87, 22, 103, 22, 119, 22, 135, 22, 151, 22, 167, 22, 183, 22, 199, 22, 13, 93, 180, 214, 22, 230, 22, 2, 93, 48, 49, 1, 51, 21, 35, 1, 52, 62, 4, 53, 51, 20, 14, 4, 21, 20, 22, 51, 50, 54, 55, 23, 6, 6, 35, 34, 38, 2, 47, 186, 186, 254, 162, 57, 86, 103, 86, 57, 145, 59, 86, 104, 86, 60, 109, 102, 127, 127, 14, 123, 18, 195, 176, 166, 186, 5, 25, 187, 252, 189, 77, 117, 98, 87, 92, 108, 70, 78, 123, 106, 95, 92, 98, 57, 88, 101, 150, 114, 18, 168, 195, 170, 0, 0, 2, 2, 47, 0, 0, 2, 233, 5, 25, 0, 3, 0, 7, 0, 63, 179, 5, 8, 4, 4, 43, 176, 4, 16, 176, 0, 208, 176, 0, 47, 176, 5, 16, 176, 3, 208, 0, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 21, 62, 89, 176, 0, 69, 88, 176, 1, 47, 27, 177, 1, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 48, 49, 33, 19, 51, 19, 3, 51, 21, 35, 2, 49, 51, 82, 51, 186, 186, 186, 3, 170, 252, 86, 5, 25, 187, 0, 1, 0, 0, 0, 0, 3, 164, 2, 47, 0, 5, 0, 15, 179, 0, 9, 1, 4, 43, 0, 179, 5, 1, 2, 4, 43, 48, 49, 33, 35, 17, 33, 53, 33, 3, 164, 113, 252, 205, 3, 164, 1, 191, 112, 0, 0, 1, 0, 23, 0, 0, 3, 164, 4, 94, 0, 8, 0, 22, 0, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 15, 62, 89, 179, 8, 1, 0, 4, 43, 48, 49, 1, 33, 1, 35, 3, 55, 19, 1, 33, 3, 164, 254, 227, 254, 211, 104, 219, 106, 166, 1, 14, 1, 111, 3, 240, 252, 16, 2, 213, 33, 253, 174, 3, 186, 0, 1, 0, 4, 254, 117, 3, 164, 5, 43, 0, 32, 0, 151, 179, 3, 8, 15, 4, 43, 176, 15, 16, 176, 19, 208, 176, 3, 16, 176, 32, 208, 0, 176, 0, 69, 88, 176, 22, 47, 27, 177, 22, 21, 62, 89, 176, 0, 69, 88, 176, 25, 47, 27, 177, 25, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 19, 62, 89, 176, 0, 69, 88, 176, 18, 47, 27, 177, 18, 19, 62, 89, 179, 12, 6, 5, 4, 43, 176, 0, 16, 177, 1, 6, 244, 176, 2, 208, 176, 5, 16, 176, 8, 208, 176, 8, 47, 176, 2, 16, 176, 16, 208, 176, 17, 208, 176, 22, 16, 177, 29, 6, 244, 180, 217, 29, 233, 29, 2, 93, 64, 27, 8, 29, 24, 29, 40, 29, 56, 29, 72, 29, 88, 29, 104, 29, 120, 29, 136, 29, 152, 29, 168, 29, 184, 29, 200, 29, 13, 93, 48, 49, 1, 21, 33, 17, 16, 33, 34, 38, 39, 53, 22, 22, 51, 50, 54, 53, 17, 35, 53, 51, 52, 54, 51, 50, 22, 23, 21, 38, 38, 35, 34, 6, 21, 3, 164, 254, 115, 254, 114, 31, 67, 35, 29, 59, 45, 127, 133, 211, 211, 199, 201, 47, 65, 23, 29, 63, 43, 131, 131, 3, 164, 117, 252, 193, 254, 133, 4, 4, 115, 4, 3, 121, 142, 3, 63, 117, 192, 199, 6, 4, 117, 4, 6, 129, 145, 0, 2, 255, 236, 0, 144, 3, 184, 3, 15, 0, 19, 0, 39, 0, 0, 1, 6, 35, 34, 46, 2, 35, 34, 7, 39, 54, 51, 50, 30, 2, 51, 50, 55, 19, 6, 35, 34, 46, 2, 35, 34, 7, 39, 54, 51, 50, 30, 2, 51, 50, 55, 3, 184, 114, 197, 74, 88, 69, 68, 51, 129, 82, 100, 114, 197, 74, 90, 69, 68, 49, 129, 82, 100, 114, 197, 74, 88, 69, 68, 51, 129, 82, 100, 114, 197, 74, 90, 69, 68, 49, 129, 82, 2, 207, 200, 45, 55, 45, 137, 59, 197, 47, 56, 45, 144, 254, 77, 200, 45, 55, 45, 137, 59, 197, 47, 55, 46, 144, 0, 0, 2, 255, 197, 0, 0, 3, 227, 5, 25, 0, 3, 0, 6, 0, 33, 0, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 177, 4, 6, 244, 48, 49, 33, 33, 1, 51, 19, 1, 1, 3, 227, 251, 226, 1, 178, 186, 248, 254, 170, 254, 170, 5, 25, 251, 92, 4, 24, 251, 232, 0, 2, 0, 14, 0, 150, 3, 20, 3, 39, 0, 5, 0, 11, 0, 15, 0, 176, 3, 47, 176, 9, 47, 176, 1, 47, 176, 7, 47, 48, 49, 37, 7, 1, 1, 23, 15, 2, 1, 1, 23, 7, 3, 20, 77, 254, 186, 1, 70, 77, 245, 125, 80, 254, 188, 1, 68, 80, 248, 229, 79, 1, 71, 1, 74, 80, 250, 248, 79, 1, 71, 1, 74, 80, 250, 0, 0, 2, 0, 141, 0, 150, 3, 152, 3, 37, 0, 5, 0, 11, 0, 15, 0, 176, 5, 47, 176, 11, 47, 176, 1, 47, 176, 7, 47, 48, 49, 1, 1, 39, 55, 39, 55, 3, 1, 39, 55, 39, 55, 3, 152, 254, 184, 78, 248, 248, 78, 47, 254, 188, 80, 248, 248, 80, 1, 221, 254, 185, 77, 250, 250, 78, 254, 184, 254, 185, 77, 250, 250, 78, 0, 3, 0, 0, 0, 0, 3, 164, 0, 186, 0, 3, 0, 7, 0, 11, 0, 64, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 15, 62, 89, 176, 4, 16, 177, 2, 5, 244, 176, 3, 208, 176, 6, 208, 176, 7, 208, 176, 10, 208, 176, 11, 208, 48, 49, 33, 35, 53, 51, 5, 35, 53, 51, 5, 35, 53, 51, 3, 164, 187, 187, 254, 139, 186, 186, 254, 139, 186, 186, 186, 186, 186, 186, 186, 0, 255, 255, 255, 197, 0, 0, 3, 227, 6, 201, 2, 38, 0, 34, 0, 0, 0, 7, 0, 65, 0, 0, 1, 117, 255, 255, 255, 197, 0, 0, 3, 227, 6, 115, 2, 38, 0, 34, 0, 0, 0, 7, 0, 215, 0, 0, 1, 115, 255, 255, 255, 223, 255, 233, 3, 199, 6, 115, 2, 38, 0, 48, 0, 0, 0, 7, 0, 215, 0, 0, 1, 115, 0, 2, 255, 242, 255, 233, 3, 164, 5, 47, 0, 19, 0, 42, 0, 160, 179, 10, 12, 22, 4, 43, 179, 35, 12, 0, 4, 43, 64, 27, 6, 10, 22, 10, 38, 10, 54, 10, 70, 10, 86, 10, 102, 10, 118, 10, 134, 10, 150, 10, 166, 10, 182, 10, 198, 10, 13, 93, 180, 213, 10, 229, 10, 2, 93, 176, 35, 16, 177, 27, 9, 244, 176, 35, 16, 176, 31, 208, 176, 27, 16, 176, 39, 208, 178, 40, 0, 35, 17, 18, 57, 0, 176, 0, 69, 88, 176, 24, 47, 27, 177, 24, 21, 62, 89, 176, 0, 69, 88, 176, 28, 47, 27, 177, 28, 21, 62, 89, 176, 0, 69, 88, 176, 20, 47, 27, 177, 20, 15, 62, 89, 176, 0, 69, 88, 176, 38, 47, 27, 177, 38, 15, 62, 89, 179, 33, 6, 34, 4, 43, 176, 28, 16, 177, 30, 6, 244, 176, 20, 16, 177, 36, 6, 244, 176, 37, 208, 178, 40, 20, 24, 17, 18, 57, 48, 49, 1, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 62, 2, 3, 32, 17, 16, 33, 50, 22, 23, 53, 33, 21, 33, 17, 33, 21, 33, 17, 33, 21, 33, 53, 6, 6, 1, 166, 10, 33, 57, 48, 47, 59, 33, 12, 12, 33, 59, 47, 48, 57, 33, 10, 148, 254, 224, 1, 32, 74, 72, 29, 1, 227, 254, 139, 1, 27, 254, 229, 1, 117, 254, 29, 29, 72, 2, 139, 123, 207, 147, 82, 82, 147, 207, 123, 123, 204, 148, 82, 82, 148, 204, 253, 217, 2, 162, 2, 164, 76, 80, 134, 117, 254, 45, 117, 254, 25, 117, 133, 80, 76, 0, 0, 3, 255, 219, 255, 233, 3, 186, 3, 186, 0, 27, 0, 34, 0, 42, 0, 252, 176, 43, 47, 176, 44, 47, 176, 0, 220, 177, 35, 8, 244, 178, 11, 0, 35, 17, 18, 57, 176, 43, 16, 176, 15, 208, 176, 15, 47, 178, 19, 0, 35, 17, 18, 57, 176, 0, 16, 176, 34, 208, 176, 15, 16, 177, 39, 12, 244, 64, 27, 6, 39, 22, 39, 38, 39, 54, 39, 70, 39, 86, 39, 102, 39, 118, 39, 134, 39, 150, 39, 166, 39, 182, 39, 198, 39, 13, 93, 180, 213, 39, 229, 39, 2, 93, 0, 176, 0, 69, 88, 176, 17, 47, 27, 177, 17, 19, 62, 89, 176, 0, 69, 88, 176, 22, 47, 27, 177, 22, 19, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 15, 62, 89, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 15, 62, 89, 179, 34, 3, 0, 4, 43, 178, 11, 9, 17, 17, 18, 57, 178, 19, 9, 17, 17, 18, 57, 176, 22, 16, 177, 31, 1, 244, 180, 217, 31, 233, 31, 2, 93, 64, 27, 8, 31, 24, 31, 40, 31, 56, 31, 72, 31, 88, 31, 104, 31, 120, 31, 136, 31, 152, 31, 168, 31, 184, 31, 200, 31, 13, 93, 176, 37, 208, 176, 13, 16, 177, 41, 1, 244, 64, 27, 7, 41, 23, 41, 39, 41, 55, 41, 71, 41, 87, 41, 103, 41, 119, 41, 135, 41, 151, 41, 167, 41, 183, 41, 199, 41, 13, 93, 180, 214, 41, 230, 41, 2, 93, 48, 49, 1, 20, 22, 51, 50, 54, 55, 23, 6, 35, 34, 39, 6, 35, 32, 17, 16, 33, 50, 23, 54, 54, 51, 50, 30, 2, 21, 39, 52, 38, 35, 34, 6, 7, 7, 16, 35, 34, 17, 16, 51, 50, 2, 14, 78, 78, 47, 66, 14, 127, 68, 186, 178, 49, 43, 170, 254, 233, 1, 23, 164, 47, 22, 111, 84, 100, 113, 57, 14, 147, 55, 82, 82, 58, 4, 143, 141, 142, 142, 141, 1, 162, 166, 148, 56, 71, 41, 213, 201, 201, 1, 232, 1, 233, 194, 98, 96, 104, 160, 188, 84, 121, 151, 150, 158, 143, 74, 1, 119, 254, 137, 254, 135, 0, 0, 1, 0, 0, 1, 168, 3, 164, 2, 20, 0, 3, 0, 9, 0, 179, 1, 1, 0, 4, 43, 48, 49, 17, 53, 33, 21, 3, 164, 1, 168, 108, 108, 0, 0, 1, 255, 164, 1, 168, 4, 2, 2, 20, 0, 3, 0, 9, 0, 179, 3, 1, 0, 4, 43, 48, 49, 1, 33, 53, 33, 4, 2, 251, 162, 4, 94, 1, 168, 108, 0, 2, 0, 55, 2, 233, 3, 164, 5, 23, 0, 12, 0, 25, 0, 116, 179, 24, 13, 15, 4, 43, 179, 11, 13, 2, 4, 43, 176, 2, 16, 177, 0, 14, 244, 176, 7, 208, 176, 15, 16, 177, 13, 14, 244, 176, 20, 208, 0, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 19, 62, 89, 176, 0, 69, 88, 176, 24, 47, 27, 177, 24, 19, 62, 89, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 21, 62, 89, 176, 0, 69, 88, 176, 20, 47, 27, 177, 20, 21, 62, 89, 176, 11, 16, 177, 0, 5, 244, 176, 7, 16, 177, 8, 6, 244, 176, 0, 16, 176, 13, 208, 176, 14, 208, 176, 8, 16, 176, 21, 208, 48, 49, 1, 33, 53, 52, 62, 2, 51, 21, 34, 21, 21, 51, 5, 33, 53, 52, 62, 2, 51, 21, 34, 21, 21, 51, 3, 164, 254, 192, 41, 80, 119, 80, 203, 203, 253, 209, 254, 194, 39, 80, 119, 80, 201, 201, 2, 233, 218, 69, 123, 92, 56, 117, 223, 31, 187, 218, 69, 123, 92, 56, 117, 223, 31, 0, 0, 2, 0, 0, 2, 236, 3, 109, 5, 25, 0, 12, 0, 25, 0, 107, 179, 1, 14, 0, 4, 43, 179, 14, 14, 13, 4, 43, 176, 0, 16, 176, 7, 208, 176, 1, 16, 177, 10, 13, 244, 176, 13, 16, 176, 20, 208, 176, 14, 16, 177, 23, 13, 244, 176, 14, 16, 176, 27, 220, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 21, 62, 89, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 21, 62, 89, 179, 8, 6, 7, 4, 43, 176, 0, 16, 177, 11, 5, 244, 176, 7, 16, 176, 20, 208, 176, 8, 16, 176, 21, 208, 176, 11, 16, 176, 24, 208, 176, 25, 208, 48, 49, 17, 33, 21, 20, 14, 2, 35, 53, 50, 53, 53, 35, 37, 33, 21, 20, 14, 2, 35, 53, 50, 53, 53, 35, 1, 63, 40, 80, 119, 80, 203, 203, 2, 47, 1, 62, 39, 80, 119, 80, 201, 201, 5, 25, 218, 69, 123, 92, 55, 116, 223, 31, 187, 218, 69, 123, 92, 55, 116, 223, 31, 0, 1, 1, 170, 2, 233, 2, 233, 5, 23, 0, 12, 0, 59, 179, 11, 13, 2, 4, 43, 176, 2, 16, 177, 0, 14, 244, 176, 7, 208, 0, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 19, 62, 89, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 21, 62, 89, 176, 11, 16, 177, 0, 5, 244, 176, 7, 16, 177, 8, 6, 244, 48, 49, 1, 33, 53, 52, 62, 2, 51, 21, 34, 21, 21, 51, 2, 233, 254, 193, 41, 80, 119, 79, 202, 202, 2, 233, 218, 69, 123, 92, 56, 117, 223, 31, 0, 0, 1, 0, 186, 2, 236, 1, 250, 5, 25, 0, 12, 0, 48, 179, 1, 14, 0, 4, 43, 176, 0, 16, 176, 7, 208, 176, 1, 16, 177, 10, 13, 244, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 21, 62, 89, 179, 8, 6, 7, 4, 43, 176, 0, 16, 177, 11, 5, 244, 48, 49, 19, 33, 21, 20, 14, 2, 35, 53, 50, 53, 53, 35, 186, 1, 64, 41, 80, 119, 80, 203, 203, 5, 25, 218, 69, 123, 92, 55, 116, 223, 31, 0, 0, 3, 0, 0, 0, 13, 3, 164, 3, 176, 0, 3, 0, 7, 0, 11, 0, 53, 179, 0, 8, 1, 4, 43, 176, 0, 16, 176, 4, 208, 176, 1, 16, 176, 5, 208, 0, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 19, 62, 89, 179, 6, 5, 5, 4, 43, 179, 11, 6, 8, 4, 43, 176, 2, 16, 177, 0, 5, 244, 48, 49, 1, 35, 53, 51, 17, 35, 53, 51, 37, 33, 53, 33, 2, 47, 186, 186, 186, 186, 1, 117, 252, 92, 3, 164, 2, 246, 186, 252, 93, 186, 221, 117, 0, 0, 2, 255, 238, 255, 240, 3, 182, 3, 184, 0, 3, 0, 7, 0, 29, 0, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 19, 62, 89, 176, 0, 69, 88, 176, 1, 47, 27, 177, 1, 15, 62, 89, 48, 49, 9, 7, 3, 182, 254, 27, 254, 29, 1, 227, 1, 98, 254, 158, 254, 158, 1, 98, 1, 211, 254, 29, 1, 227, 1, 229, 254, 27, 1, 98, 254, 158, 254, 158, 0, 255, 255, 255, 225, 254, 117, 3, 193, 5, 25, 2, 34, 0, 90, 0, 0, 0, 2, 0, 140, 0, 0, 255, 255, 255, 236, 0, 0, 3, 184, 6, 140, 2, 34, 0, 58, 0, 0, 0, 3, 0, 140, 0, 0, 1, 115, 0, 1, 0, 2, 255, 229, 3, 164, 5, 55, 0, 3, 0, 19, 0, 176, 3, 47, 176, 0, 69, 88, 176, 1, 47, 27, 177, 1, 15, 62, 89, 48, 49, 1, 1, 39, 1, 3, 164, 252, 188, 94, 3, 70, 4, 248, 250, 237, 60, 5, 22, 0, 0, 1, 0, 0, 255, 233, 3, 172, 5, 47, 0, 53, 0, 153, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 38, 47, 27, 177, 38, 15, 62, 89, 179, 26, 1, 27, 4, 43, 179, 17, 1, 18, 4, 43, 176, 17, 16, 176, 0, 208, 176, 6, 16, 177, 13, 6, 244, 180, 217, 13, 233, 13, 2, 93, 64, 27, 8, 13, 24, 13, 40, 13, 56, 13, 72, 13, 88, 13, 104, 13, 120, 13, 136, 13, 152, 13, 168, 13, 184, 13, 200, 13, 13, 93, 176, 38, 16, 177, 31, 6, 244, 64, 27, 7, 31, 23, 31, 39, 31, 55, 31, 71, 31, 87, 31, 103, 31, 119, 31, 135, 31, 151, 31, 167, 31, 183, 31, 199, 31, 13, 93, 180, 214, 31, 230, 31, 2, 93, 176, 27, 16, 176, 43, 208, 176, 26, 16, 176, 45, 208, 176, 18, 16, 176, 52, 208, 48, 49, 17, 51, 62, 3, 51, 50, 22, 23, 7, 38, 38, 35, 34, 6, 7, 33, 21, 33, 6, 20, 21, 20, 20, 23, 33, 21, 33, 22, 22, 51, 50, 54, 55, 23, 6, 6, 35, 34, 46, 2, 39, 35, 53, 51, 38, 52, 53, 52, 52, 55, 35, 166, 14, 60, 96, 137, 90, 139, 187, 51, 121, 28, 132, 92, 100, 137, 27, 1, 0, 254, 244, 2, 2, 1, 12, 255, 0, 25, 139, 100, 92, 132, 28, 121, 51, 187, 139, 90, 137, 96, 62, 14, 164, 154, 2, 2, 154, 3, 90, 98, 170, 127, 74, 176, 188, 31, 123, 155, 176, 176, 113, 22, 47, 25, 24, 45, 23, 113, 178, 174, 158, 123, 33, 188, 177, 74, 125, 172, 98, 113, 23, 47, 22, 23, 49, 22, 0, 0, 1, 0, 199, 0, 150, 2, 92, 3, 39, 0, 5, 0, 9, 0, 176, 3, 47, 176, 1, 47, 48, 49, 37, 7, 1, 1, 23, 7, 2, 92, 78, 254, 185, 1, 71, 78, 248, 229, 79, 1, 71, 1, 74, 80, 250, 0, 1, 1, 72, 0, 150, 2, 221, 3, 37, 0, 5, 0, 9, 0, 176, 5, 47, 176, 1, 47, 48, 49, 1, 1, 39, 55, 39, 55, 2, 221, 254, 187, 80, 247, 247, 80, 1, 221, 254, 185, 77, 250, 250, 78, 0, 0, 2, 0, 0, 0, 0, 4, 94, 5, 43, 0, 23, 0, 27, 0, 191, 176, 28, 47, 176, 29, 47, 176, 28, 16, 176, 3, 208, 176, 3, 47, 176, 7, 208, 176, 3, 16, 177, 27, 12, 244, 176, 20, 208, 176, 29, 16, 176, 22, 220, 177, 24, 12, 244, 0, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 21, 62, 89, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 21, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 19, 62, 89, 176, 0, 69, 88, 176, 20, 47, 27, 177, 20, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 177, 2, 6, 244, 176, 20, 16, 177, 4, 6, 244, 176, 5, 208, 176, 10, 16, 177, 17, 6, 244, 180, 217, 17, 233, 17, 2, 93, 64, 27, 8, 17, 24, 17, 40, 17, 56, 17, 72, 17, 88, 17, 104, 17, 120, 17, 136, 17, 152, 17, 168, 17, 184, 17, 200, 17, 13, 93, 176, 2, 16, 176, 22, 208, 176, 23, 208, 176, 24, 208, 176, 5, 16, 176, 25, 208, 176, 26, 208, 176, 24, 16, 176, 27, 208, 48, 49, 33, 33, 53, 51, 17, 35, 53, 51, 52, 54, 51, 50, 22, 23, 21, 38, 38, 35, 34, 6, 21, 33, 17, 51, 33, 17, 33, 17, 4, 94, 251, 162, 211, 211, 211, 199, 200, 47, 66, 22, 28, 64, 43, 131, 131, 2, 47, 211, 254, 164, 254, 90, 117, 2, 186, 117, 192, 199, 6, 4, 117, 4, 6, 129, 145, 252, 209, 2, 186, 253, 70, 0, 2, 0, 0, 0, 0, 4, 94, 5, 43, 0, 15, 0, 27, 0, 178, 176, 28, 47, 176, 29, 47, 176, 28, 16, 176, 3, 208, 176, 3, 47, 176, 7, 208, 176, 29, 16, 176, 14, 220, 177, 16, 12, 244, 176, 3, 16, 177, 27, 12, 244, 176, 23, 208, 0, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 21, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 19, 62, 89, 176, 0, 69, 88, 176, 23, 47, 27, 177, 23, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 177, 2, 6, 244, 176, 23, 16, 177, 4, 6, 244, 176, 5, 208, 176, 2, 16, 176, 14, 208, 176, 15, 208, 176, 16, 208, 176, 10, 16, 177, 20, 6, 244, 180, 217, 20, 233, 20, 2, 93, 64, 27, 8, 20, 24, 20, 40, 20, 56, 20, 72, 20, 88, 20, 104, 20, 120, 20, 136, 20, 152, 20, 168, 20, 184, 20, 200, 20, 13, 93, 176, 5, 16, 176, 25, 208, 176, 26, 208, 176, 16, 16, 176, 27, 208, 48, 49, 33, 33, 53, 51, 17, 35, 53, 51, 52, 54, 51, 50, 22, 23, 17, 51, 33, 17, 38, 38, 35, 34, 6, 21, 51, 21, 35, 17, 4, 94, 251, 162, 211, 211, 211, 199, 200, 103, 135, 59, 211, 254, 164, 22, 76, 62, 131, 131, 211, 211, 117, 2, 186, 117, 192, 199, 18, 17, 251, 109, 4, 51, 4, 10, 129, 145, 117, 253, 70, 0, 0, 1, 0, 186, 0, 186, 2, 233, 5, 25, 0, 19, 0, 75, 179, 1, 14, 5, 4, 43, 176, 1, 16, 177, 4, 10, 244, 177, 0, 14, 244, 176, 4, 16, 176, 7, 208, 176, 5, 16, 176, 9, 208, 176, 4, 16, 176, 11, 208, 176, 1, 16, 176, 13, 208, 176, 13, 47, 176, 0, 16, 176, 15, 208, 176, 1, 16, 176, 17, 208, 0, 176, 2, 47, 176, 0, 69, 88, 176, 12, 47, 27, 177, 12, 21, 62, 89, 48, 49, 1, 39, 23, 35, 55, 7, 53, 23, 17, 7, 53, 23, 39, 51, 7, 55, 21, 39, 17, 55, 2, 233, 237, 12, 110, 14, 238, 238, 238, 238, 14, 110, 12, 237, 237, 237, 1, 156, 14, 240, 240, 14, 110, 12, 1, 217, 14, 112, 14, 238, 238, 14, 112, 14, 254, 39, 12, 0, 1, 1, 117, 1, 129, 2, 47, 2, 59, 0, 3, 0, 9, 0, 176, 0, 47, 176, 2, 47, 48, 49, 1, 35, 53, 51, 2, 47, 186, 186, 1, 129, 186, 0, 1, 2, 46, 254, 142, 3, 110, 0, 187, 0, 12, 0, 65, 179, 1, 14, 0, 4, 43, 176, 0, 16, 176, 7, 208, 176, 1, 16, 177, 10, 13, 244, 176, 1, 16, 176, 14, 220, 0, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 17, 62, 89, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 15, 62, 89, 177, 0, 5, 244, 176, 7, 16, 177, 8, 6, 244, 48, 49, 37, 33, 21, 20, 14, 2, 35, 53, 50, 53, 53, 35, 2, 46, 1, 64, 41, 80, 119, 80, 203, 203, 187, 218, 69, 123, 92, 55, 116, 223, 31, 0, 2, 0, 0, 254, 142, 3, 109, 0, 187, 0, 12, 0, 25, 0, 121, 179, 1, 14, 0, 4, 43, 179, 14, 14, 13, 4, 43, 176, 0, 16, 176, 7, 208, 176, 1, 16, 177, 10, 13, 244, 176, 13, 16, 176, 20, 208, 176, 14, 16, 176, 27, 220, 0, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 17, 62, 89, 176, 0, 69, 88, 176, 20, 47, 27, 177, 20, 17, 62, 89, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 15, 62, 89, 176, 0, 69, 88, 176, 24, 47, 27, 177, 24, 15, 62, 89, 176, 11, 16, 177, 0, 5, 244, 176, 7, 16, 177, 8, 6, 244, 176, 0, 16, 176, 13, 208, 176, 14, 208, 176, 8, 16, 176, 21, 208, 48, 49, 53, 33, 21, 20, 14, 2, 35, 53, 50, 53, 53, 35, 37, 33, 21, 20, 14, 2, 35, 53, 50, 53, 53, 35, 1, 63, 40, 80, 119, 80, 203, 203, 2, 47, 1, 62, 39, 80, 119, 80, 201, 201, 187, 218, 69, 123, 92, 55, 116, 223, 31, 187, 218, 69, 123, 92, 55, 116, 223, 31, 0, 0, 7, 255, 236, 255, 219, 4, 92, 5, 47, 0, 3, 0, 15, 0, 27, 0, 39, 0, 51, 0, 63, 0, 75, 1, 133, 179, 10, 10, 16, 4, 43, 179, 34, 10, 40, 4, 43, 179, 46, 9, 28, 4, 43, 179, 58, 10, 64, 4, 43, 179, 70, 9, 52, 4, 43, 64, 27, 6, 10, 22, 10, 38, 10, 54, 10, 70, 10, 86, 10, 102, 10, 118, 10, 134, 10, 150, 10, 166, 10, 182, 10, 198, 10, 13, 93, 180, 213, 10, 229, 10, 2, 93, 180, 182, 34, 198, 34, 2, 93, 64, 23, 6, 34, 22, 34, 38, 34, 54, 34, 70, 34, 86, 34, 102, 34, 118, 34, 134, 34, 150, 34, 166, 34, 11, 93, 180, 213, 34, 229, 34, 2, 93, 176, 34, 16, 176, 22, 208, 176, 22, 47, 180, 218, 28, 234, 28, 2, 93, 64, 27, 9, 28, 25, 28, 41, 28, 57, 28, 73, 28, 89, 28, 105, 28, 121, 28, 137, 28, 153, 28, 169, 28, 185, 28, 201, 28, 13, 93, 180, 218, 52, 234, 52, 2, 93, 64, 27, 9, 52, 25, 52, 41, 52, 57, 52, 73, 52, 89, 52, 105, 52, 121, 52, 137, 52, 153, 52, 169, 52, 185, 52, 201, 52, 13, 93, 180, 218, 64, 234, 64, 2, 93, 64, 27, 9, 64, 25, 64, 41, 64, 57, 64, 73, 64, 89, 64, 105, 64, 121, 64, 137, 64, 153, 64, 169, 64, 185, 64, 201, 64, 13, 93, 176, 70, 16, 176, 77, 220, 0, 176, 1, 47, 176, 49, 47, 176, 73, 47, 176, 0, 69, 88, 176, 19, 47, 27, 177, 19, 21, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 21, 62, 89, 179, 43, 1, 31, 4, 43, 179, 13, 1, 25, 4, 43, 176, 19, 16, 177, 7, 1, 244, 180, 217, 7, 233, 7, 2, 93, 64, 27, 8, 7, 24, 7, 40, 7, 56, 7, 72, 7, 88, 7, 104, 7, 120, 7, 136, 7, 152, 7, 168, 7, 184, 7, 200, 7, 13, 93, 176, 49, 16, 177, 37, 1, 244, 64, 27, 7, 37, 23, 37, 39, 37, 55, 37, 71, 37, 87, 37, 103, 37, 119, 37, 135, 37, 151, 37, 167, 37, 183, 37, 199, 37, 13, 93, 180, 214, 37, 230, 37, 2, 93, 176, 31, 16, 176, 55, 208, 176, 37, 16, 176, 61, 208, 176, 43, 16, 176, 67, 208, 48, 49, 1, 1, 39, 1, 5, 52, 38, 35, 34, 6, 21, 20, 22, 51, 50, 54, 37, 52, 54, 51, 50, 22, 21, 20, 6, 35, 34, 38, 1, 52, 38, 35, 34, 6, 21, 20, 22, 51, 50, 54, 37, 52, 54, 51, 50, 22, 21, 20, 6, 35, 34, 38, 37, 52, 38, 35, 34, 6, 21, 20, 22, 51, 50, 54, 37, 52, 54, 51, 50, 22, 21, 20, 6, 35, 34, 38, 2, 152, 253, 200, 102, 2, 61, 254, 221, 47, 51, 49, 49, 49, 49, 51, 47, 254, 216, 98, 102, 103, 98, 98, 103, 102, 98, 2, 98, 47, 51, 50, 49, 49, 50, 51, 47, 254, 215, 98, 103, 102, 98, 98, 102, 103, 98, 2, 207, 47, 52, 49, 49, 49, 49, 52, 47, 254, 215, 98, 102, 103, 98, 98, 103, 102, 98, 4, 252, 250, 223, 41, 5, 35, 244, 64, 86, 86, 64, 63, 86, 86, 63, 105, 147, 147, 105, 104, 148, 148, 253, 26, 64, 86, 86, 64, 63, 86, 86, 63, 105, 147, 147, 105, 104, 148, 148, 104, 64, 86, 86, 64, 63, 86, 86, 63, 105, 147, 147, 105, 104, 148, 148, 255, 255, 255, 197, 0, 0, 3, 227, 6, 203, 2, 38, 0, 34, 0, 0, 0, 7, 0, 214, 0, 0, 1, 115, 255, 255, 0, 49, 0, 0, 3, 115, 6, 203, 2, 38, 0, 38, 0, 0, 0, 7, 0, 214, 0, 0, 1, 115, 255, 255, 255, 197, 0, 0, 3, 227, 6, 199, 2, 38, 0, 34, 0, 0, 0, 7, 0, 139, 0, 0, 1, 115, 255, 255, 0, 49, 0, 0, 3, 115, 6, 140, 2, 38, 0, 38, 0, 0, 0, 7, 0, 140, 0, 0, 1, 115, 255, 255, 0, 49, 0, 0, 3, 115, 6, 201, 2, 38, 0, 38, 0, 0, 0, 7, 0, 65, 0, 0, 1, 117, 255, 255, 0, 186, 0, 0, 2, 233, 6, 199, 2, 38, 0, 42, 0, 0, 0, 7, 0, 139, 0, 0, 1, 115, 255, 255, 0, 170, 0, 0, 2, 252, 6, 203, 2, 38, 0, 42, 0, 0, 0, 7, 0, 214, 0, 0, 1, 115, 255, 255, 0, 186, 0, 0, 2, 233, 6, 140, 2, 38, 0, 42, 0, 0, 0, 7, 0, 140, 0, 0, 1, 115, 255, 255, 0, 186, 0, 0, 2, 233, 6, 201, 2, 38, 0, 42, 0, 0, 0, 7, 0, 65, 0, 0, 1, 117, 255, 255, 255, 223, 255, 233, 3, 199, 6, 199, 2, 38, 0, 48, 0, 0, 0, 7, 0, 139, 0, 0, 1, 115, 255, 255, 255, 223, 255, 233, 3, 199, 6, 203, 2, 38, 0, 48, 0, 0, 0, 7, 0, 214, 0, 0, 1, 115, 0, 2, 0, 2, 0, 0, 4, 104, 5, 63, 0, 4, 0, 48, 0, 32, 0, 176, 0, 47, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 15, 62, 89, 176, 0, 69, 88, 176, 20, 47, 27, 177, 20, 15, 62, 89, 48, 49, 1, 20, 6, 7, 18, 1, 14, 3, 35, 34, 46, 2, 35, 34, 14, 2, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 30, 2, 51, 50, 62, 2, 51, 50, 23, 6, 21, 20, 30, 2, 3, 51, 147, 117, 2, 2, 59, 14, 57, 80, 100, 56, 30, 58, 57, 60, 30, 31, 57, 54, 53, 26, 68, 131, 103, 61, 39, 78, 121, 84, 36, 70, 62, 57, 29, 32, 62, 63, 64, 35, 147, 109, 146, 25, 47, 69, 5, 63, 149, 166, 10, 1, 10, 252, 102, 43, 122, 113, 82, 16, 21, 16, 16, 23, 16, 123, 186, 215, 92, 74, 150, 118, 76, 14, 19, 14, 17, 20, 16, 133, 123, 139, 43, 88, 78, 59, 255, 255, 255, 223, 255, 233, 3, 199, 6, 201, 2, 38, 0, 48, 0, 0, 0, 7, 0, 65, 0, 0, 1, 117, 255, 255, 0, 49, 255, 233, 3, 115, 6, 199, 2, 38, 0, 54, 0, 0, 0, 7, 0, 139, 0, 0, 1, 115, 255, 255, 0, 49, 255, 233, 3, 115, 6, 203, 2, 38, 0, 54, 0, 0, 0, 7, 0, 214, 0, 0, 1, 115, 255, 255, 0, 49, 255, 233, 3, 115, 6, 201, 2, 38, 0, 54, 0, 0, 0, 7, 0, 65, 0, 0, 1, 117, 0, 1, 0, 186, 0, 0, 2, 233, 3, 164, 0, 9, 0, 68, 179, 8, 14, 2, 4, 43, 176, 8, 16, 177, 3, 8, 244, 176, 2, 16, 176, 5, 208, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 177, 2, 6, 244, 176, 6, 16, 177, 4, 3, 244, 176, 2, 16, 176, 8, 208, 176, 9, 208, 48, 49, 33, 33, 53, 51, 17, 35, 53, 33, 17, 51, 2, 233, 253, 209, 211, 211, 1, 93, 210, 117, 2, 182, 121, 252, 209, 0, 0, 1, 0, 170, 3, 244, 2, 252, 5, 88, 0, 5, 0, 12, 0, 176, 1, 47, 176, 3, 47, 176, 5, 47, 48, 49, 1, 7, 39, 7, 39, 1, 2, 252, 53, 242, 246, 53, 1, 41, 4, 57, 67, 205, 207, 65, 1, 35, 0, 1, 0, 78, 4, 47, 3, 78, 5, 0, 0, 19, 0, 15, 0, 179, 17, 2, 2, 4, 43, 179, 12, 2, 7, 4, 43, 48, 49, 1, 6, 35, 34, 46, 2, 35, 34, 7, 39, 54, 51, 50, 30, 2, 51, 50, 55, 3, 78, 90, 156, 57, 72, 55, 54, 38, 103, 63, 80, 92, 154, 57, 72, 55, 53, 39, 102, 64, 4, 205, 158, 37, 43, 37, 111, 47, 156, 37, 43, 37, 113, 0, 0, 1, 0, 186, 4, 82, 2, 233, 4, 195, 0, 3, 0, 9, 0, 179, 3, 1, 0, 4, 43, 48, 49, 1, 33, 53, 33, 2, 233, 253, 209, 2, 47, 4, 82, 113, 0, 1, 0, 182, 4, 70, 2, 240, 5, 6, 0, 9, 0, 15, 0, 176, 5, 47, 176, 9, 47, 179, 7, 2, 2, 4, 43, 48, 49, 1, 6, 35, 34, 39, 55, 22, 51, 50, 55, 2, 240, 117, 168, 168, 117, 78, 94, 113, 113, 94, 4, 186, 116, 116, 76, 94, 94, 0, 0, 1, 1, 117, 4, 94, 2, 47, 5, 25, 0, 3, 0, 25, 179, 0, 8, 1, 4, 43, 0, 176, 0, 47, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 21, 62, 89, 48, 49, 1, 35, 53, 51, 2, 47, 186, 186, 4, 94, 187, 0, 2, 0, 242, 4, 8, 2, 180, 5, 203, 0, 19, 0, 31, 0, 58, 179, 10, 10, 26, 4, 43, 180, 218, 26, 234, 26, 2, 93, 64, 27, 9, 26, 25, 26, 41, 26, 57, 26, 73, 26, 89, 26, 105, 26, 121, 26, 137, 26, 153, 26, 169, 26, 185, 26, 201, 26, 13, 93, 0, 179, 23, 2, 15, 4, 43, 179, 5, 2, 29, 4, 43, 48, 49, 19, 52, 62, 2, 51, 50, 30, 2, 21, 20, 14, 2, 35, 34, 46, 2, 55, 20, 22, 51, 50, 54, 53, 52, 38, 35, 34, 6, 242, 34, 62, 82, 47, 47, 82, 61, 35, 35, 61, 82, 47, 47, 82, 62, 34, 90, 80, 55, 55, 80, 80, 55, 55, 80, 4, 233, 48, 81, 62, 35, 35, 62, 81, 48, 47, 82, 61, 35, 35, 61, 82, 47, 55, 80, 80, 55, 56, 80, 80, 0, 0, 1, 0, 242, 254, 141, 2, 47, 0, 0, 0, 9, 0, 35, 179, 0, 13, 7, 4, 43, 0, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 17, 62, 89, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 15, 62, 89, 48, 49, 5, 20, 7, 6, 35, 53, 50, 53, 53, 51, 2, 47, 82, 88, 147, 202, 115, 41, 147, 88, 95, 117, 213, 41, 0, 0, 2, 0, 170, 4, 0, 3, 100, 5, 119, 0, 3, 0, 7, 0, 15, 0, 176, 2, 47, 176, 6, 47, 176, 0, 47, 176, 4, 47, 48, 49, 1, 35, 19, 51, 1, 35, 19, 51, 2, 170, 141, 141, 186, 253, 209, 139, 139, 187, 4, 0, 1, 119, 254, 137, 1, 119, 0, 0, 1, 2, 240, 254, 133, 3, 252, 0, 39, 0, 12, 0, 52, 179, 9, 10, 3, 4, 43, 64, 27, 6, 9, 22, 9, 38, 9, 54, 9, 70, 9, 86, 9, 102, 9, 118, 9, 134, 9, 150, 9, 166, 9, 182, 9, 198, 9, 13, 93, 180, 213, 9, 229, 9, 2, 93, 0, 176, 0, 47, 176, 6, 47, 48, 49, 1, 34, 38, 53, 52, 54, 55, 23, 6, 21, 20, 22, 51, 3, 252, 125, 143, 53, 39, 37, 50, 109, 80, 254, 133, 125, 102, 64, 92, 35, 39, 45, 76, 72, 96, 0, 0, 1, 0, 170, 3, 244, 2, 252, 5, 88, 0, 5, 0, 12, 0, 176, 1, 47, 176, 3, 47, 176, 5, 47, 48, 49, 9, 2, 55, 23, 55, 2, 252, 254, 215, 254, 215, 53, 246, 242, 5, 16, 254, 228, 1, 32, 68, 207, 203, 0, 0, 2, 1, 117, 0, 0, 2, 47, 5, 25, 0, 3, 0, 7, 0, 29, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 21, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 48, 49, 1, 3, 35, 3, 19, 35, 53, 51, 2, 45, 51, 82, 51, 186, 186, 186, 5, 25, 252, 86, 3, 170, 250, 231, 186, 0, 2, 0, 186, 3, 72, 2, 233, 5, 25, 0, 3, 0, 7, 0, 35, 0, 176, 1, 47, 176, 5, 47, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 21, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 21, 62, 89, 48, 49, 1, 3, 35, 3, 35, 3, 35, 3, 2, 233, 40, 103, 43, 186, 43, 101, 43, 5, 25, 254, 47, 1, 209, 254, 47, 1, 209, 0, 1, 1, 55, 254, 139, 2, 98, 255, 152, 0, 3, 0, 19, 0, 176, 0, 47, 176, 0, 69, 88, 176, 1, 47, 27, 177, 1, 17, 62, 89, 48, 49, 5, 3, 35, 19, 2, 98, 172, 127, 84, 104, 254, 243, 1, 13, 0, 0, 2, 255, 217, 0, 145, 3, 205, 4, 133, 0, 33, 0, 53, 0, 133, 176, 54, 47, 176, 55, 47, 176, 4, 220, 176, 54, 16, 176, 22, 208, 176, 22, 47, 176, 4, 16, 177, 34, 8, 244, 180, 218, 34, 234, 34, 2, 93, 64, 27, 9, 34, 25, 34, 41, 34, 57, 34, 73, 34, 89, 34, 105, 34, 121, 34, 137, 34, 153, 34, 169, 34, 185, 34, 201, 34, 13, 93, 176, 22, 16, 177, 44, 12, 244, 64, 27, 6, 44, 22, 44, 38, 44, 54, 44, 70, 44, 86, 44, 102, 44, 118, 44, 134, 44, 150, 44, 166, 44, 182, 44, 198, 44, 13, 93, 180, 213, 44, 229, 44, 2, 93, 0, 176, 9, 47, 176, 17, 47, 176, 26, 47, 176, 33, 47, 179, 49, 3, 13, 4, 43, 179, 29, 6, 39, 4, 43, 48, 49, 1, 7, 22, 22, 21, 20, 6, 7, 23, 7, 39, 6, 6, 35, 34, 38, 39, 7, 39, 55, 38, 38, 53, 52, 55, 39, 55, 23, 54, 51, 50, 22, 23, 55, 3, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 62, 2, 3, 205, 117, 49, 53, 53, 47, 115, 80, 115, 61, 158, 92, 94, 158, 61, 115, 78, 115, 47, 49, 98, 117, 78, 117, 127, 184, 92, 158, 59, 117, 74, 47, 92, 131, 82, 82, 131, 90, 47, 47, 90, 131, 82, 82, 131, 92, 47, 4, 55, 116, 62, 160, 92, 92, 158, 61, 115, 78, 113, 47, 49, 53, 47, 117, 78, 117, 61, 156, 92, 185, 127, 118, 78, 119, 103, 54, 47, 117, 254, 4, 80, 135, 103, 57, 57, 103, 135, 80, 80, 135, 98, 55, 55, 98, 135, 0, 0, 2, 1, 141, 255, 70, 2, 23, 5, 211, 0, 3, 0, 7, 0, 27, 179, 0, 8, 1, 4, 43, 176, 0, 16, 176, 4, 208, 176, 1, 16, 176, 5, 208, 0, 176, 6, 47, 176, 0, 47, 48, 49, 5, 35, 17, 51, 53, 35, 17, 51, 2, 23, 138, 138, 138, 138, 186, 2, 233, 186, 2, 234, 0, 0, 1, 0, 0, 1, 164, 3, 164, 2, 25, 0, 3, 0, 9, 0, 179, 3, 6, 0, 4, 43, 48, 49, 1, 33, 53, 33, 3, 164, 252, 92, 3, 164, 1, 164, 117, 0, 1, 0, 27, 2, 233, 1, 193, 5, 37, 0, 27, 0, 96, 179, 10, 9, 4, 4, 43, 176, 10, 16, 176, 0, 208, 176, 0, 47, 176, 4, 16, 176, 8, 208, 176, 8, 47, 176, 4, 16, 176, 16, 208, 0, 176, 0, 69, 88, 176, 24, 47, 27, 177, 24, 21, 62, 89, 179, 8, 2, 11, 4, 43, 176, 24, 16, 177, 19, 2, 244, 180, 217, 19, 233, 19, 2, 93, 64, 27, 8, 19, 24, 19, 40, 19, 56, 19, 72, 19, 88, 19, 104, 19, 120, 19, 136, 19, 152, 19, 168, 19, 184, 19, 200, 19, 13, 93, 48, 49, 1, 20, 7, 6, 7, 6, 6, 7, 51, 53, 51, 21, 33, 53, 55, 54, 53, 52, 38, 35, 34, 21, 35, 52, 51, 50, 23, 22, 1, 193, 33, 17, 59, 25, 69, 45, 147, 98, 254, 107, 252, 47, 55, 41, 115, 102, 217, 84, 55, 66, 4, 127, 55, 45, 29, 53, 23, 63, 47, 73, 164, 78, 240, 47, 41, 35, 37, 138, 232, 41, 49, 0, 0, 1, 255, 254, 2, 221, 1, 178, 5, 35, 0, 33, 0, 147, 179, 30, 9, 18, 4, 43, 176, 30, 16, 176, 0, 208, 176, 0, 47, 180, 218, 18, 234, 18, 2, 93, 64, 27, 9, 18, 25, 18, 41, 18, 57, 18, 73, 18, 89, 18, 105, 18, 121, 18, 137, 18, 153, 18, 169, 18, 185, 18, 201, 18, 13, 93, 176, 18, 16, 176, 11, 208, 176, 11, 47, 178, 32, 18, 30, 17, 18, 57, 0, 176, 0, 69, 88, 176, 27, 47, 27, 177, 27, 21, 62, 89, 178, 16, 3, 3, 43, 176, 3, 16, 177, 8, 2, 244, 176, 27, 16, 177, 20, 2, 244, 180, 217, 20, 233, 20, 2, 93, 64, 27, 8, 20, 24, 20, 40, 20, 56, 20, 72, 20, 88, 20, 104, 20, 120, 20, 136, 20, 152, 20, 168, 20, 184, 20, 200, 20, 13, 93, 178, 32, 3, 16, 17, 18, 57, 48, 49, 1, 20, 6, 35, 34, 39, 55, 22, 51, 50, 54, 53, 52, 39, 38, 35, 53, 50, 53, 52, 35, 34, 21, 35, 52, 55, 54, 51, 50, 22, 21, 20, 7, 22, 1, 178, 115, 92, 204, 25, 106, 15, 108, 41, 58, 33, 17, 67, 106, 88, 112, 105, 64, 63, 90, 92, 105, 66, 76, 3, 141, 69, 107, 203, 14, 123, 50, 32, 56, 10, 10, 100, 66, 74, 123, 106, 56, 51, 92, 72, 76, 35, 53, 0, 1, 0, 0, 2, 233, 1, 133, 5, 25, 0, 16, 0, 40, 179, 15, 9, 3, 4, 43, 176, 3, 16, 176, 13, 208, 0, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 21, 62, 89, 179, 16, 2, 0, 4, 43, 176, 16, 16, 176, 2, 208, 48, 49, 1, 33, 53, 51, 17, 6, 6, 35, 53, 50, 62, 2, 53, 51, 17, 51, 1, 133, 254, 223, 90, 20, 96, 74, 31, 67, 56, 36, 109, 90, 2, 233, 91, 1, 34, 51, 74, 99, 28, 54, 75, 48, 254, 43, 0, 4, 0, 0, 255, 229, 3, 164, 5, 55, 0, 3, 0, 20, 0, 35, 0, 38, 0, 171, 176, 39, 47, 176, 40, 47, 176, 34, 220, 176, 3, 208, 176, 3, 47, 176, 39, 16, 176, 7, 208, 176, 7, 47, 176, 17, 208, 176, 7, 16, 177, 19, 9, 244, 176, 34, 16, 177, 24, 9, 244, 176, 28, 208, 176, 28, 47, 176, 34, 16, 176, 29, 208, 176, 24, 16, 176, 36, 208, 178, 37, 7, 34, 17, 18, 57, 178, 38, 7, 34, 17, 18, 57, 0, 176, 3, 47, 176, 0, 69, 88, 176, 17, 47, 27, 177, 17, 21, 62, 89, 176, 0, 69, 88, 176, 1, 47, 27, 177, 1, 15, 62, 89, 176, 0, 69, 88, 176, 21, 47, 27, 177, 21, 15, 62, 89, 179, 36, 2, 25, 4, 43, 179, 20, 2, 4, 4, 43, 176, 20, 16, 176, 6, 208, 178, 8, 1, 3, 17, 18, 57, 176, 21, 16, 177, 23, 2, 244, 176, 36, 16, 176, 30, 208, 176, 25, 16, 176, 32, 208, 176, 23, 16, 176, 34, 208, 176, 35, 208, 48, 49, 1, 1, 39, 1, 1, 33, 53, 51, 17, 6, 6, 35, 53, 50, 62, 2, 53, 51, 17, 51, 1, 33, 53, 51, 53, 35, 53, 19, 51, 17, 51, 21, 35, 21, 51, 39, 53, 7, 3, 164, 252, 188, 94, 3, 70, 254, 61, 254, 223, 90, 20, 96, 74, 31, 67, 56, 36, 109, 90, 2, 31, 254, 225, 92, 250, 244, 111, 90, 90, 90, 195, 119, 4, 248, 250, 237, 60, 5, 22, 253, 178, 91, 1, 34, 51, 74, 99, 28, 54, 75, 48, 254, 43, 252, 188, 90, 60, 75, 1, 78, 254, 195, 92, 60, 152, 159, 159, 0, 3, 0, 0, 255, 229, 3, 166, 5, 55, 0, 3, 0, 31, 0, 48, 0, 136, 176, 49, 47, 176, 50, 47, 176, 14, 220, 176, 0, 208, 176, 14, 16, 176, 4, 208, 176, 4, 47, 176, 14, 16, 177, 8, 9, 244, 176, 12, 208, 176, 12, 47, 176, 8, 16, 176, 20, 208, 176, 49, 16, 176, 35, 208, 176, 35, 47, 176, 45, 208, 176, 35, 16, 177, 47, 9, 244, 0, 176, 3, 47, 176, 0, 69, 88, 176, 45, 47, 27, 177, 45, 21, 62, 89, 176, 0, 69, 88, 176, 1, 47, 27, 177, 1, 15, 62, 89, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 15, 62, 89, 179, 28, 2, 23, 4, 43, 179, 48, 2, 32, 4, 43, 176, 15, 16, 177, 11, 2, 244, 176, 48, 16, 176, 34, 208, 178, 36, 1, 3, 17, 18, 57, 48, 49, 1, 1, 39, 1, 19, 20, 7, 6, 7, 6, 6, 7, 51, 53, 51, 21, 33, 53, 55, 54, 53, 52, 38, 35, 34, 21, 35, 52, 51, 50, 23, 22, 1, 33, 53, 51, 17, 6, 6, 35, 53, 50, 62, 2, 53, 51, 17, 51, 3, 164, 252, 188, 94, 3, 70, 94, 33, 16, 60, 24, 70, 45, 148, 98, 254, 106, 252, 47, 55, 41, 115, 102, 217, 84, 55, 66, 253, 223, 254, 223, 90, 20, 96, 74, 31, 67, 56, 36, 109, 90, 4, 248, 250, 237, 60, 5, 22, 252, 95, 56, 45, 29, 53, 22, 64, 47, 74, 164, 78, 239, 48, 41, 34, 37, 137, 231, 41, 49, 1, 8, 91, 1, 34, 51, 74, 99, 28, 54, 75, 48, 254, 43, 0, 4, 255, 254, 255, 229, 3, 164, 5, 55, 0, 33, 0, 37, 0, 52, 0, 55, 1, 15, 176, 56, 47, 176, 57, 47, 176, 56, 16, 176, 18, 208, 176, 18, 47, 177, 30, 9, 244, 64, 27, 6, 30, 22, 30, 38, 30, 54, 30, 70, 30, 86, 30, 102, 30, 118, 30, 134, 30, 150, 30, 166, 30, 182, 30, 198, 30, 13, 93, 180, 213, 30, 229, 30, 2, 93, 176, 0, 208, 176, 0, 47, 176, 18, 16, 176, 11, 208, 176, 11, 47, 178, 32, 18, 30, 17, 18, 57, 176, 57, 16, 176, 51, 220, 176, 37, 208, 176, 37, 47, 176, 51, 16, 177, 41, 9, 244, 176, 45, 208, 176, 45, 47, 176, 51, 16, 176, 46, 208, 176, 41, 16, 176, 53, 208, 178, 54, 18, 51, 17, 18, 57, 178, 55, 18, 51, 17, 18, 57, 0, 176, 37, 47, 176, 0, 69, 88, 176, 27, 47, 27, 177, 27, 21, 62, 89, 176, 0, 69, 88, 176, 35, 47, 27, 177, 35, 15, 62, 89, 176, 0, 69, 88, 176, 38, 47, 27, 177, 38, 15, 62, 89, 179, 53, 2, 42, 4, 43, 179, 8, 2, 3, 4, 43, 176, 3, 16, 176, 16, 220, 176, 27, 16, 177, 20, 2, 244, 180, 217, 20, 233, 20, 2, 93, 64, 27, 8, 20, 24, 20, 40, 20, 56, 20, 72, 20, 88, 20, 104, 20, 120, 20, 136, 20, 152, 20, 168, 20, 184, 20, 200, 20, 13, 93, 178, 32, 3, 16, 17, 18, 57, 176, 38, 16, 177, 40, 2, 244, 176, 53, 16, 176, 47, 208, 176, 42, 16, 176, 49, 208, 176, 40, 16, 176, 51, 208, 176, 52, 208, 48, 49, 1, 20, 6, 35, 34, 39, 55, 22, 51, 50, 54, 53, 52, 39, 38, 35, 53, 50, 53, 52, 35, 34, 21, 35, 52, 55, 54, 51, 50, 22, 21, 20, 7, 22, 1, 1, 39, 1, 19, 33, 53, 51, 53, 35, 53, 19, 51, 17, 51, 21, 35, 21, 51, 39, 53, 7, 1, 178, 115, 92, 204, 25, 106, 15, 108, 41, 58, 33, 17, 67, 106, 88, 112, 105, 64, 63, 90, 92, 105, 66, 76, 1, 242, 252, 188, 94, 3, 70, 92, 254, 225, 92, 250, 244, 111, 90, 90, 90, 195, 119, 3, 141, 69, 107, 203, 14, 123, 50, 32, 56, 10, 10, 100, 66, 74, 123, 106, 56, 51, 92, 72, 76, 35, 53, 1, 29, 250, 237, 60, 5, 22, 250, 201, 90, 60, 75, 1, 78, 254, 195, 92, 60, 152, 159, 159, 0, 2, 255, 139, 0, 0, 3, 207, 5, 25, 0, 16, 0, 29, 0, 136, 176, 30, 47, 176, 31, 47, 176, 0, 220, 176, 30, 16, 176, 6, 208, 176, 6, 47, 176, 10, 208, 176, 0, 16, 177, 17, 12, 244, 180, 218, 17, 234, 17, 2, 93, 64, 27, 9, 17, 25, 17, 41, 17, 57, 17, 73, 17, 89, 17, 105, 17, 121, 17, 137, 17, 153, 17, 169, 17, 185, 17, 201, 17, 13, 93, 176, 6, 16, 177, 26, 12, 244, 176, 21, 208, 0, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 21, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 179, 10, 6, 7, 4, 43, 176, 11, 16, 177, 20, 6, 244, 176, 10, 16, 176, 22, 208, 176, 7, 16, 176, 24, 208, 176, 5, 16, 177, 26, 6, 244, 48, 49, 1, 20, 14, 2, 35, 33, 17, 35, 53, 51, 17, 33, 50, 30, 2, 7, 16, 2, 35, 33, 17, 51, 21, 35, 17, 33, 50, 18, 3, 207, 60, 122, 191, 129, 254, 88, 166, 166, 1, 168, 137, 191, 121, 53, 137, 193, 172, 254, 225, 254, 254, 1, 31, 172, 193, 2, 141, 135, 237, 179, 102, 2, 94, 117, 2, 70, 107, 180, 236, 129, 1, 0, 1, 23, 254, 47, 117, 254, 23, 1, 24, 0, 0, 1, 0, 98, 0, 109, 3, 68, 3, 78, 0, 11, 0, 15, 0, 176, 9, 47, 176, 11, 47, 176, 3, 47, 176, 5, 47, 48, 49, 9, 2, 7, 1, 1, 39, 1, 1, 55, 1, 1, 3, 68, 254, 221, 1, 35, 80, 254, 223, 254, 221, 78, 1, 33, 254, 223, 78, 1, 35, 1, 33, 3, 0, 254, 222, 254, 221, 78, 1, 35, 254, 221, 78, 1, 35, 1, 34, 78, 254, 221, 1, 35, 255, 255, 255, 236, 0, 0, 3, 184, 6, 199, 2, 38, 0, 58, 0, 0, 0, 7, 0, 139, 0, 0, 1, 115, 0, 2, 0, 49, 0, 0, 3, 162, 5, 25, 0, 10, 0, 18, 0, 116, 176, 19, 47, 176, 20, 47, 176, 0, 220, 176, 19, 16, 176, 5, 208, 176, 5, 47, 177, 4, 12, 244, 176, 7, 208, 176, 0, 16, 177, 11, 8, 244, 180, 218, 11, 234, 11, 2, 93, 64, 27, 9, 11, 25, 11, 41, 11, 57, 11, 73, 11, 89, 11, 105, 11, 121, 11, 137, 11, 153, 11, 169, 11, 185, 11, 201, 11, 13, 93, 176, 4, 16, 176, 14, 208, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 179, 16, 6, 2, 4, 43, 179, 9, 6, 13, 4, 43, 48, 49, 1, 16, 33, 35, 17, 35, 17, 51, 17, 51, 32, 3, 52, 33, 35, 17, 51, 50, 54, 3, 162, 254, 12, 244, 137, 137, 244, 1, 244, 139, 254, 151, 244, 244, 180, 181, 2, 152, 254, 139, 254, 221, 5, 25, 254, 243, 254, 140, 254, 254, 0, 131, 0, 2, 255, 236, 255, 233, 3, 182, 5, 92, 0, 32, 0, 48, 0, 194, 176, 49, 47, 176, 50, 47, 176, 49, 16, 176, 23, 208, 176, 23, 47, 176, 50, 16, 176, 15, 220, 178, 1, 23, 15, 17, 18, 57, 178, 28, 23, 15, 17, 18, 57, 177, 33, 12, 244, 180, 218, 33, 234, 33, 2, 93, 64, 27, 9, 33, 25, 33, 41, 33, 57, 33, 73, 33, 89, 33, 105, 33, 121, 33, 137, 33, 153, 33, 169, 33, 185, 33, 201, 33, 13, 93, 176, 23, 16, 177, 41, 12, 244, 64, 27, 6, 41, 22, 41, 38, 41, 54, 41, 70, 41, 86, 41, 102, 41, 118, 41, 134, 41, 150, 41, 166, 41, 182, 41, 198, 41, 13, 93, 180, 213, 41, 229, 41, 2, 93, 0, 176, 8, 47, 176, 0, 69, 88, 176, 20, 47, 27, 177, 20, 15, 62, 89, 178, 1, 20, 8, 17, 18, 57, 178, 28, 20, 8, 17, 18, 57, 177, 44, 6, 244, 64, 27, 7, 44, 23, 44, 39, 44, 55, 44, 71, 44, 87, 44, 103, 44, 119, 44, 135, 44, 151, 44, 167, 44, 183, 44, 199, 44, 13, 93, 180, 214, 44, 230, 44, 2, 93, 48, 49, 19, 55, 38, 38, 39, 55, 22, 23, 55, 23, 7, 30, 3, 21, 20, 14, 2, 35, 34, 38, 53, 52, 54, 54, 36, 55, 38, 38, 39, 7, 1, 52, 38, 39, 14, 3, 21, 20, 22, 51, 50, 62, 2, 233, 160, 41, 86, 47, 45, 117, 102, 144, 78, 121, 80, 135, 96, 55, 71, 136, 192, 121, 205, 245, 116, 203, 1, 16, 156, 41, 121, 71, 183, 1, 246, 16, 17, 145, 244, 176, 98, 168, 145, 92, 142, 98, 51, 3, 209, 160, 22, 35, 16, 117, 45, 53, 143, 80, 123, 51, 127, 155, 187, 112, 129, 207, 146, 78, 193, 184, 105, 162, 122, 84, 25, 70, 110, 47, 182, 254, 152, 55, 100, 47, 16, 70, 98, 125, 76, 116, 144, 64, 116, 164, 255, 255, 255, 225, 254, 117, 3, 193, 5, 84, 2, 38, 0, 90, 0, 0, 0, 6, 0, 139, 0, 0, 0, 2, 0, 49, 254, 139, 3, 166, 5, 25, 0, 18, 0, 33, 0, 236, 176, 34, 47, 176, 35, 47, 176, 0, 220, 176, 34, 16, 176, 9, 208, 176, 9, 47, 177, 8, 12, 244, 176, 11, 208, 178, 12, 9, 0, 17, 18, 57, 176, 0, 16, 177, 19, 8, 244, 180, 218, 19, 234, 19, 2, 93, 64, 27, 9, 19, 25, 19, 41, 19, 57, 19, 73, 19, 89, 19, 105, 19, 121, 19, 137, 19, 153, 19, 169, 19, 185, 19, 201, 19, 13, 93, 176, 8, 16, 176, 26, 208, 0, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 21, 62, 89, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 19, 62, 89, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 17, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 177, 29, 1, 244, 64, 27, 7, 29, 23, 29, 39, 29, 55, 29, 71, 29, 87, 29, 103, 29, 119, 29, 135, 29, 151, 29, 167, 29, 183, 29, 199, 29, 13, 93, 180, 214, 29, 230, 29, 2, 93, 178, 7, 5, 29, 17, 18, 57, 176, 14, 16, 177, 24, 1, 244, 180, 217, 24, 233, 24, 2, 93, 64, 27, 8, 24, 24, 24, 40, 24, 56, 24, 72, 24, 88, 24, 104, 24, 120, 24, 136, 24, 152, 24, 168, 24, 184, 24, 200, 24, 13, 93, 178, 12, 14, 24, 17, 18, 57, 48, 49, 1, 20, 14, 2, 35, 34, 39, 17, 35, 17, 51, 17, 54, 51, 50, 30, 2, 7, 52, 46, 2, 35, 34, 7, 17, 22, 51, 50, 62, 2, 3, 166, 66, 120, 177, 110, 150, 125, 137, 137, 125, 150, 106, 176, 123, 68, 139, 43, 82, 127, 82, 156, 119, 119, 156, 82, 127, 82, 43, 1, 209, 109, 178, 131, 72, 99, 254, 65, 6, 142, 254, 63, 98, 69, 127, 180, 113, 82, 137, 100, 58, 127, 254, 12, 129, 57, 103, 139, 255, 255, 255, 197, 0, 0, 3, 227, 6, 54, 2, 38, 0, 34, 0, 0, 0, 7, 0, 216, 0, 0, 1, 115, 255, 255, 0, 0, 255, 233, 3, 117, 4, 194, 2, 38, 0, 66, 2, 0, 0, 6, 0, 216, 0, 255, 255, 255, 255, 197, 0, 0, 3, 227, 6, 121, 2, 38, 0, 34, 0, 0, 0, 7, 0, 217, 0, 0, 1, 115, 255, 255, 0, 0, 255, 233, 3, 117, 5, 5, 2, 38, 0, 66, 2, 0, 0, 6, 0, 217, 0, 255, 0, 2, 255, 197, 254, 133, 4, 111, 5, 25, 0, 19, 0, 22, 0, 127, 179, 16, 10, 3, 4, 43, 180, 218, 3, 234, 3, 2, 93, 64, 27, 9, 3, 25, 3, 41, 3, 57, 3, 73, 3, 89, 3, 105, 3, 121, 3, 137, 3, 153, 3, 169, 3, 185, 3, 201, 3, 13, 93, 178, 6, 3, 16, 17, 18, 57, 176, 16, 16, 176, 24, 220, 0, 176, 0, 47, 176, 0, 69, 88, 176, 12, 47, 27, 177, 12, 21, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 15, 62, 89, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 15, 62, 89, 179, 20, 3, 8, 4, 43, 178, 11, 0, 12, 17, 18, 57, 48, 49, 1, 34, 38, 53, 52, 54, 55, 35, 3, 33, 3, 35, 1, 51, 1, 6, 21, 20, 22, 51, 1, 3, 3, 4, 111, 125, 144, 31, 23, 72, 123, 253, 252, 121, 147, 1, 178, 186, 1, 178, 49, 109, 80, 254, 63, 219, 219, 254, 133, 125, 102, 48, 75, 29, 1, 117, 254, 139, 5, 25, 250, 231, 45, 76, 72, 96, 3, 15, 2, 161, 253, 95, 0, 0, 2, 255, 254, 254, 133, 3, 252, 3, 186, 0, 51, 0, 68, 0, 245, 179, 66, 12, 23, 4, 43, 179, 3, 10, 14, 4, 43, 176, 14, 16, 177, 0, 8, 244, 176, 14, 16, 176, 10, 208, 176, 10, 47, 176, 14, 16, 176, 33, 208, 176, 14, 16, 176, 57, 208, 64, 27, 6, 66, 22, 66, 38, 66, 54, 66, 70, 66, 86, 66, 102, 66, 118, 66, 134, 66, 150, 66, 166, 66, 182, 66, 198, 66, 13, 93, 180, 213, 66, 229, 66, 2, 93, 0, 176, 7, 47, 176, 0, 69, 88, 176, 46, 47, 27, 177, 46, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 15, 62, 89, 176, 0, 69, 88, 176, 20, 47, 27, 177, 20, 15, 62, 89, 179, 28, 6, 61, 4, 43, 178, 15, 7, 46, 17, 18, 57, 176, 46, 16, 177, 39, 6, 244, 180, 217, 39, 233, 39, 2, 93, 64, 27, 8, 39, 24, 39, 40, 39, 56, 39, 72, 39, 88, 39, 104, 39, 120, 39, 136, 39, 152, 39, 168, 39, 184, 39, 200, 39, 13, 93, 176, 20, 16, 177, 52, 6, 244, 64, 27, 7, 52, 23, 52, 39, 52, 55, 52, 71, 52, 87, 52, 103, 52, 119, 52, 135, 52, 151, 52, 167, 52, 183, 52, 199, 52, 13, 93, 180, 214, 52, 230, 52, 2, 93, 176, 61, 16, 176, 58, 208, 176, 58, 47, 48, 49, 33, 6, 6, 21, 20, 22, 51, 21, 34, 38, 53, 52, 54, 55, 35, 53, 14, 3, 35, 34, 38, 53, 52, 62, 2, 51, 50, 30, 2, 23, 53, 52, 46, 2, 35, 34, 6, 7, 39, 54, 54, 51, 50, 30, 2, 21, 1, 50, 62, 2, 53, 53, 38, 38, 35, 34, 14, 2, 21, 20, 22, 3, 115, 23, 29, 109, 80, 125, 143, 30, 23, 60, 36, 91, 100, 100, 45, 185, 190, 88, 143, 185, 96, 37, 59, 53, 54, 32, 59, 86, 94, 33, 104, 176, 76, 62, 84, 209, 125, 76, 147, 117, 70, 254, 2, 86, 137, 96, 53, 67, 123, 45, 74, 137, 102, 62, 115, 23, 63, 35, 72, 96, 90, 125, 102, 48, 75, 29, 156, 45, 68, 43, 23, 142, 133, 88, 119, 69, 31, 2, 4, 6, 4, 67, 68, 88, 51, 21, 56, 47, 103, 51, 65, 39, 81, 132, 92, 253, 252, 51, 76, 86, 35, 88, 10, 2, 20, 45, 72, 53, 59, 99, 0, 255, 255, 255, 236, 255, 233, 3, 172, 6, 199, 2, 38, 0, 36, 0, 0, 0, 7, 0, 139, 0, 0, 1, 115, 255, 255, 0, 0, 255, 233, 3, 129, 5, 83, 2, 38, 0, 68, 0, 0, 0, 6, 0, 139, 0, 255, 255, 255, 255, 236, 255, 233, 3, 172, 6, 203, 2, 38, 0, 36, 0, 0, 0, 7, 0, 214, 0, 0, 1, 115, 255, 255, 0, 0, 255, 233, 3, 129, 5, 87, 2, 38, 0, 68, 0, 0, 0, 6, 0, 214, 0, 255, 255, 255, 255, 236, 255, 233, 3, 172, 6, 140, 2, 38, 0, 36, 0, 0, 0, 7, 0, 218, 0, 0, 1, 115, 255, 255, 0, 0, 255, 233, 3, 129, 5, 25, 2, 38, 0, 68, 0, 0, 0, 6, 0, 218, 0, 0, 255, 255, 255, 236, 255, 233, 3, 172, 6, 203, 2, 38, 0, 36, 0, 0, 0, 7, 0, 223, 0, 0, 1, 115, 255, 255, 0, 0, 255, 233, 3, 129, 5, 87, 2, 38, 0, 68, 0, 0, 0, 6, 0, 223, 0, 255, 255, 255, 0, 49, 0, 0, 3, 207, 6, 207, 2, 38, 0, 37, 0, 0, 0, 7, 0, 223, 0, 0, 1, 119, 0, 3, 0, 0, 255, 233, 4, 41, 5, 25, 0, 22, 0, 38, 0, 42, 0, 217, 176, 43, 47, 176, 44, 47, 176, 0, 220, 177, 1, 12, 244, 176, 43, 16, 176, 10, 208, 176, 10, 47, 176, 1, 16, 176, 18, 208, 176, 1, 16, 176, 23, 208, 176, 10, 16, 177, 31, 12, 244, 64, 27, 6, 31, 22, 31, 38, 31, 54, 31, 70, 31, 86, 31, 102, 31, 118, 31, 134, 31, 150, 31, 166, 31, 182, 31, 198, 31, 13, 93, 180, 213, 31, 229, 31, 2, 93, 0, 176, 18, 47, 176, 26, 47, 176, 40, 47, 176, 0, 69, 88, 176, 21, 47, 27, 177, 21, 21, 62, 89, 176, 0, 69, 88, 176, 39, 47, 27, 177, 39, 21, 62, 89, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 177, 36, 6, 244, 64, 27, 7, 36, 23, 36, 39, 36, 55, 36, 71, 36, 87, 36, 103, 36, 119, 36, 135, 36, 151, 36, 167, 36, 183, 36, 199, 36, 13, 93, 180, 214, 36, 230, 36, 2, 93, 178, 2, 5, 36, 17, 18, 57, 176, 21, 16, 177, 19, 6, 244, 176, 15, 16, 177, 41, 6, 244, 48, 49, 33, 35, 53, 6, 6, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 22, 23, 17, 35, 53, 33, 3, 38, 38, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 55, 1, 3, 35, 17, 2, 233, 137, 47, 117, 59, 90, 143, 99, 53, 53, 99, 143, 90, 59, 117, 47, 186, 1, 67, 137, 47, 108, 60, 61, 96, 66, 35, 35, 66, 96, 61, 123, 92, 1, 201, 84, 101, 86, 53, 56, 72, 129, 180, 107, 106, 181, 129, 73, 53, 53, 1, 84, 117, 253, 178, 65, 58, 58, 100, 135, 80, 80, 135, 100, 58, 125, 4, 63, 254, 47, 1, 209, 0, 255, 255, 255, 139, 0, 0, 3, 207, 5, 25, 2, 6, 0, 236, 0, 0, 0, 2, 255, 254, 255, 233, 4, 45, 5, 25, 0, 28, 0, 44, 1, 9, 176, 45, 47, 176, 46, 47, 176, 2, 220, 177, 3, 8, 244, 176, 45, 16, 176, 12, 208, 176, 12, 47, 176, 3, 16, 176, 20, 208, 176, 3, 16, 176, 24, 208, 176, 2, 16, 176, 26, 208, 176, 3, 16, 176, 29, 208, 176, 12, 16, 177, 37, 12, 244, 64, 27, 6, 37, 22, 37, 38, 37, 54, 37, 70, 37, 86, 37, 102, 37, 118, 37, 134, 37, 150, 37, 166, 37, 182, 37, 198, 37, 13, 93, 180, 213, 37, 229, 37, 2, 93, 0, 176, 0, 69, 88, 176, 25, 47, 27, 177, 25, 21, 62, 89, 176, 0, 69, 88, 176, 17, 47, 27, 177, 17, 19, 62, 89, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 15, 62, 89, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 15, 62, 89, 179, 28, 6, 0, 4, 43, 176, 7, 16, 177, 42, 6, 244, 64, 27, 7, 42, 23, 42, 39, 42, 55, 42, 71, 42, 87, 42, 103, 42, 119, 42, 135, 42, 151, 42, 167, 42, 183, 42, 199, 42, 13, 93, 180, 214, 42, 230, 42, 2, 93, 178, 4, 7, 42, 17, 18, 57, 176, 17, 16, 177, 32, 6, 244, 180, 217, 32, 233, 32, 2, 93, 64, 27, 8, 32, 24, 32, 40, 32, 56, 32, 72, 32, 88, 32, 104, 32, 120, 32, 136, 32, 152, 32, 168, 32, 184, 32, 200, 32, 13, 93, 178, 20, 17, 32, 17, 18, 57, 176, 0, 16, 176, 21, 208, 176, 28, 16, 176, 23, 208, 48, 49, 1, 35, 17, 35, 53, 6, 6, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 22, 23, 53, 35, 53, 51, 53, 51, 21, 51, 1, 38, 38, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 55, 4, 45, 186, 138, 59, 141, 74, 111, 176, 121, 65, 65, 121, 176, 111, 74, 141, 59, 186, 186, 138, 186, 254, 188, 59, 139, 78, 82, 125, 84, 43, 43, 84, 125, 82, 158, 118, 3, 233, 252, 23, 86, 53, 56, 72, 129, 180, 107, 106, 181, 129, 73, 53, 53, 153, 117, 187, 187, 254, 109, 65, 58, 58, 100, 135, 80, 80, 135, 100, 58, 125, 0, 255, 255, 0, 49, 0, 0, 3, 115, 6, 54, 2, 38, 0, 38, 0, 0, 0, 7, 0, 216, 0, 0, 1, 115, 255, 255, 255, 252, 255, 233, 3, 174, 4, 194, 2, 38, 0, 70, 0, 0, 0, 6, 0, 216, 0, 255, 255, 255, 0, 49, 0, 0, 3, 115, 6, 121, 2, 38, 0, 38, 0, 0, 0, 7, 0, 217, 0, 0, 1, 115, 255, 255, 255, 252, 255, 233, 3, 174, 5, 5, 2, 38, 0, 70, 0, 0, 0, 6, 0, 217, 0, 255, 255, 255, 0, 49, 0, 0, 3, 115, 6, 140, 2, 38, 0, 38, 0, 0, 0, 7, 0, 218, 0, 0, 1, 115, 255, 255, 255, 252, 255, 233, 3, 174, 5, 25, 2, 38, 0, 70, 0, 0, 0, 6, 0, 218, 0, 0, 0, 1, 0, 49, 254, 133, 4, 0, 5, 25, 0, 24, 0, 123, 179, 16, 12, 7, 4, 43, 179, 21, 10, 3, 4, 43, 180, 218, 3, 234, 3, 2, 93, 64, 27, 9, 3, 25, 3, 41, 3, 57, 3, 73, 3, 89, 3, 105, 3, 121, 3, 137, 3, 153, 3, 169, 3, 185, 3, 201, 3, 13, 93, 176, 16, 16, 176, 11, 208, 0, 176, 0, 47, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 21, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 176, 0, 69, 88, 176, 18, 47, 27, 177, 18, 15, 62, 89, 179, 13, 6, 14, 4, 43, 176, 8, 16, 177, 10, 6, 244, 176, 6, 16, 177, 16, 6, 244, 176, 17, 208, 48, 49, 1, 34, 38, 53, 52, 54, 55, 33, 17, 33, 21, 33, 17, 33, 21, 33, 17, 33, 21, 23, 6, 21, 20, 22, 51, 4, 0, 125, 143, 30, 23, 253, 8, 3, 66, 253, 71, 2, 2, 253, 254, 2, 185, 2, 49, 108, 80, 254, 133, 125, 102, 48, 75, 29, 5, 25, 117, 254, 45, 117, 254, 25, 115, 2, 45, 76, 72, 96, 0, 0, 2, 255, 252, 254, 133, 3, 174, 3, 186, 0, 39, 0, 48, 0, 189, 179, 3, 10, 10, 4, 43, 180, 218, 10, 234, 10, 2, 93, 64, 27, 9, 10, 25, 10, 41, 10, 57, 10, 73, 10, 89, 10, 105, 10, 121, 10, 137, 10, 153, 10, 169, 10, 185, 10, 201, 10, 13, 93, 178, 13, 10, 3, 17, 18, 57, 0, 176, 7, 47, 176, 0, 69, 88, 176, 25, 47, 27, 177, 25, 19, 62, 89, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 15, 62, 89, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 15, 62, 89, 179, 40, 6, 30, 4, 43, 176, 15, 16, 177, 34, 6, 244, 64, 27, 7, 34, 23, 34, 39, 34, 55, 34, 71, 34, 87, 34, 103, 34, 119, 34, 135, 34, 151, 34, 167, 34, 183, 34, 199, 34, 13, 93, 180, 214, 34, 230, 34, 2, 93, 176, 25, 16, 177, 43, 6, 244, 180, 217, 43, 233, 43, 2, 93, 64, 27, 8, 43, 24, 43, 40, 43, 56, 43, 72, 43, 88, 43, 104, 43, 120, 43, 136, 43, 152, 43, 168, 43, 184, 43, 200, 43, 13, 93, 48, 49, 37, 6, 6, 21, 20, 22, 51, 21, 34, 38, 53, 52, 54, 55, 6, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 30, 2, 21, 33, 22, 22, 51, 50, 54, 55, 23, 6, 3, 38, 38, 35, 34, 14, 2, 7, 2, 147, 22, 25, 109, 80, 125, 144, 23, 18, 43, 43, 108, 180, 131, 72, 65, 123, 176, 109, 119, 178, 119, 57, 252, 219, 15, 186, 149, 105, 164, 41, 96, 94, 2, 23, 176, 129, 66, 112, 86, 58, 8, 2, 22, 66, 35, 72, 96, 90, 125, 102, 41, 66, 29, 7, 72, 129, 178, 109, 106, 179, 131, 73, 80, 141, 196, 119, 148, 176, 86, 64, 66, 131, 1, 232, 153, 150, 43, 80, 113, 67, 255, 255, 0, 49, 0, 0, 3, 115, 6, 203, 2, 38, 0, 38, 0, 0, 0, 7, 0, 223, 0, 0, 1, 115, 255, 255, 255, 252, 255, 233, 3, 174, 5, 87, 2, 38, 0, 70, 0, 0, 0, 6, 0, 223, 0, 255, 255, 255, 255, 236, 255, 233, 3, 215, 6, 203, 2, 38, 0, 40, 0, 0, 0, 7, 0, 214, 0, 0, 1, 115, 255, 255, 255, 254, 254, 117, 3, 115, 5, 87, 2, 38, 0, 72, 0, 0, 0, 6, 0, 214, 0, 255, 255, 255, 255, 236, 255, 233, 3, 215, 6, 121, 2, 38, 0, 40, 0, 0, 0, 7, 0, 217, 0, 0, 1, 115, 255, 255, 255, 254, 254, 117, 3, 115, 5, 5, 2, 38, 0, 72, 0, 0, 0, 6, 0, 217, 0, 255, 255, 255, 255, 236, 255, 233, 3, 215, 6, 140, 2, 38, 0, 40, 0, 0, 0, 7, 0, 218, 0, 0, 1, 115, 255, 255, 255, 254, 254, 117, 3, 115, 5, 25, 2, 38, 0, 72, 0, 0, 0, 6, 0, 218, 0, 0, 255, 255, 255, 236, 254, 139, 3, 215, 5, 47, 2, 38, 0, 40, 0, 0, 0, 6, 0, 226, 0, 0, 0, 3, 255, 254, 254, 117, 3, 115, 5, 211, 0, 3, 0, 35, 0, 50, 1, 27, 176, 51, 47, 176, 52, 47, 176, 51, 16, 176, 25, 208, 176, 25, 47, 176, 52, 16, 176, 4, 220, 178, 0, 25, 4, 17, 18, 57, 178, 2, 25, 4, 17, 18, 57, 176, 25, 16, 177, 44, 12, 244, 64, 27, 6, 44, 22, 44, 38, 44, 54, 44, 70, 44, 86, 44, 102, 44, 118, 44, 134, 44, 150, 44, 166, 44, 182, 44, 198, 44, 13, 93, 180, 213, 44, 229, 44, 2, 93, 176, 13, 208, 176, 13, 47, 176, 4, 16, 177, 19, 8, 244, 176, 33, 208, 176, 19, 16, 176, 36, 208, 0, 176, 1, 47, 176, 0, 47, 176, 0, 69, 88, 176, 34, 47, 27, 177, 34, 19, 62, 89, 176, 0, 69, 88, 176, 30, 47, 27, 177, 30, 19, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 176, 0, 69, 88, 176, 19, 47, 27, 177, 19, 15, 62, 89, 176, 0, 69, 88, 176, 22, 47, 27, 177, 22, 15, 62, 89, 179, 16, 4, 9, 4, 43, 176, 22, 16, 177, 47, 6, 244, 64, 27, 7, 47, 23, 47, 39, 47, 55, 47, 71, 47, 87, 47, 103, 47, 119, 47, 135, 47, 151, 47, 167, 47, 183, 47, 199, 47, 13, 93, 180, 214, 47, 230, 47, 2, 93, 178, 20, 22, 47, 17, 18, 57, 176, 30, 16, 177, 39, 6, 244, 180, 217, 39, 233, 39, 2, 93, 64, 27, 8, 39, 24, 39, 40, 39, 56, 39, 72, 39, 88, 39, 104, 39, 120, 39, 136, 39, 152, 39, 168, 39, 184, 39, 200, 39, 13, 93, 178, 33, 30, 39, 17, 18, 57, 48, 49, 1, 1, 51, 3, 1, 20, 14, 2, 35, 34, 38, 39, 55, 22, 22, 51, 50, 54, 53, 53, 6, 35, 34, 38, 53, 52, 62, 2, 51, 50, 22, 23, 53, 51, 7, 38, 38, 35, 34, 14, 2, 21, 20, 22, 51, 50, 54, 55, 1, 27, 1, 18, 96, 186, 1, 160, 66, 119, 161, 99, 139, 195, 71, 96, 43, 162, 104, 142, 165, 122, 156, 219, 250, 65, 121, 174, 109, 76, 143, 59, 138, 138, 59, 141, 78, 82, 125, 82, 43, 166, 166, 78, 141, 59, 4, 94, 1, 117, 254, 139, 251, 172, 96, 150, 104, 55, 104, 98, 74, 65, 88, 143, 135, 100, 108, 250, 217, 106, 179, 131, 73, 53, 53, 84, 217, 65, 58, 58, 100, 137, 78, 160, 190, 59, 66, 255, 255, 0, 49, 0, 0, 3, 115, 6, 203, 2, 38, 0, 41, 0, 0, 0, 7, 0, 214, 0, 0, 1, 115, 255, 255, 0, 49, 0, 0, 3, 115, 6, 205, 2, 38, 0, 73, 0, 0, 0, 7, 0, 214, 0, 0, 1, 117, 0, 2, 255, 119, 0, 0, 4, 47, 5, 25, 0, 19, 0, 23, 0, 153, 176, 24, 47, 176, 25, 47, 176, 4, 220, 176, 0, 208, 176, 4, 16, 177, 5, 8, 244, 176, 24, 16, 176, 9, 208, 176, 9, 47, 177, 8, 12, 244, 176, 9, 16, 176, 13, 208, 176, 8, 16, 176, 15, 208, 176, 5, 16, 176, 17, 208, 176, 5, 16, 176, 20, 208, 176, 8, 16, 176, 22, 208, 0, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 21, 62, 89, 176, 0, 69, 88, 176, 18, 47, 27, 177, 18, 21, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 15, 62, 89, 179, 1, 1, 2, 4, 43, 179, 20, 6, 6, 4, 43, 176, 2, 16, 176, 10, 208, 176, 1, 16, 176, 12, 208, 176, 1, 16, 176, 16, 208, 176, 2, 16, 176, 21, 208, 48, 49, 1, 51, 21, 35, 17, 35, 17, 33, 17, 35, 17, 35, 53, 51, 53, 51, 21, 33, 53, 51, 3, 17, 33, 17, 3, 115, 188, 188, 138, 253, 209, 137, 186, 186, 137, 2, 47, 138, 138, 253, 209, 4, 72, 113, 252, 41, 2, 92, 253, 164, 3, 215, 113, 209, 209, 209, 253, 184, 1, 6, 254, 250, 0, 0, 1, 255, 119, 0, 0, 3, 115, 5, 25, 0, 27, 0, 175, 176, 28, 47, 176, 29, 47, 176, 0, 220, 177, 1, 8, 244, 176, 28, 16, 176, 12, 208, 176, 12, 47, 177, 11, 12, 244, 176, 12, 16, 176, 16, 208, 176, 11, 16, 176, 18, 208, 176, 11, 16, 176, 22, 208, 178, 23, 12, 0, 17, 18, 57, 0, 176, 0, 69, 88, 176, 17, 47, 27, 177, 17, 21, 62, 89, 176, 0, 69, 88, 176, 25, 47, 27, 177, 25, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 15, 62, 89, 179, 16, 1, 13, 4, 43, 176, 25, 16, 177, 5, 6, 244, 180, 217, 5, 233, 5, 2, 93, 64, 27, 8, 5, 24, 5, 40, 5, 56, 5, 72, 5, 88, 5, 104, 5, 120, 5, 136, 5, 152, 5, 168, 5, 184, 5, 200, 5, 13, 93, 176, 16, 16, 176, 19, 208, 176, 13, 16, 176, 21, 208, 178, 23, 0, 17, 17, 18, 57, 48, 49, 33, 35, 17, 52, 38, 35, 34, 14, 2, 21, 17, 35, 17, 35, 53, 51, 53, 51, 21, 51, 21, 35, 17, 18, 51, 32, 17, 3, 115, 138, 108, 121, 76, 123, 86, 45, 137, 186, 186, 137, 187, 187, 99, 254, 1, 88, 2, 63, 125, 138, 70, 117, 151, 82, 254, 94, 3, 238, 112, 187, 187, 112, 254, 204, 1, 0, 254, 133, 0, 255, 255, 0, 78, 0, 0, 3, 78, 6, 115, 2, 38, 0, 42, 0, 0, 0, 7, 0, 215, 0, 0, 1, 115, 255, 255, 0, 78, 0, 0, 3, 78, 4, 255, 2, 38, 0, 213, 0, 0, 0, 6, 0, 215, 0, 255, 255, 255, 0, 186, 0, 0, 2, 233, 6, 54, 2, 38, 0, 42, 0, 0, 0, 7, 0, 216, 0, 0, 1, 115, 255, 255, 0, 186, 0, 0, 2, 233, 4, 194, 2, 38, 0, 213, 0, 0, 0, 6, 0, 216, 0, 255, 255, 255, 0, 182, 0, 0, 2, 240, 6, 121, 2, 38, 0, 42, 0, 0, 0, 7, 0, 217, 0, 0, 1, 115, 255, 255, 0, 182, 0, 0, 2, 240, 5, 5, 2, 38, 0, 213, 0, 0, 0, 6, 0, 217, 0, 255, 0, 1, 0, 186, 254, 133, 3, 117, 5, 25, 0, 23, 0, 130, 179, 16, 8, 9, 4, 43, 179, 20, 10, 3, 4, 43, 180, 218, 3, 234, 3, 2, 93, 64, 27, 9, 3, 25, 3, 41, 3, 57, 3, 73, 3, 89, 3, 105, 3, 121, 3, 137, 3, 153, 3, 169, 3, 185, 3, 201, 3, 13, 93, 178, 6, 3, 20, 17, 18, 57, 0, 176, 0, 47, 176, 0, 69, 88, 176, 12, 47, 27, 177, 12, 21, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 176, 0, 69, 88, 176, 18, 47, 27, 177, 18, 15, 62, 89, 176, 6, 16, 177, 8, 6, 244, 176, 12, 16, 177, 10, 6, 244, 176, 14, 208, 176, 15, 208, 176, 8, 16, 176, 16, 208, 176, 17, 208, 48, 49, 1, 34, 38, 53, 52, 54, 55, 33, 53, 51, 17, 35, 53, 33, 21, 35, 17, 51, 21, 6, 21, 20, 22, 51, 3, 117, 125, 144, 31, 23, 254, 28, 211, 211, 2, 47, 210, 210, 49, 109, 80, 254, 133, 125, 102, 48, 75, 29, 117, 4, 47, 117, 117, 251, 209, 117, 45, 76, 72, 96, 0, 2, 0, 186, 254, 133, 3, 117, 5, 25, 0, 21, 0, 25, 0, 164, 179, 14, 14, 8, 4, 43, 179, 18, 10, 3, 4, 43, 180, 218, 3, 234, 3, 2, 93, 64, 27, 9, 3, 25, 3, 41, 3, 57, 3, 73, 3, 89, 3, 105, 3, 121, 3, 137, 3, 153, 3, 169, 3, 185, 3, 201, 3, 13, 93, 178, 6, 3, 18, 17, 18, 57, 176, 14, 16, 177, 9, 8, 244, 176, 8, 16, 176, 11, 208, 178, 23, 8, 14, 17, 18, 57, 176, 23, 47, 177, 22, 8, 244, 0, 176, 0, 47, 176, 0, 69, 88, 176, 24, 47, 27, 177, 24, 21, 62, 89, 176, 0, 69, 88, 176, 12, 47, 27, 177, 12, 19, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 176, 0, 69, 88, 176, 16, 47, 27, 177, 16, 15, 62, 89, 176, 6, 16, 177, 8, 6, 244, 176, 12, 16, 177, 10, 6, 244, 176, 8, 16, 176, 14, 208, 176, 15, 208, 48, 49, 1, 34, 38, 53, 52, 54, 55, 33, 53, 51, 17, 35, 53, 33, 17, 51, 21, 6, 21, 20, 22, 51, 1, 35, 53, 51, 3, 117, 125, 144, 31, 23, 254, 28, 211, 211, 1, 93, 210, 49, 109, 80, 254, 186, 186, 186, 254, 133, 125, 102, 48, 75, 29, 117, 2, 186, 117, 252, 209, 117, 45, 76, 72, 96, 5, 127, 187, 0, 255, 255, 0, 186, 0, 0, 2, 233, 6, 140, 2, 38, 0, 42, 0, 0, 0, 7, 0, 218, 0, 0, 1, 115, 0, 2, 0, 0, 254, 117, 3, 164, 5, 25, 0, 16, 0, 28, 0, 103, 176, 29, 47, 176, 30, 47, 176, 11, 220, 177, 8, 12, 244, 176, 29, 16, 176, 20, 208, 176, 20, 47, 177, 27, 8, 244, 0, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 21, 62, 89, 176, 0, 69, 88, 176, 23, 47, 27, 177, 23, 21, 62, 89, 176, 0, 69, 88, 176, 17, 47, 27, 177, 17, 15, 62, 89, 179, 3, 6, 14, 4, 43, 176, 17, 16, 177, 19, 6, 244, 176, 23, 16, 177, 21, 6, 244, 176, 25, 208, 176, 26, 208, 176, 19, 16, 176, 27, 208, 176, 28, 208, 48, 49, 5, 22, 22, 51, 50, 62, 2, 53, 17, 51, 17, 20, 2, 35, 34, 39, 1, 33, 53, 51, 17, 35, 53, 33, 21, 35, 17, 51, 1, 0, 49, 127, 72, 92, 115, 61, 23, 137, 211, 217, 211, 123, 1, 133, 253, 209, 211, 211, 2, 47, 210, 210, 170, 57, 52, 74, 115, 143, 72, 4, 156, 251, 100, 248, 254, 240, 129, 1, 10, 117, 4, 47, 117, 117, 251, 209, 0, 0, 4, 0, 0, 254, 117, 3, 164, 5, 25, 0, 3, 0, 13, 0, 17, 0, 36, 0, 179, 179, 12, 14, 6, 4, 43, 179, 34, 12, 29, 4, 43, 176, 12, 16, 177, 7, 12, 244, 176, 6, 16, 176, 9, 208, 176, 34, 16, 176, 38, 220, 0, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 21, 62, 89, 176, 0, 69, 88, 176, 16, 47, 27, 177, 16, 21, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 19, 62, 89, 176, 0, 69, 88, 176, 32, 47, 27, 177, 32, 19, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 176, 0, 69, 88, 176, 29, 47, 27, 177, 29, 15, 62, 89, 176, 0, 69, 88, 176, 34, 47, 27, 177, 34, 15, 62, 89, 179, 24, 6, 18, 4, 43, 176, 2, 16, 177, 0, 5, 244, 176, 4, 16, 177, 6, 6, 244, 176, 10, 16, 177, 8, 6, 244, 176, 6, 16, 176, 12, 208, 176, 13, 208, 176, 0, 16, 176, 14, 208, 176, 15, 208, 176, 8, 16, 176, 30, 208, 176, 31, 208, 48, 49, 1, 35, 53, 51, 19, 33, 53, 51, 17, 35, 53, 33, 17, 51, 1, 35, 53, 51, 1, 34, 39, 55, 22, 22, 51, 50, 62, 2, 53, 17, 35, 53, 33, 17, 20, 6, 1, 117, 187, 187, 186, 253, 209, 211, 211, 1, 92, 211, 1, 117, 187, 187, 254, 115, 246, 99, 105, 37, 117, 86, 67, 92, 54, 22, 211, 1, 92, 188, 4, 94, 187, 250, 231, 117, 2, 186, 117, 252, 209, 3, 233, 187, 249, 92, 202, 72, 76, 82, 39, 72, 102, 66, 3, 47, 117, 252, 92, 180, 215, 255, 255, 255, 254, 255, 233, 3, 115, 6, 203, 2, 38, 0, 43, 0, 0, 0, 7, 0, 214, 0, 0, 1, 115, 0, 2, 0, 4, 254, 117, 3, 88, 5, 88, 0, 18, 0, 24, 0, 44, 179, 16, 12, 11, 4, 43, 0, 176, 24, 47, 176, 20, 47, 176, 22, 47, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 19, 62, 89, 179, 6, 6, 0, 4, 43, 176, 14, 16, 177, 12, 6, 244, 48, 49, 1, 34, 39, 55, 22, 22, 51, 50, 62, 2, 53, 17, 35, 53, 33, 17, 20, 6, 1, 7, 39, 7, 39, 1, 1, 92, 246, 98, 105, 36, 117, 86, 68, 92, 53, 23, 211, 1, 92, 189, 1, 68, 53, 242, 246, 53, 1, 41, 254, 117, 202, 72, 76, 82, 39, 72, 102, 66, 3, 47, 117, 252, 92, 180, 215, 5, 196, 67, 205, 207, 65, 1, 35, 0, 255, 255, 0, 49, 254, 139, 3, 158, 5, 25, 2, 38, 0, 44, 0, 0, 0, 6, 0, 226, 0, 0, 255, 255, 0, 49, 254, 139, 3, 162, 5, 25, 2, 38, 0, 76, 0, 0, 0, 6, 0, 226, 0, 0, 0, 1, 0, 49, 0, 0, 3, 162, 3, 164, 0, 11, 0, 74, 179, 4, 12, 5, 4, 43, 176, 4, 16, 176, 7, 208, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 19, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 178, 8, 0, 6, 17, 18, 57, 48, 49, 33, 35, 1, 7, 17, 35, 17, 51, 17, 1, 51, 1, 3, 162, 195, 254, 131, 168, 137, 137, 2, 19, 196, 254, 45, 1, 162, 154, 254, 248, 3, 164, 254, 10, 1, 246, 254, 84, 255, 255, 0, 49, 0, 0, 3, 115, 6, 199, 2, 38, 0, 45, 0, 0, 0, 7, 0, 139, 0, 0, 1, 115, 255, 255, 0, 186, 0, 0, 2, 233, 6, 201, 2, 38, 0, 77, 0, 0, 0, 7, 0, 139, 0, 0, 1, 117, 255, 255, 0, 49, 254, 139, 3, 115, 5, 25, 2, 38, 0, 45, 0, 0, 0, 6, 0, 226, 0, 0, 255, 255, 0, 186, 254, 139, 2, 233, 5, 25, 2, 38, 0, 77, 0, 0, 0, 6, 0, 226, 0, 0, 255, 255, 0, 49, 0, 0, 3, 115, 5, 25, 2, 38, 0, 45, 0, 0, 0, 7, 1, 119, 0, 213, 254, 234, 255, 255, 0, 186, 0, 0, 3, 162, 5, 25, 2, 38, 0, 77, 0, 0, 0, 7, 1, 119, 1, 92, 254, 234, 255, 255, 0, 49, 0, 0, 3, 115, 5, 25, 2, 38, 0, 45, 0, 0, 0, 7, 0, 193, 0, 186, 0, 186, 255, 255, 0, 186, 0, 0, 4, 94, 5, 25, 2, 38, 0, 77, 0, 0, 0, 7, 0, 193, 2, 47, 0, 0, 0, 1, 255, 94, 0, 0, 3, 115, 5, 25, 0, 13, 0, 79, 179, 12, 12, 1, 4, 43, 176, 1, 16, 176, 5, 208, 176, 12, 16, 176, 7, 208, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 178, 2, 0, 6, 17, 18, 57, 178, 3, 0, 6, 17, 18, 57, 178, 8, 0, 6, 17, 18, 57, 178, 9, 0, 6, 17, 18, 57, 177, 12, 3, 244, 48, 49, 33, 33, 17, 7, 53, 55, 17, 51, 17, 55, 21, 7, 17, 33, 3, 115, 252, 190, 211, 211, 137, 211, 211, 2, 185, 2, 51, 69, 127, 69, 2, 103, 253, 200, 70, 127, 70, 254, 21, 0, 1, 0, 186, 0, 0, 2, 233, 5, 25, 0, 17, 0, 137, 179, 4, 14, 3, 4, 43, 176, 4, 16, 177, 0, 8, 244, 177, 7, 14, 244, 176, 4, 16, 176, 8, 208, 176, 5, 16, 176, 9, 208, 176, 7, 16, 176, 10, 208, 176, 3, 16, 176, 12, 208, 176, 0, 16, 176, 14, 208, 178, 15, 3, 4, 17, 18, 57, 176, 3, 16, 176, 16, 208, 0, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 21, 62, 89, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 15, 62, 89, 176, 3, 16, 177, 1, 3, 244, 178, 5, 11, 3, 17, 18, 57, 178, 6, 11, 3, 17, 18, 57, 176, 11, 16, 177, 9, 3, 244, 176, 13, 208, 176, 14, 208, 178, 15, 11, 3, 17, 18, 57, 178, 16, 11, 3, 17, 18, 57, 48, 49, 1, 17, 35, 53, 33, 17, 55, 21, 7, 17, 51, 21, 33, 53, 51, 17, 7, 53, 1, 141, 211, 1, 93, 210, 210, 210, 253, 209, 211, 211, 2, 178, 1, 240, 119, 253, 200, 70, 127, 70, 254, 21, 119, 119, 1, 188, 69, 127, 0, 255, 255, 0, 49, 0, 0, 3, 115, 6, 199, 2, 38, 0, 47, 0, 0, 0, 7, 0, 139, 0, 0, 1, 115, 255, 255, 0, 49, 0, 0, 3, 115, 5, 83, 2, 38, 0, 79, 0, 0, 0, 6, 0, 139, 0, 255, 255, 255, 0, 49, 254, 139, 3, 115, 5, 25, 2, 38, 0, 47, 0, 0, 0, 6, 0, 226, 0, 0, 255, 255, 0, 49, 254, 139, 3, 115, 3, 186, 2, 38, 0, 79, 0, 0, 0, 6, 0, 226, 0, 0, 255, 255, 0, 49, 0, 0, 3, 115, 6, 203, 2, 38, 0, 47, 0, 0, 0, 7, 0, 223, 0, 0, 1, 115, 255, 255, 0, 49, 0, 0, 3, 115, 5, 87, 2, 38, 0, 79, 0, 0, 0, 6, 0, 223, 0, 255, 255, 255, 0, 1, 0, 0, 3, 115, 6, 47, 2, 38, 0, 79, 0, 0, 0, 7, 1, 119, 254, 116, 0, 0, 0, 1, 0, 49, 254, 117, 3, 115, 5, 25, 0, 22, 0, 94, 176, 23, 47, 176, 24, 47, 176, 0, 220, 177, 20, 8, 244, 176, 14, 208, 176, 14, 47, 176, 23, 16, 176, 17, 208, 176, 17, 47, 177, 16, 12, 244, 0, 176, 0, 69, 88, 176, 18, 47, 27, 177, 18, 21, 62, 89, 176, 0, 69, 88, 176, 21, 47, 27, 177, 21, 21, 62, 89, 176, 0, 69, 88, 176, 16, 47, 27, 177, 16, 15, 62, 89, 179, 9, 6, 3, 4, 43, 178, 15, 16, 18, 17, 18, 57, 178, 20, 16, 18, 17, 18, 57, 48, 49, 37, 20, 2, 35, 34, 39, 55, 22, 22, 51, 50, 62, 2, 55, 1, 17, 35, 17, 51, 1, 17, 51, 3, 115, 211, 217, 211, 123, 86, 49, 127, 72, 65, 94, 66, 41, 10, 253, 223, 137, 193, 1, 247, 138, 125, 248, 254, 240, 129, 96, 57, 52, 39, 66, 88, 49, 4, 117, 251, 176, 5, 25, 251, 227, 4, 29, 0, 1, 0, 49, 254, 117, 3, 115, 3, 186, 0, 32, 0, 161, 176, 33, 47, 176, 34, 47, 176, 27, 220, 177, 8, 8, 244, 176, 33, 16, 176, 19, 208, 176, 19, 47, 177, 18, 12, 244, 176, 21, 208, 178, 22, 19, 27, 17, 18, 57, 0, 176, 0, 69, 88, 176, 20, 47, 27, 177, 20, 19, 62, 89, 176, 0, 69, 88, 176, 24, 47, 27, 177, 24, 19, 62, 89, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 15, 62, 89, 176, 0, 69, 88, 176, 18, 47, 27, 177, 18, 15, 62, 89, 176, 0, 69, 88, 176, 27, 47, 27, 177, 27, 15, 62, 89, 179, 3, 6, 30, 4, 43, 176, 24, 16, 177, 12, 6, 244, 180, 217, 12, 233, 12, 2, 93, 64, 27, 8, 12, 24, 12, 40, 12, 56, 12, 72, 12, 88, 12, 104, 12, 120, 12, 136, 12, 152, 12, 168, 12, 184, 12, 200, 12, 13, 93, 178, 22, 8, 24, 17, 18, 57, 48, 49, 5, 22, 22, 51, 50, 62, 2, 53, 17, 52, 38, 35, 34, 14, 2, 21, 17, 35, 17, 51, 21, 18, 51, 32, 17, 17, 20, 6, 35, 34, 39, 1, 131, 25, 67, 31, 68, 92, 53, 22, 108, 121, 76, 123, 86, 45, 137, 137, 99, 254, 1, 88, 189, 184, 90, 68, 250, 14, 15, 39, 72, 102, 66, 2, 63, 125, 138, 70, 117, 151, 82, 254, 94, 3, 164, 234, 1, 0, 254, 133, 253, 193, 180, 215, 26, 255, 255, 255, 223, 255, 233, 3, 199, 6, 54, 2, 38, 0, 48, 0, 0, 0, 7, 0, 216, 0, 0, 1, 115, 255, 255, 255, 236, 255, 233, 3, 188, 4, 194, 2, 38, 0, 80, 0, 0, 0, 6, 0, 216, 0, 255, 255, 255, 255, 223, 255, 233, 3, 199, 6, 121, 2, 38, 0, 48, 0, 0, 0, 7, 0, 217, 0, 0, 1, 115, 255, 255, 255, 236, 255, 233, 3, 188, 5, 5, 2, 38, 0, 80, 0, 0, 0, 6, 0, 217, 0, 255, 255, 255, 255, 223, 255, 233, 3, 199, 6, 234, 2, 38, 0, 48, 0, 0, 0, 7, 0, 221, 0, 0, 1, 115, 255, 255, 255, 236, 255, 233, 3, 188, 5, 118, 2, 38, 0, 80, 0, 0, 0, 6, 0, 221, 0, 255, 255, 255, 0, 49, 0, 0, 3, 176, 6, 199, 2, 38, 0, 51, 0, 0, 0, 7, 0, 139, 0, 0, 1, 115, 255, 255, 0, 0, 0, 0, 3, 158, 5, 84, 2, 38, 0, 83, 0, 0, 0, 6, 0, 139, 0, 0, 255, 255, 0, 49, 254, 139, 3, 176, 5, 25, 2, 38, 0, 51, 0, 0, 0, 6, 0, 226, 0, 0, 255, 255, 0, 0, 254, 139, 3, 158, 3, 186, 2, 38, 0, 83, 0, 0, 0, 6, 0, 226, 0, 0, 255, 255, 0, 49, 0, 0, 3, 176, 6, 203, 2, 38, 0, 51, 0, 0, 0, 7, 0, 223, 0, 0, 1, 115, 255, 255, 0, 0, 0, 0, 3, 158, 5, 88, 2, 38, 0, 83, 0, 0, 0, 6, 0, 223, 0, 0, 255, 255, 0, 25, 255, 233, 3, 131, 6, 199, 2, 38, 0, 52, 0, 0, 0, 7, 0, 139, 0, 0, 1, 115, 255, 255, 255, 246, 255, 233, 3, 139, 5, 84, 2, 38, 0, 84, 0, 0, 0, 6, 0, 139, 0, 0, 255, 255, 0, 25, 255, 233, 3, 131, 6, 203, 2, 38, 0, 52, 0, 0, 0, 7, 0, 214, 0, 0, 1, 115, 255, 255, 255, 246, 255, 233, 3, 139, 5, 88, 2, 38, 0, 84, 0, 0, 0, 6, 0, 214, 0, 0, 0, 1, 0, 25, 254, 141, 3, 131, 5, 47, 0, 72, 0, 176, 179, 21, 10, 41, 4, 43, 179, 6, 13, 13, 4, 43, 179, 51, 11, 50, 4, 43, 176, 50, 16, 177, 0, 8, 244, 176, 21, 16, 176, 17, 208, 176, 50, 16, 176, 53, 208, 176, 41, 16, 177, 63, 12, 244, 176, 51, 16, 176, 74, 220, 0, 176, 0, 69, 88, 176, 50, 47, 27, 177, 50, 21, 62, 89, 176, 0, 69, 88, 176, 52, 47, 27, 177, 52, 19, 62, 89, 176, 0, 69, 88, 176, 46, 47, 27, 177, 46, 21, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 17, 62, 89, 176, 0, 69, 88, 176, 18, 47, 27, 177, 18, 15, 62, 89, 178, 17, 10, 46, 17, 18, 57, 178, 49, 10, 46, 17, 18, 57, 176, 46, 16, 177, 58, 6, 244, 180, 217, 58, 233, 58, 2, 93, 64, 27, 8, 58, 24, 58, 40, 58, 56, 58, 72, 58, 88, 58, 104, 58, 120, 58, 136, 58, 152, 58, 168, 58, 184, 58, 200, 58, 13, 93, 48, 49, 1, 20, 14, 2, 7, 21, 20, 7, 6, 35, 53, 50, 53, 53, 38, 38, 39, 21, 35, 17, 51, 20, 30, 2, 51, 50, 62, 2, 53, 52, 46, 2, 39, 46, 3, 53, 52, 62, 2, 51, 50, 22, 23, 53, 51, 17, 35, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 23, 30, 3, 3, 131, 55, 92, 123, 70, 82, 88, 147, 202, 96, 160, 47, 116, 116, 62, 96, 125, 65, 58, 98, 74, 43, 55, 93, 116, 60, 71, 142, 112, 70, 68, 110, 146, 77, 95, 161, 45, 121, 121, 49, 84, 108, 60, 53, 96, 72, 43, 51, 86, 113, 59, 74, 146, 116, 74, 1, 84, 74, 121, 92, 59, 10, 25, 147, 88, 95, 117, 213, 21, 8, 80, 71, 139, 1, 141, 67, 111, 80, 45, 33, 61, 88, 56, 63, 90, 64, 45, 22, 25, 55, 84, 121, 90, 80, 125, 86, 45, 78, 80, 136, 254, 139, 59, 103, 73, 43, 24, 53, 84, 58, 51, 72, 55, 45, 23, 26, 64, 90, 131, 0, 0, 1, 255, 246, 254, 141, 3, 139, 3, 186, 0, 59, 0, 165, 179, 50, 12, 33, 4, 43, 179, 6, 13, 13, 4, 43, 179, 0, 12, 23, 4, 43, 180, 218, 23, 234, 23, 2, 93, 64, 27, 9, 23, 25, 23, 41, 23, 57, 23, 73, 23, 89, 23, 105, 23, 121, 23, 137, 23, 153, 23, 169, 23, 185, 23, 201, 23, 13, 93, 64, 27, 6, 50, 22, 50, 38, 50, 54, 50, 70, 50, 86, 50, 102, 50, 118, 50, 134, 50, 150, 50, 166, 50, 182, 50, 198, 50, 13, 93, 180, 213, 50, 229, 50, 2, 93, 0, 176, 0, 69, 88, 176, 38, 47, 27, 177, 38, 19, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 17, 62, 89, 176, 38, 16, 177, 45, 6, 244, 180, 217, 45, 233, 45, 2, 93, 64, 27, 8, 45, 24, 45, 40, 45, 56, 45, 72, 45, 88, 45, 104, 45, 120, 45, 136, 45, 152, 45, 168, 45, 184, 45, 200, 45, 13, 93, 48, 49, 1, 20, 14, 2, 7, 21, 20, 7, 6, 35, 53, 50, 53, 53, 38, 38, 39, 55, 22, 22, 51, 32, 53, 52, 46, 2, 39, 46, 3, 53, 52, 62, 2, 51, 50, 22, 23, 7, 38, 38, 35, 34, 14, 2, 21, 20, 30, 2, 23, 30, 3, 3, 139, 59, 98, 125, 66, 82, 88, 147, 202, 122, 242, 90, 61, 103, 200, 107, 1, 53, 51, 86, 111, 61, 78, 154, 127, 77, 71, 119, 160, 86, 123, 194, 78, 55, 80, 164, 96, 43, 105, 90, 61, 51, 86, 111, 61, 76, 155, 127, 78, 1, 2, 68, 98, 65, 37, 6, 25, 147, 88, 95, 117, 213, 18, 5, 69, 60, 118, 65, 70, 160, 39, 49, 31, 18, 8, 11, 30, 60, 100, 82, 70, 102, 68, 32, 57, 53, 107, 56, 45, 15, 37, 59, 45, 39, 47, 31, 18, 8, 11, 30, 58, 100, 0, 255, 255, 0, 25, 255, 233, 3, 131, 6, 203, 2, 38, 0, 52, 0, 0, 0, 7, 0, 223, 0, 0, 1, 115, 255, 255, 255, 246, 255, 233, 3, 139, 5, 88, 2, 38, 0, 84, 0, 0, 0, 6, 0, 223, 0, 0, 255, 255, 0, 0, 254, 139, 3, 164, 5, 25, 2, 38, 0, 53, 0, 0, 0, 6, 0, 226, 0, 0, 255, 255, 0, 0, 254, 139, 3, 174, 5, 25, 2, 38, 0, 85, 0, 0, 0, 6, 0, 226, 0, 0, 255, 255, 0, 0, 0, 0, 3, 164, 6, 203, 2, 38, 0, 53, 0, 0, 0, 7, 0, 223, 0, 0, 1, 115, 255, 255, 0, 0, 255, 233, 3, 174, 5, 212, 2, 38, 0, 85, 0, 0, 0, 7, 1, 119, 1, 92, 255, 165, 0, 1, 0, 0, 0, 0, 3, 164, 5, 25, 0, 23, 0, 134, 176, 24, 47, 176, 15, 208, 176, 15, 47, 176, 7, 220, 178, 64, 7, 1, 93, 177, 2, 8, 244, 176, 7, 16, 176, 11, 208, 176, 15, 16, 177, 14, 13, 244, 176, 7, 16, 176, 19, 220, 178, 64, 19, 1, 93, 177, 18, 13, 244, 176, 2, 16, 176, 21, 208, 176, 18, 16, 176, 25, 220, 0, 176, 0, 69, 88, 176, 16, 47, 27, 177, 16, 21, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 179, 23, 1, 0, 4, 43, 176, 4, 16, 177, 2, 6, 244, 176, 6, 208, 176, 7, 208, 176, 0, 16, 176, 8, 208, 176, 23, 16, 176, 10, 208, 176, 16, 16, 177, 12, 6, 244, 176, 20, 208, 176, 21, 208, 48, 49, 1, 35, 17, 51, 21, 33, 53, 51, 17, 35, 53, 51, 17, 33, 17, 35, 17, 33, 17, 35, 17, 33, 17, 51, 2, 233, 210, 210, 253, 209, 211, 211, 211, 254, 232, 117, 3, 164, 117, 254, 232, 210, 2, 96, 254, 21, 117, 117, 1, 235, 113, 1, 211, 254, 188, 1, 185, 254, 71, 1, 68, 254, 45, 0, 0, 1, 0, 0, 255, 233, 3, 174, 5, 25, 0, 35, 0, 163, 179, 2, 12, 19, 4, 43, 176, 19, 16, 176, 23, 208, 176, 19, 16, 176, 27, 208, 176, 2, 16, 176, 29, 208, 176, 2, 16, 176, 33, 208, 0, 176, 0, 69, 88, 176, 28, 47, 27, 177, 28, 21, 62, 89, 176, 0, 69, 88, 176, 26, 47, 27, 177, 26, 19, 62, 89, 176, 0, 69, 88, 176, 30, 47, 27, 177, 30, 19, 62, 89, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 15, 62, 89, 179, 35, 1, 0, 4, 43, 176, 14, 16, 177, 7, 6, 244, 64, 27, 7, 7, 23, 7, 39, 7, 55, 7, 71, 7, 87, 7, 103, 7, 119, 7, 135, 7, 151, 7, 167, 7, 183, 7, 199, 7, 13, 93, 180, 214, 7, 230, 7, 2, 93, 176, 0, 16, 176, 20, 208, 176, 35, 16, 176, 22, 208, 176, 30, 16, 177, 24, 6, 244, 176, 25, 208, 176, 32, 208, 176, 33, 208, 48, 49, 1, 35, 21, 20, 30, 2, 51, 50, 54, 55, 23, 6, 6, 35, 34, 46, 2, 53, 53, 35, 53, 51, 17, 35, 53, 51, 17, 51, 17, 33, 21, 33, 17, 51, 2, 47, 211, 33, 59, 84, 54, 102, 137, 10, 115, 16, 199, 149, 82, 136, 96, 53, 211, 211, 211, 211, 137, 1, 141, 254, 115, 211, 1, 190, 104, 51, 90, 68, 39, 127, 101, 25, 147, 173, 54, 96, 135, 80, 104, 113, 1, 0, 117, 1, 117, 254, 139, 117, 255, 0, 0, 255, 255, 0, 49, 255, 233, 3, 115, 6, 115, 2, 38, 0, 54, 0, 0, 0, 7, 0, 215, 0, 0, 1, 115, 255, 255, 0, 49, 255, 233, 3, 115, 5, 0, 2, 38, 0, 86, 0, 0, 0, 6, 0, 215, 0, 0, 255, 255, 0, 49, 255, 233, 3, 115, 6, 54, 2, 38, 0, 54, 0, 0, 0, 7, 0, 216, 0, 0, 1, 115, 255, 255, 0, 49, 255, 233, 3, 115, 4, 195, 2, 38, 0, 86, 0, 0, 0, 6, 0, 216, 0, 0, 255, 255, 0, 49, 255, 233, 3, 115, 6, 121, 2, 38, 0, 54, 0, 0, 0, 7, 0, 217, 0, 0, 1, 115, 255, 255, 0, 49, 255, 233, 3, 115, 5, 6, 2, 38, 0, 86, 0, 0, 0, 6, 0, 217, 0, 0, 255, 255, 0, 49, 255, 233, 3, 115, 7, 62, 2, 38, 0, 54, 0, 0, 0, 7, 0, 219, 0, 0, 1, 115, 255, 255, 0, 49, 255, 233, 3, 115, 5, 203, 2, 38, 0, 86, 0, 0, 0, 6, 0, 219, 0, 0, 255, 255, 0, 49, 255, 233, 3, 115, 6, 234, 2, 38, 0, 54, 0, 0, 0, 7, 0, 221, 0, 0, 1, 115, 255, 255, 0, 49, 255, 233, 3, 115, 5, 119, 2, 38, 0, 86, 0, 0, 0, 6, 0, 221, 0, 0, 0, 1, 0, 49, 254, 133, 3, 115, 5, 25, 0, 38, 0, 167, 179, 17, 12, 14, 4, 43, 179, 35, 10, 3, 4, 43, 179, 30, 8, 27, 4, 43, 180, 218, 3, 234, 3, 2, 93, 64, 27, 9, 3, 25, 3, 41, 3, 57, 3, 73, 3, 89, 3, 105, 3, 121, 3, 137, 3, 153, 3, 169, 3, 185, 3, 201, 3, 13, 93, 178, 6, 3, 35, 17, 18, 57, 176, 30, 16, 176, 40, 220, 0, 176, 0, 47, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 21, 62, 89, 176, 0, 69, 88, 176, 28, 47, 27, 177, 28, 21, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 15, 62, 89, 177, 22, 6, 244, 64, 27, 7, 22, 23, 22, 39, 22, 55, 22, 71, 22, 87, 22, 103, 22, 119, 22, 135, 22, 151, 22, 167, 22, 183, 22, 199, 22, 13, 93, 180, 214, 22, 230, 22, 2, 93, 48, 49, 1, 34, 38, 53, 52, 54, 55, 6, 6, 35, 34, 46, 2, 53, 17, 51, 17, 20, 30, 2, 51, 50, 62, 2, 53, 17, 51, 17, 20, 6, 7, 6, 21, 20, 22, 51, 2, 248, 125, 143, 20, 18, 16, 33, 16, 109, 157, 101, 49, 137, 21, 61, 109, 88, 88, 111, 61, 20, 138, 127, 135, 50, 109, 80, 254, 133, 125, 102, 41, 64, 29, 2, 3, 70, 127, 182, 111, 3, 70, 252, 184, 59, 132, 108, 72, 72, 108, 132, 59, 3, 72, 252, 184, 180, 242, 43, 45, 76, 72, 96, 0, 0, 1, 0, 49, 254, 133, 3, 254, 3, 164, 0, 31, 0, 153, 179, 15, 12, 12, 4, 43, 179, 28, 10, 7, 4, 43, 176, 7, 16, 176, 3, 208, 176, 3, 47, 176, 7, 16, 176, 23, 208, 176, 7, 16, 177, 26, 8, 244, 0, 176, 0, 47, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 19, 62, 89, 176, 0, 69, 88, 176, 24, 47, 27, 177, 24, 19, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 176, 0, 69, 88, 176, 26, 47, 27, 177, 26, 15, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 15, 62, 89, 178, 8, 0, 13, 17, 18, 57, 177, 18, 6, 244, 64, 27, 7, 18, 23, 18, 39, 18, 55, 18, 71, 18, 87, 18, 103, 18, 119, 18, 135, 18, 151, 18, 167, 18, 183, 18, 199, 18, 13, 93, 180, 214, 18, 230, 18, 2, 93, 48, 49, 1, 34, 38, 53, 52, 54, 55, 35, 53, 2, 35, 32, 17, 17, 51, 17, 20, 22, 51, 50, 62, 2, 53, 17, 51, 17, 6, 21, 20, 22, 51, 3, 254, 125, 143, 30, 23, 62, 98, 254, 254, 168, 137, 109, 121, 76, 122, 86, 45, 138, 49, 108, 80, 254, 133, 125, 102, 48, 75, 29, 233, 255, 0, 1, 123, 2, 64, 253, 192, 125, 137, 70, 117, 151, 82, 1, 162, 252, 92, 45, 76, 72, 96, 255, 255, 255, 193, 0, 0, 3, 227, 6, 203, 2, 38, 0, 56, 0, 0, 0, 7, 0, 214, 0, 0, 1, 115, 255, 255, 255, 229, 0, 0, 3, 195, 5, 88, 2, 38, 0, 88, 0, 0, 0, 6, 0, 214, 0, 0, 255, 255, 255, 236, 0, 0, 3, 184, 6, 203, 2, 38, 0, 58, 0, 0, 0, 7, 0, 214, 0, 0, 1, 115, 255, 255, 255, 225, 254, 117, 3, 193, 5, 88, 2, 38, 0, 90, 0, 0, 0, 6, 0, 214, 0, 0, 255, 255, 0, 49, 0, 0, 3, 119, 6, 201, 2, 38, 0, 59, 0, 0, 0, 7, 0, 139, 0, 0, 1, 117, 255, 255, 0, 47, 0, 0, 3, 119, 5, 83, 2, 38, 0, 91, 0, 0, 0, 6, 0, 139, 0, 255, 255, 255, 0, 49, 0, 0, 3, 119, 6, 142, 2, 38, 0, 59, 0, 0, 0, 7, 0, 218, 0, 0, 1, 117, 255, 255, 0, 47, 0, 0, 3, 119, 5, 25, 2, 38, 0, 91, 0, 0, 0, 6, 0, 218, 0, 0, 255, 255, 0, 49, 0, 0, 3, 119, 6, 205, 2, 38, 0, 59, 0, 0, 0, 7, 0, 223, 0, 0, 1, 117, 255, 255, 0, 47, 0, 0, 3, 119, 5, 87, 2, 38, 0, 91, 0, 0, 0, 6, 0, 223, 0, 255, 0, 1, 0, 186, 0, 0, 3, 164, 5, 47, 0, 22, 0, 157, 179, 0, 14, 4, 4, 43, 176, 0, 16, 177, 5, 8, 244, 176, 4, 16, 176, 7, 208, 176, 5, 16, 176, 9, 208, 0, 176, 0, 69, 88, 176, 12, 47, 27, 177, 12, 21, 62, 89, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 21, 62, 89, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 19, 62, 89, 176, 0, 69, 88, 176, 22, 47, 27, 177, 22, 19, 62, 89, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 15, 62, 89, 177, 0, 6, 244, 176, 4, 208, 176, 5, 208, 176, 22, 16, 177, 6, 6, 244, 176, 7, 208, 176, 12, 16, 177, 19, 6, 244, 180, 217, 19, 233, 19, 2, 93, 64, 27, 8, 19, 24, 19, 40, 19, 56, 19, 72, 19, 88, 19, 104, 19, 120, 19, 136, 19, 152, 19, 168, 19, 184, 19, 200, 19, 13, 93, 48, 49, 37, 51, 21, 33, 53, 51, 17, 35, 53, 51, 52, 54, 51, 50, 22, 23, 21, 38, 38, 35, 34, 6, 21, 2, 23, 210, 253, 209, 211, 211, 211, 199, 201, 47, 65, 23, 29, 63, 43, 131, 131, 117, 117, 117, 2, 186, 117, 192, 203, 6, 4, 117, 4, 6, 133, 145, 0, 255, 255, 255, 193, 0, 0, 3, 164, 6, 203, 2, 38, 0, 142, 0, 0, 0, 7, 0, 139, 0, 0, 1, 119, 255, 255, 255, 219, 255, 233, 3, 186, 5, 86, 2, 38, 0, 158, 0, 0, 0, 6, 0, 139, 0, 2, 255, 255, 255, 211, 255, 233, 3, 211, 6, 203, 2, 38, 0, 143, 0, 0, 0, 7, 0, 139, 0, 0, 1, 119, 255, 255, 255, 213, 255, 233, 3, 209, 5, 86, 2, 38, 0, 159, 0, 0, 0, 6, 0, 139, 0, 2, 255, 255, 0, 25, 254, 139, 3, 131, 5, 47, 2, 38, 0, 52, 0, 0, 0, 6, 0, 226, 0, 0, 255, 255, 255, 246, 254, 139, 3, 139, 3, 186, 2, 38, 0, 84, 0, 0, 0, 6, 0, 226, 0, 0, 255, 255, 0, 0, 254, 139, 3, 164, 5, 25, 2, 38, 0, 53, 0, 0, 0, 6, 0, 226, 0, 0, 255, 255, 0, 0, 254, 139, 3, 174, 5, 25, 2, 38, 0, 85, 0, 0, 0, 6, 0, 226, 0, 0, 0, 1, 1, 141, 4, 94, 2, 70, 6, 47, 0, 3, 0, 9, 0, 176, 0, 47, 176, 1, 47, 48, 49, 1, 3, 35, 17, 2, 70, 84, 101, 6, 47, 254, 47, 1, 209, 0, 0, 3, 0, 0, 4, 94, 3, 164, 6, 47, 0, 3, 0, 7, 0, 11, 0, 57, 179, 8, 8, 9, 4, 43, 0, 176, 0, 47, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 21, 62, 89, 176, 6, 16, 177, 1, 5, 244, 176, 4, 208, 176, 5, 208, 176, 8, 208, 176, 9, 208, 48, 49, 1, 3, 35, 17, 1, 35, 53, 51, 5, 35, 53, 51, 2, 70, 84, 101, 2, 23, 187, 187, 253, 22, 186, 186, 6, 47, 254, 47, 1, 209, 254, 47, 187, 187, 187, 255, 255, 255, 197, 0, 0, 3, 227, 6, 47, 2, 34, 1, 129, 0, 0, 0, 3, 1, 119, 254, 140, 0, 0, 255, 255, 255, 95, 0, 0, 3, 115, 6, 47, 2, 34, 1, 133, 0, 0, 0, 3, 1, 119, 253, 210, 0, 0, 255, 255, 255, 95, 0, 0, 3, 115, 6, 47, 2, 35, 1, 119, 253, 210, 0, 0, 0, 2, 1, 135, 0, 0, 255, 255, 0, 23, 0, 0, 2, 233, 6, 47, 2, 35, 1, 119, 254, 138, 0, 0, 0, 2, 1, 137, 0, 0, 255, 255, 255, 91, 255, 233, 3, 199, 6, 47, 2, 34, 1, 143, 0, 0, 0, 3, 1, 119, 253, 206, 0, 0, 255, 255, 255, 91, 0, 0, 3, 184, 6, 47, 2, 34, 1, 148, 0, 0, 0, 3, 1, 119, 253, 206, 0, 0, 255, 255, 255, 91, 0, 0, 3, 188, 6, 47, 2, 34, 0, 157, 0, 0, 0, 3, 1, 119, 253, 206, 0, 0, 255, 255, 0, 0, 255, 233, 3, 164, 6, 47, 2, 38, 1, 167, 0, 0, 0, 6, 1, 120, 0, 0, 0, 2, 255, 197, 0, 0, 3, 227, 5, 25, 0, 7, 0, 10, 0, 48, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 179, 8, 3, 2, 4, 43, 48, 49, 33, 35, 3, 33, 3, 35, 1, 51, 19, 3, 3, 3, 227, 147, 123, 253, 252, 121, 147, 1, 178, 186, 125, 219, 219, 1, 117, 254, 139, 5, 25, 252, 213, 2, 161, 253, 95, 0, 0, 3, 0, 49, 0, 0, 3, 162, 5, 25, 0, 14, 0, 27, 0, 36, 0, 135, 179, 33, 12, 4, 4, 43, 179, 11, 12, 15, 4, 43, 176, 11, 16, 177, 28, 10, 244, 177, 0, 12, 244, 178, 13, 4, 0, 17, 18, 57, 180, 218, 15, 234, 15, 2, 93, 64, 27, 9, 15, 25, 15, 41, 15, 57, 15, 73, 15, 89, 15, 105, 15, 121, 15, 137, 15, 153, 15, 169, 15, 185, 15, 201, 15, 13, 93, 176, 33, 16, 176, 21, 208, 176, 11, 16, 176, 38, 220, 0, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 21, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 179, 23, 1, 31, 4, 43, 178, 13, 31, 23, 17, 18, 57, 176, 5, 16, 177, 20, 6, 244, 176, 3, 16, 177, 33, 6, 244, 48, 49, 1, 20, 6, 35, 33, 17, 33, 50, 30, 2, 21, 20, 7, 22, 3, 52, 46, 2, 35, 33, 17, 33, 50, 62, 2, 19, 52, 38, 35, 33, 17, 33, 50, 54, 3, 162, 242, 223, 254, 96, 1, 137, 82, 158, 125, 78, 203, 248, 182, 58, 90, 108, 50, 255, 0, 1, 0, 56, 108, 86, 56, 45, 175, 153, 254, 233, 1, 23, 153, 175, 1, 117, 187, 186, 5, 25, 27, 74, 131, 106, 203, 74, 76, 1, 97, 69, 88, 47, 17, 254, 69, 17, 49, 86, 253, 244, 135, 123, 253, 254, 129, 0, 1, 0, 49, 0, 0, 3, 164, 5, 25, 0, 5, 0, 42, 179, 3, 12, 0, 4, 43, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 21, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 176, 0, 16, 177, 2, 6, 244, 48, 49, 19, 33, 21, 33, 17, 35, 49, 3, 115, 253, 22, 137, 5, 25, 117, 251, 92, 0, 0, 2, 255, 197, 0, 0, 3, 227, 5, 25, 0, 3, 0, 6, 0, 33, 0, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 177, 4, 6, 244, 48, 49, 33, 33, 1, 51, 19, 1, 1, 3, 227, 251, 226, 1, 178, 186, 248, 254, 170, 254, 170, 5, 25, 251, 92, 4, 24, 251, 232, 0, 1, 0, 49, 0, 0, 3, 115, 5, 25, 0, 11, 0, 61, 179, 10, 12, 1, 4, 43, 176, 10, 16, 176, 5, 208, 0, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 179, 7, 6, 8, 4, 43, 176, 2, 16, 177, 4, 6, 244, 176, 0, 16, 177, 10, 6, 244, 48, 49, 33, 33, 17, 33, 21, 33, 17, 33, 21, 33, 17, 33, 3, 115, 252, 190, 3, 66, 253, 71, 2, 2, 253, 254, 2, 185, 5, 25, 117, 254, 45, 117, 254, 25, 0, 0, 1, 0, 49, 0, 0, 3, 119, 5, 25, 0, 13, 0, 85, 176, 14, 47, 176, 15, 47, 176, 0, 220, 176, 14, 16, 176, 6, 208, 176, 6, 47, 176, 1, 208, 178, 3, 6, 0, 17, 18, 57, 176, 6, 16, 177, 5, 13, 244, 176, 0, 16, 177, 11, 13, 244, 0, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 7, 16, 177, 3, 6, 244, 176, 0, 16, 177, 10, 6, 244, 48, 49, 33, 33, 53, 1, 33, 17, 35, 17, 33, 21, 1, 33, 17, 51, 3, 119, 252, 186, 2, 144, 253, 229, 117, 3, 49, 253, 119, 2, 41, 117, 117, 4, 47, 254, 192, 1, 181, 117, 251, 209, 1, 69, 0, 0, 1, 0, 49, 0, 0, 3, 115, 5, 25, 0, 11, 0, 96, 176, 12, 47, 176, 13, 47, 176, 0, 220, 177, 1, 8, 244, 176, 12, 16, 176, 5, 208, 176, 5, 47, 177, 4, 12, 244, 176, 7, 208, 176, 1, 16, 176, 9, 208, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 179, 9, 6, 2, 4, 43, 48, 49, 33, 35, 17, 33, 17, 35, 17, 51, 17, 33, 17, 51, 3, 115, 138, 253, 209, 137, 137, 2, 47, 138, 2, 92, 253, 164, 5, 25, 253, 184, 2, 72, 0, 3, 255, 223, 255, 233, 3, 199, 5, 47, 0, 3, 0, 23, 0, 43, 0, 233, 176, 44, 47, 176, 45, 47, 176, 4, 220, 176, 44, 16, 176, 14, 208, 176, 14, 47, 176, 4, 16, 177, 24, 8, 244, 180, 218, 24, 234, 24, 2, 93, 64, 27, 9, 24, 25, 24, 41, 24, 57, 24, 73, 24, 89, 24, 105, 24, 121, 24, 137, 24, 153, 24, 169, 24, 185, 24, 201, 24, 13, 93, 176, 14, 16, 177, 34, 12, 244, 64, 19, 6, 34, 22, 34, 38, 34, 54, 34, 70, 34, 86, 34, 102, 34, 118, 34, 134, 34, 9, 93, 64, 9, 150, 34, 166, 34, 182, 34, 198, 34, 4, 93, 180, 213, 34, 229, 34, 2, 93, 0, 176, 0, 69, 88, 176, 19, 47, 27, 177, 19, 21, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 15, 62, 89, 179, 1, 6, 2, 4, 43, 176, 19, 16, 177, 29, 6, 244, 180, 217, 29, 233, 29, 2, 93, 64, 27, 8, 29, 24, 29, 40, 29, 56, 29, 72, 29, 88, 29, 104, 29, 120, 29, 136, 29, 152, 29, 168, 29, 184, 29, 200, 29, 13, 93, 176, 9, 16, 177, 39, 6, 244, 64, 27, 7, 39, 23, 39, 39, 39, 55, 39, 71, 39, 87, 39, 103, 39, 119, 39, 135, 39, 151, 39, 167, 39, 183, 39, 199, 39, 13, 93, 180, 214, 39, 230, 39, 2, 93, 48, 49, 19, 33, 21, 33, 37, 20, 14, 2, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 30, 2, 7, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 62, 2, 229, 1, 215, 254, 41, 2, 226, 54, 118, 191, 137, 137, 191, 119, 53, 53, 121, 191, 135, 135, 191, 118, 56, 138, 49, 92, 135, 86, 107, 139, 84, 33, 33, 84, 139, 107, 106, 140, 84, 32, 2, 199, 117, 57, 131, 244, 186, 113, 113, 186, 244, 131, 131, 244, 188, 113, 113, 188, 244, 131, 129, 207, 146, 77, 100, 162, 198, 99, 98, 199, 159, 101, 101, 159, 199, 0, 1, 0, 186, 0, 0, 2, 233, 5, 25, 0, 11, 0, 61, 179, 10, 8, 3, 4, 43, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 177, 2, 6, 244, 176, 6, 16, 177, 4, 6, 244, 176, 8, 208, 176, 9, 208, 176, 2, 16, 176, 10, 208, 176, 11, 208, 48, 49, 33, 33, 53, 51, 17, 35, 53, 33, 21, 35, 17, 51, 2, 233, 253, 209, 211, 211, 2, 47, 210, 210, 117, 4, 47, 117, 117, 251, 209, 0, 1, 0, 49, 0, 0, 3, 158, 5, 25, 0, 11, 0, 74, 179, 4, 12, 5, 4, 43, 176, 4, 16, 176, 7, 208, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 178, 8, 0, 6, 17, 18, 57, 48, 49, 33, 35, 1, 7, 17, 35, 17, 51, 17, 1, 51, 1, 3, 158, 168, 254, 78, 138, 137, 137, 2, 47, 181, 254, 0, 2, 127, 154, 254, 27, 5, 25, 253, 133, 2, 123, 253, 198, 0, 1, 255, 197, 0, 0, 3, 227, 5, 25, 0, 6, 0, 49, 0, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 15, 62, 89, 178, 1, 0, 4, 17, 18, 57, 48, 49, 33, 1, 1, 35, 1, 51, 1, 3, 80, 254, 131, 254, 133, 147, 1, 178, 186, 1, 178, 4, 141, 251, 115, 5, 25, 250, 231, 0, 1, 0, 49, 0, 0, 3, 115, 5, 25, 0, 12, 0, 109, 176, 13, 47, 176, 14, 47, 176, 0, 220, 177, 1, 8, 244, 176, 13, 16, 176, 7, 208, 176, 7, 47, 177, 6, 12, 244, 178, 10, 7, 0, 17, 18, 57, 0, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 21, 62, 89, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 178, 2, 0, 8, 17, 18, 57, 178, 5, 0, 8, 17, 18, 57, 178, 10, 0, 8, 17, 18, 57, 48, 49, 33, 35, 17, 3, 35, 3, 17, 35, 17, 51, 19, 19, 51, 3, 115, 138, 231, 98, 230, 137, 178, 238, 240, 178, 4, 63, 253, 95, 2, 161, 251, 193, 5, 25, 253, 86, 2, 170, 0, 0, 1, 0, 49, 0, 0, 3, 115, 5, 25, 0, 9, 0, 98, 176, 10, 47, 176, 11, 47, 176, 0, 220, 176, 10, 16, 176, 4, 208, 176, 4, 47, 177, 3, 12, 244, 176, 0, 16, 177, 7, 8, 244, 0, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 21, 62, 89, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 178, 2, 0, 5, 17, 18, 57, 178, 7, 0, 5, 17, 18, 57, 48, 49, 33, 35, 1, 17, 35, 17, 51, 1, 17, 51, 3, 115, 170, 253, 241, 137, 193, 1, 247, 138, 4, 80, 251, 176, 5, 25, 251, 227, 4, 29, 0, 3, 0, 0, 0, 0, 3, 164, 5, 25, 0, 7, 0, 15, 0, 19, 0, 126, 176, 20, 47, 176, 21, 47, 176, 20, 16, 176, 0, 208, 176, 0, 47, 177, 1, 11, 244, 176, 21, 16, 176, 6, 220, 177, 3, 11, 244, 176, 8, 208, 176, 1, 16, 176, 9, 208, 176, 0, 16, 176, 11, 208, 176, 6, 16, 176, 13, 208, 0, 176, 0, 69, 88, 176, 12, 47, 27, 177, 12, 21, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 179, 17, 6, 18, 4, 43, 176, 6, 16, 176, 0, 220, 176, 6, 16, 177, 2, 6, 244, 176, 0, 16, 176, 4, 208, 176, 5, 208, 176, 12, 16, 177, 8, 6, 244, 176, 12, 16, 176, 10, 220, 176, 14, 208, 176, 15, 208, 48, 49, 17, 51, 21, 33, 53, 51, 17, 33, 1, 33, 21, 35, 17, 33, 17, 35, 1, 33, 21, 33, 121, 2, 178, 121, 252, 92, 3, 43, 253, 78, 121, 3, 164, 121, 253, 186, 1, 215, 254, 41, 1, 45, 184, 184, 254, 211, 4, 164, 187, 1, 48, 254, 208, 254, 222, 117, 0, 2, 255, 223, 255, 233, 3, 199, 5, 47, 0, 19, 0, 39, 0, 226, 176, 40, 47, 176, 41, 47, 176, 0, 220, 176, 40, 16, 176, 10, 208, 176, 10, 47, 176, 0, 16, 177, 20, 8, 244, 180, 218, 20, 234, 20, 2, 93, 64, 27, 9, 20, 25, 20, 41, 20, 57, 20, 73, 20, 89, 20, 105, 20, 121, 20, 137, 20, 153, 20, 169, 20, 185, 20, 201, 20, 13, 93, 176, 10, 16, 177, 30, 12, 244, 64, 23, 6, 30, 22, 30, 38, 30, 54, 30, 70, 30, 86, 30, 102, 30, 118, 30, 134, 30, 150, 30, 166, 30, 11, 93, 180, 182, 30, 198, 30, 2, 93, 180, 213, 30, 229, 30, 2, 93, 0, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 21, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 176, 15, 16, 177, 25, 6, 244, 180, 217, 25, 233, 25, 2, 93, 64, 27, 8, 25, 24, 25, 40, 25, 56, 25, 72, 25, 88, 25, 104, 25, 120, 25, 136, 25, 152, 25, 168, 25, 184, 25, 200, 25, 13, 93, 176, 5, 16, 177, 35, 6, 244, 64, 27, 7, 35, 23, 35, 39, 35, 55, 35, 71, 35, 87, 35, 103, 35, 119, 35, 135, 35, 151, 35, 167, 35, 183, 35, 199, 35, 13, 93, 180, 214, 35, 230, 35, 2, 93, 48, 49, 1, 20, 14, 2, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 30, 2, 7, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 62, 2, 3, 199, 54, 118, 191, 137, 137, 191, 119, 53, 53, 121, 191, 135, 135, 191, 118, 56, 138, 49, 92, 135, 86, 107, 139, 84, 33, 33, 84, 139, 107, 106, 140, 84, 32, 2, 139, 131, 244, 186, 113, 113, 186, 244, 131, 131, 244, 188, 113, 113, 188, 244, 131, 129, 207, 146, 77, 100, 162, 198, 99, 98, 199, 159, 101, 101, 159, 199, 0, 1, 0, 49, 0, 0, 3, 115, 5, 25, 0, 7, 0, 75, 176, 8, 47, 176, 9, 47, 176, 0, 220, 177, 1, 8, 244, 176, 8, 16, 176, 5, 208, 176, 5, 47, 177, 4, 12, 244, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 176, 6, 16, 177, 2, 6, 244, 48, 49, 33, 35, 17, 33, 17, 35, 17, 33, 3, 115, 138, 253, 209, 137, 3, 66, 4, 164, 251, 92, 5, 25, 0, 0, 2, 0, 49, 0, 0, 3, 162, 5, 25, 0, 10, 0, 19, 0, 114, 176, 20, 47, 176, 21, 47, 176, 0, 220, 176, 20, 16, 176, 6, 208, 176, 6, 47, 177, 5, 12, 244, 176, 0, 16, 177, 11, 12, 244, 180, 218, 11, 234, 11, 2, 93, 64, 27, 9, 11, 25, 11, 41, 11, 57, 11, 73, 11, 89, 11, 105, 11, 121, 11, 137, 11, 153, 11, 169, 11, 185, 11, 201, 11, 13, 93, 176, 5, 16, 176, 15, 208, 0, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 21, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 179, 17, 6, 3, 4, 43, 176, 7, 16, 177, 14, 6, 244, 48, 49, 1, 20, 6, 35, 33, 17, 35, 17, 33, 50, 22, 7, 52, 38, 35, 33, 17, 33, 50, 54, 3, 162, 236, 213, 254, 217, 137, 1, 174, 215, 236, 137, 170, 142, 254, 217, 1, 39, 142, 170, 3, 164, 189, 184, 253, 209, 5, 25, 187, 186, 135, 121, 254, 0, 121, 0, 0, 1, 0, 43, 0, 0, 3, 115, 5, 25, 0, 15, 0, 67, 179, 7, 11, 8, 4, 43, 176, 7, 16, 176, 0, 208, 176, 8, 16, 176, 13, 208, 176, 7, 16, 176, 17, 220, 0, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 5, 16, 177, 9, 6, 244, 176, 0, 16, 177, 12, 6, 244, 48, 49, 33, 33, 53, 1, 1, 53, 33, 17, 35, 17, 33, 1, 1, 33, 17, 51, 3, 115, 252, 184, 1, 72, 254, 184, 3, 72, 121, 253, 213, 1, 69, 254, 187, 2, 43, 121, 117, 2, 24, 2, 23, 117, 254, 71, 1, 68, 253, 233, 253, 232, 1, 69, 0, 0, 1, 0, 0, 0, 0, 3, 164, 5, 25, 0, 15, 0, 107, 176, 16, 47, 176, 13, 208, 176, 13, 47, 176, 9, 220, 178, 64, 9, 1, 93, 176, 1, 220, 178, 64, 1, 1, 93, 177, 0, 13, 244, 176, 9, 16, 177, 4, 8, 244, 176, 13, 16, 177, 12, 13, 244, 176, 0, 16, 176, 17, 220, 0, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 21, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 176, 14, 16, 177, 2, 6, 244, 176, 6, 16, 177, 4, 6, 244, 176, 8, 208, 176, 9, 208, 176, 2, 16, 176, 10, 208, 176, 11, 208, 48, 49, 1, 35, 17, 33, 17, 51, 21, 33, 53, 51, 17, 33, 17, 35, 17, 33, 3, 164, 117, 254, 232, 210, 253, 209, 211, 254, 232, 117, 3, 164, 3, 96, 1, 68, 251, 209, 117, 117, 4, 47, 254, 188, 1, 185, 0, 0, 1, 255, 236, 0, 0, 3, 184, 5, 25, 0, 20, 0, 103, 179, 3, 8, 8, 4, 43, 178, 16, 8, 3, 17, 18, 57, 0, 176, 0, 69, 88, 176, 12, 47, 27, 177, 12, 21, 62, 89, 176, 0, 69, 88, 176, 19, 47, 27, 177, 19, 21, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 176, 19, 16, 177, 0, 6, 244, 176, 5, 16, 177, 3, 6, 244, 176, 7, 208, 176, 8, 208, 176, 0, 16, 176, 10, 208, 176, 11, 208, 176, 14, 208, 176, 15, 208, 178, 16, 5, 12, 17, 18, 57, 176, 17, 208, 176, 18, 208, 48, 49, 1, 35, 1, 17, 51, 21, 33, 53, 51, 17, 1, 35, 53, 33, 21, 35, 19, 19, 35, 53, 33, 3, 184, 106, 254, 201, 210, 253, 209, 211, 254, 201, 106, 1, 112, 108, 227, 225, 108, 1, 112, 4, 164, 253, 143, 254, 66, 117, 117, 1, 190, 2, 113, 117, 117, 254, 20, 1, 236, 117, 0, 0, 3, 255, 236, 0, 0, 3, 188, 5, 25, 0, 25, 0, 34, 0, 43, 0, 145, 179, 35, 12, 13, 4, 43, 179, 6, 8, 7, 4, 43, 179, 0, 12, 26, 4, 43, 176, 7, 16, 176, 18, 208, 176, 6, 16, 176, 20, 208, 180, 218, 26, 234, 26, 2, 93, 64, 27, 9, 26, 25, 26, 41, 26, 57, 26, 73, 26, 89, 26, 105, 26, 121, 26, 137, 26, 153, 26, 169, 26, 185, 26, 201, 26, 13, 93, 176, 6, 16, 176, 31, 208, 64, 27, 6, 35, 22, 35, 38, 35, 54, 35, 70, 35, 86, 35, 102, 35, 118, 35, 134, 35, 150, 35, 166, 35, 182, 35, 198, 35, 13, 93, 180, 213, 35, 229, 35, 2, 93, 176, 7, 16, 176, 38, 208, 0, 176, 0, 69, 88, 176, 19, 47, 27, 177, 19, 21, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 48, 49, 1, 20, 14, 2, 7, 21, 35, 53, 46, 3, 53, 52, 62, 2, 55, 53, 51, 21, 30, 3, 7, 52, 46, 2, 39, 17, 54, 54, 37, 20, 22, 23, 17, 14, 3, 3, 188, 61, 111, 155, 94, 138, 94, 153, 111, 59, 59, 111, 153, 94, 138, 94, 155, 111, 61, 137, 39, 71, 107, 67, 135, 149, 253, 66, 145, 135, 67, 105, 71, 37, 2, 143, 98, 168, 127, 80, 10, 172, 174, 10, 80, 125, 168, 98, 99, 168, 129, 79, 13, 162, 162, 10, 82, 127, 170, 99, 70, 125, 98, 64, 12, 253, 37, 22, 199, 141, 141, 199, 22, 2, 219, 12, 66, 96, 125, 0, 1, 255, 233, 0, 0, 3, 186, 5, 25, 0, 27, 0, 122, 0, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 21, 62, 89, 176, 0, 69, 88, 176, 21, 47, 27, 177, 21, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 15, 62, 89, 177, 2, 6, 244, 176, 3, 208, 178, 4, 0, 14, 17, 18, 57, 176, 5, 208, 176, 6, 208, 176, 9, 208, 176, 10, 208, 176, 14, 16, 177, 12, 6, 244, 176, 16, 208, 176, 17, 208, 178, 18, 0, 14, 17, 18, 57, 176, 19, 208, 176, 20, 208, 176, 23, 208, 176, 24, 208, 176, 10, 16, 176, 26, 208, 176, 27, 208, 48, 49, 33, 33, 53, 51, 3, 3, 51, 21, 33, 53, 51, 1, 1, 35, 53, 33, 21, 35, 19, 19, 35, 53, 33, 21, 35, 1, 1, 51, 3, 186, 254, 142, 88, 205, 207, 88, 254, 141, 127, 1, 27, 254, 234, 109, 1, 117, 109, 203, 197, 105, 1, 117, 113, 254, 240, 1, 24, 127, 117, 1, 172, 254, 84, 117, 117, 2, 28, 2, 19, 117, 117, 254, 94, 1, 162, 117, 117, 253, 237, 253, 228, 0, 0, 1, 0, 49, 0, 0, 3, 115, 5, 25, 0, 27, 0, 85, 179, 12, 12, 9, 4, 43, 179, 4, 8, 5, 4, 43, 179, 0, 8, 25, 4, 43, 176, 5, 16, 176, 17, 208, 176, 4, 16, 176, 19, 208, 0, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 21, 62, 89, 176, 0, 69, 88, 176, 18, 47, 27, 177, 18, 21, 62, 89, 176, 0, 69, 88, 176, 26, 47, 27, 177, 26, 21, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 48, 49, 1, 20, 2, 7, 17, 35, 17, 38, 2, 53, 17, 51, 17, 20, 30, 2, 23, 17, 51, 17, 62, 3, 53, 17, 51, 3, 115, 168, 180, 138, 182, 166, 137, 17, 45, 82, 67, 138, 65, 82, 47, 16, 138, 3, 39, 205, 255, 0, 22, 254, 188, 1, 68, 22, 1, 2, 205, 1, 240, 254, 14, 53, 117, 102, 78, 15, 3, 95, 252, 161, 15, 78, 102, 117, 53, 1, 242, 255, 255, 0, 186, 0, 0, 2, 233, 6, 142, 2, 34, 1, 137, 0, 0, 0, 3, 0, 140, 0, 0, 1, 117, 255, 255, 255, 236, 0, 0, 3, 184, 6, 142, 2, 35, 0, 140, 0, 0, 1, 117, 0, 2, 1, 148, 0, 0, 255, 255, 0, 2, 255, 233, 3, 170, 6, 47, 2, 34, 1, 159, 0, 0, 0, 2, 1, 119, 0, 0, 255, 255, 0, 0, 255, 233, 3, 129, 6, 47, 2, 38, 1, 163, 0, 0, 0, 6, 1, 119, 0, 0, 255, 255, 0, 12, 254, 139, 3, 115, 6, 47, 2, 38, 1, 165, 0, 0, 0, 6, 1, 119, 0, 0, 255, 255, 0, 186, 255, 233, 2, 233, 6, 47, 2, 38, 1, 167, 0, 0, 0, 6, 1, 119, 0, 0, 255, 255, 0, 0, 255, 233, 3, 164, 6, 47, 2, 38, 1, 178, 0, 0, 0, 6, 1, 120, 0, 0, 0, 2, 0, 2, 255, 233, 3, 170, 3, 186, 0, 19, 0, 41, 0, 204, 179, 0, 12, 20, 4, 43, 64, 27, 6, 0, 22, 0, 38, 0, 54, 0, 70, 0, 86, 0, 102, 0, 118, 0, 134, 0, 150, 0, 166, 0, 182, 0, 198, 0, 13, 93, 180, 213, 0, 229, 0, 2, 93, 0, 176, 0, 69, 88, 176, 29, 47, 27, 177, 29, 19, 62, 89, 176, 0, 69, 88, 176, 25, 47, 27, 177, 25, 19, 62, 89, 176, 0, 69, 88, 176, 32, 47, 27, 177, 32, 15, 62, 89, 176, 0, 69, 88, 176, 37, 47, 27, 177, 37, 15, 62, 89, 177, 5, 6, 244, 64, 27, 7, 5, 23, 5, 39, 5, 55, 5, 71, 5, 87, 5, 103, 5, 119, 5, 135, 5, 151, 5, 167, 5, 183, 5, 199, 5, 13, 93, 180, 214, 5, 230, 5, 2, 93, 176, 25, 16, 177, 15, 6, 244, 180, 217, 15, 233, 15, 2, 93, 64, 27, 8, 15, 24, 15, 40, 15, 56, 15, 72, 15, 88, 15, 104, 15, 120, 15, 136, 15, 152, 15, 168, 15, 184, 15, 200, 15, 13, 93, 178, 28, 37, 25, 17, 18, 57, 178, 30, 25, 15, 17, 18, 57, 178, 34, 37, 25, 17, 18, 57, 48, 49, 19, 20, 30, 2, 51, 50, 62, 2, 55, 46, 3, 35, 34, 14, 2, 7, 52, 62, 2, 51, 50, 22, 23, 19, 51, 3, 19, 35, 3, 6, 6, 35, 34, 46, 2, 139, 27, 59, 97, 67, 60, 92, 71, 52, 20, 20, 52, 71, 92, 60, 67, 97, 59, 27, 137, 45, 96, 146, 100, 123, 182, 41, 56, 147, 131, 131, 147, 56, 41, 182, 123, 100, 146, 96, 45, 1, 211, 64, 131, 108, 70, 70, 106, 133, 64, 63, 132, 106, 70, 70, 106, 132, 63, 94, 176, 135, 82, 155, 137, 1, 14, 254, 47, 254, 45, 1, 14, 137, 156, 82, 138, 176, 0, 2, 0, 49, 254, 139, 3, 168, 5, 47, 0, 26, 0, 52, 1, 13, 179, 4, 12, 5, 4, 43, 179, 16, 8, 39, 4, 43, 180, 218, 39, 234, 39, 2, 93, 64, 27, 9, 39, 25, 39, 41, 39, 57, 39, 73, 39, 89, 39, 105, 39, 121, 39, 137, 39, 153, 39, 169, 39, 185, 39, 201, 39, 13, 93, 178, 30, 39, 16, 17, 18, 57, 176, 30, 47, 180, 218, 30, 234, 30, 2, 93, 64, 27, 9, 30, 25, 30, 41, 30, 57, 30, 73, 30, 89, 30, 105, 30, 121, 30, 137, 30, 153, 30, 169, 30, 185, 30, 201, 30, 13, 93, 177, 22, 12, 244, 178, 19, 5, 22, 17, 18, 57, 176, 4, 16, 176, 49, 208, 176, 22, 16, 176, 54, 220, 0, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 21, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 17, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 179, 36, 6, 33, 4, 43, 176, 0, 16, 177, 27, 6, 244, 64, 27, 7, 27, 23, 27, 39, 27, 55, 27, 71, 27, 87, 27, 103, 27, 119, 27, 135, 27, 151, 27, 167, 27, 183, 27, 199, 27, 13, 93, 180, 214, 27, 230, 27, 2, 93, 178, 3, 0, 27, 17, 18, 57, 178, 19, 33, 36, 17, 18, 57, 176, 11, 16, 177, 44, 6, 244, 180, 217, 44, 233, 44, 2, 93, 64, 27, 8, 44, 24, 44, 40, 44, 56, 44, 72, 44, 88, 44, 104, 44, 120, 44, 136, 44, 152, 44, 168, 44, 184, 44, 200, 44, 13, 93, 48, 49, 5, 34, 38, 39, 17, 35, 17, 52, 62, 2, 51, 50, 30, 2, 21, 20, 6, 7, 22, 22, 21, 20, 14, 2, 39, 50, 54, 53, 52, 38, 35, 35, 53, 51, 50, 54, 53, 52, 46, 2, 35, 34, 14, 2, 21, 17, 22, 22, 1, 238, 99, 145, 64, 137, 66, 112, 156, 90, 96, 152, 104, 56, 117, 109, 133, 148, 66, 116, 162, 98, 143, 162, 170, 166, 90, 90, 145, 135, 30, 64, 102, 74, 53, 103, 81, 50, 60, 147, 23, 48, 49, 254, 65, 5, 31, 84, 143, 105, 57, 59, 94, 125, 64, 104, 160, 37, 41, 166, 123, 82, 137, 100, 58, 117, 144, 116, 117, 147, 117, 142, 108, 37, 80, 65, 43, 32, 68, 102, 70, 253, 45, 65, 56, 0, 1, 0, 0, 254, 139, 3, 123, 3, 164, 0, 14, 0, 62, 179, 6, 8, 7, 4, 43, 178, 11, 7, 6, 17, 18, 57, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 19, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 19, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 17, 62, 89, 178, 11, 6, 0, 17, 18, 57, 48, 49, 1, 14, 3, 7, 17, 35, 17, 1, 51, 1, 54, 18, 55, 3, 123, 17, 57, 86, 119, 77, 138, 254, 115, 158, 1, 61, 119, 139, 19, 3, 164, 119, 254, 252, 241, 107, 254, 180, 1, 74, 3, 207, 252, 180, 199, 1, 172, 217, 0, 2, 0, 39, 255, 233, 3, 121, 5, 47, 0, 39, 0, 55, 1, 17, 179, 46, 12, 17, 4, 43, 179, 0, 12, 25, 4, 43, 179, 7, 12, 40, 4, 43, 64, 27, 6, 0, 22, 0, 38, 0, 54, 0, 70, 0, 86, 0, 102, 0, 118, 0, 134, 0, 150, 0, 166, 0, 182, 0, 198, 0, 13, 93, 180, 213, 0, 229, 0, 2, 93, 178, 20, 17, 7, 17, 18, 57, 180, 218, 40, 234, 40, 2, 93, 64, 27, 9, 40, 25, 40, 41, 40, 57, 40, 73, 40, 89, 40, 105, 40, 121, 40, 137, 40, 153, 40, 169, 40, 185, 40, 201, 40, 13, 93, 64, 27, 6, 46, 22, 46, 38, 46, 54, 46, 70, 46, 86, 46, 102, 46, 118, 46, 134, 46, 150, 46, 166, 46, 182, 46, 198, 46, 13, 93, 180, 213, 46, 229, 46, 2, 93, 176, 7, 16, 176, 57, 220, 0, 176, 0, 69, 88, 176, 30, 47, 27, 177, 30, 21, 62, 89, 176, 0, 69, 88, 176, 12, 47, 27, 177, 12, 15, 62, 89, 178, 20, 12, 30, 17, 18, 57, 176, 30, 16, 177, 37, 6, 244, 180, 217, 37, 233, 37, 2, 93, 64, 19, 8, 37, 24, 37, 40, 37, 56, 37, 72, 37, 88, 37, 104, 37, 120, 37, 136, 37, 9, 93, 64, 9, 152, 37, 168, 37, 184, 37, 200, 37, 4, 93, 176, 12, 16, 177, 51, 6, 244, 180, 7, 51, 23, 51, 2, 93, 64, 23, 39, 51, 55, 51, 71, 51, 87, 51, 103, 51, 119, 51, 135, 51, 151, 51, 167, 51, 183, 51, 199, 51, 11, 93, 180, 214, 51, 230, 51, 2, 93, 48, 49, 1, 20, 30, 4, 21, 20, 14, 2, 35, 34, 46, 2, 53, 52, 54, 55, 46, 3, 53, 52, 62, 2, 51, 50, 22, 23, 7, 38, 38, 35, 34, 6, 1, 52, 38, 39, 6, 6, 21, 20, 30, 2, 51, 50, 62, 2, 1, 78, 82, 123, 145, 123, 82, 60, 110, 158, 98, 96, 158, 111, 59, 166, 168, 37, 64, 47, 28, 39, 75, 109, 69, 84, 132, 61, 61, 48, 106, 62, 67, 88, 1, 162, 148, 133, 133, 162, 31, 67, 111, 78, 78, 110, 70, 31, 4, 68, 41, 76, 82, 98, 127, 160, 102, 97, 155, 115, 62, 62, 115, 155, 97, 118, 238, 92, 25, 51, 55, 66, 41, 43, 84, 67, 41, 33, 41, 98, 33, 22, 59, 253, 23, 114, 189, 71, 71, 189, 117, 57, 110, 89, 53, 56, 88, 110, 0, 0, 1, 0, 0, 255, 233, 3, 129, 3, 186, 0, 48, 0, 191, 179, 28, 12, 43, 4, 43, 176, 43, 16, 176, 0, 208, 176, 0, 47, 64, 27, 6, 28, 22, 28, 38, 28, 54, 28, 70, 28, 86, 28, 102, 28, 118, 28, 134, 28, 150, 28, 166, 28, 182, 28, 198, 28, 13, 93, 180, 213, 28, 229, 28, 2, 93, 176, 28, 16, 176, 15, 208, 176, 15, 47, 0, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 19, 62, 89, 176, 0, 69, 88, 176, 38, 47, 27, 177, 38, 15, 62, 89, 179, 21, 6, 22, 4, 43, 176, 5, 16, 177, 12, 6, 244, 180, 217, 12, 233, 12, 2, 93, 64, 27, 8, 12, 24, 12, 40, 12, 56, 12, 72, 12, 88, 12, 104, 12, 120, 12, 136, 12, 152, 12, 168, 12, 184, 12, 200, 12, 13, 93, 176, 38, 16, 177, 31, 6, 244, 64, 27, 7, 31, 23, 31, 39, 31, 55, 31, 71, 31, 87, 31, 103, 31, 119, 31, 135, 31, 151, 31, 167, 31, 183, 31, 199, 31, 13, 93, 180, 214, 31, 230, 31, 2, 93, 178, 46, 22, 21, 17, 18, 57, 48, 49, 19, 52, 62, 2, 51, 50, 22, 23, 7, 38, 38, 35, 34, 6, 21, 20, 30, 2, 51, 51, 21, 35, 34, 14, 2, 21, 20, 22, 51, 50, 54, 55, 23, 6, 6, 35, 34, 46, 2, 53, 52, 54, 55, 38, 38, 12, 66, 119, 161, 97, 153, 201, 61, 102, 41, 154, 118, 142, 163, 30, 64, 98, 66, 206, 206, 68, 100, 68, 35, 182, 148, 123, 164, 47, 96, 63, 207, 160, 100, 170, 125, 72, 113, 92, 99, 94, 2, 164, 63, 105, 71, 39, 100, 100, 70, 70, 84, 88, 74, 25, 51, 41, 27, 116, 27, 43, 55, 27, 80, 90, 76, 72, 66, 100, 99, 39, 74, 107, 67, 72, 119, 18, 16, 119, 0, 0, 1, 0, 2, 254, 117, 3, 164, 5, 25, 0, 40, 0, 130, 176, 41, 47, 176, 42, 47, 176, 34, 220, 177, 0, 12, 244, 180, 218, 0, 234, 0, 2, 93, 64, 27, 9, 0, 25, 0, 41, 0, 57, 0, 73, 0, 89, 0, 105, 0, 121, 0, 137, 0, 153, 0, 169, 0, 185, 0, 201, 0, 13, 93, 176, 41, 16, 176, 10, 208, 176, 10, 47, 178, 15, 10, 34, 17, 18, 57, 177, 24, 12, 244, 64, 27, 6, 24, 22, 24, 38, 24, 54, 24, 70, 24, 86, 24, 102, 24, 118, 24, 134, 24, 150, 24, 166, 24, 182, 24, 198, 24, 13, 93, 180, 213, 24, 229, 24, 2, 93, 0, 176, 37, 47, 176, 0, 69, 88, 176, 17, 47, 27, 177, 17, 21, 62, 89, 177, 15, 6, 244, 48, 49, 5, 52, 46, 2, 39, 46, 3, 53, 52, 62, 2, 55, 33, 53, 33, 21, 6, 4, 6, 6, 21, 20, 30, 2, 23, 30, 3, 21, 20, 6, 7, 39, 54, 54, 3, 2, 33, 59, 88, 55, 84, 189, 158, 102, 100, 174, 232, 131, 254, 59, 2, 234, 184, 254, 217, 205, 109, 72, 115, 147, 74, 71, 132, 98, 59, 116, 117, 60, 88, 68, 115, 37, 43, 25, 12, 4, 6, 35, 100, 189, 160, 104, 203, 180, 152, 53, 117, 117, 49, 160, 188, 203, 92, 113, 141, 80, 31, 6, 6, 21, 51, 88, 74, 86, 153, 41, 104, 33, 96, 0, 0, 1, 0, 12, 254, 139, 3, 115, 3, 186, 0, 29, 0, 145, 176, 30, 47, 176, 31, 47, 176, 30, 16, 176, 17, 208, 176, 17, 47, 177, 16, 8, 244, 178, 0, 17, 16, 17, 18, 57, 176, 31, 16, 176, 7, 220, 177, 8, 8, 244, 0, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 19, 62, 89, 176, 0, 69, 88, 176, 27, 47, 27, 177, 27, 19, 62, 89, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 17, 62, 89, 176, 0, 69, 88, 176, 16, 47, 27, 177, 16, 15, 62, 89, 178, 0, 7, 3, 17, 18, 57, 176, 3, 16, 177, 12, 6, 244, 180, 217, 12, 233, 12, 2, 93, 64, 27, 8, 12, 24, 12, 40, 12, 56, 12, 72, 12, 88, 12, 104, 12, 120, 12, 136, 12, 152, 12, 168, 12, 184, 12, 200, 12, 13, 93, 176, 21, 208, 48, 49, 1, 54, 54, 51, 50, 22, 21, 17, 35, 17, 52, 38, 35, 34, 6, 21, 17, 35, 17, 52, 38, 35, 34, 7, 39, 54, 54, 51, 50, 22, 1, 47, 31, 131, 104, 154, 160, 138, 86, 90, 104, 141, 138, 45, 35, 34, 33, 27, 21, 57, 29, 71, 109, 3, 6, 78, 102, 184, 192, 252, 73, 3, 183, 116, 144, 160, 146, 253, 236, 2, 236, 43, 47, 15, 107, 10, 14, 88, 0, 0, 3, 0, 41, 255, 233, 3, 127, 5, 47, 0, 19, 0, 30, 0, 41, 0, 164, 176, 42, 47, 176, 43, 47, 176, 0, 220, 176, 42, 16, 176, 10, 208, 176, 10, 47, 176, 0, 16, 177, 25, 8, 244, 176, 10, 16, 177, 26, 8, 244, 176, 36, 208, 176, 25, 16, 176, 37, 208, 0, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 21, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 179, 37, 6, 25, 4, 43, 176, 5, 16, 177, 20, 6, 244, 64, 27, 7, 20, 23, 20, 39, 20, 55, 20, 71, 20, 87, 20, 103, 20, 119, 20, 135, 20, 151, 20, 167, 20, 183, 20, 199, 20, 13, 93, 180, 214, 20, 230, 20, 2, 93, 176, 15, 16, 177, 31, 6, 244, 180, 217, 31, 233, 31, 2, 93, 64, 27, 8, 31, 24, 31, 40, 31, 56, 31, 72, 31, 88, 31, 104, 31, 120, 31, 136, 31, 152, 31, 168, 31, 184, 31, 200, 31, 13, 93, 48, 49, 1, 20, 14, 2, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 30, 2, 1, 50, 62, 2, 55, 33, 30, 3, 19, 34, 14, 2, 7, 33, 46, 3, 3, 127, 49, 103, 163, 113, 115, 159, 105, 47, 47, 105, 159, 115, 115, 161, 105, 47, 254, 84, 78, 108, 68, 31, 4, 253, 192, 2, 33, 68, 106, 78, 78, 106, 68, 33, 2, 2, 64, 4, 33, 68, 106, 2, 139, 149, 248, 178, 99, 99, 178, 248, 149, 148, 248, 180, 100, 100, 178, 250, 253, 63, 78, 137, 189, 108, 108, 189, 137, 78, 4, 92, 73, 131, 179, 104, 104, 179, 131, 73, 0, 1, 0, 186, 255, 233, 2, 233, 3, 164, 0, 17, 0, 93, 179, 13, 8, 8, 4, 43, 0, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 19, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 176, 11, 16, 177, 9, 3, 244, 176, 3, 16, 177, 15, 6, 244, 64, 27, 7, 15, 23, 15, 39, 15, 55, 15, 71, 15, 87, 15, 103, 15, 119, 15, 135, 15, 151, 15, 167, 15, 183, 15, 199, 15, 13, 93, 180, 214, 15, 230, 15, 2, 93, 178, 17, 3, 11, 17, 18, 57, 48, 49, 37, 6, 6, 35, 34, 46, 2, 53, 17, 35, 53, 33, 17, 20, 51, 50, 55, 2, 233, 22, 57, 43, 45, 82, 62, 37, 211, 1, 93, 106, 49, 27, 2, 12, 13, 31, 58, 86, 55, 2, 92, 121, 253, 43, 113, 17, 0, 0, 1, 0, 49, 0, 0, 3, 162, 3, 164, 0, 11, 0, 74, 179, 4, 12, 5, 4, 43, 176, 4, 16, 176, 7, 208, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 19, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 178, 8, 0, 6, 17, 18, 57, 48, 49, 33, 35, 1, 7, 17, 35, 17, 51, 17, 1, 51, 1, 3, 162, 195, 254, 131, 168, 137, 137, 2, 19, 196, 254, 45, 1, 162, 154, 254, 248, 3, 164, 254, 10, 1, 246, 254, 84, 0, 1, 255, 225, 0, 0, 3, 193, 5, 47, 0, 18, 0, 93, 0, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 15, 62, 89, 178, 1, 0, 14, 17, 18, 57, 176, 14, 16, 177, 8, 6, 244, 180, 217, 8, 233, 8, 2, 93, 64, 27, 8, 8, 24, 8, 40, 8, 56, 8, 72, 8, 88, 8, 104, 8, 120, 8, 136, 8, 152, 8, 168, 8, 184, 8, 200, 8, 13, 93, 48, 49, 33, 1, 1, 35, 1, 39, 38, 38, 35, 34, 6, 7, 39, 54, 51, 50, 22, 23, 1, 3, 29, 254, 182, 254, 176, 162, 1, 160, 57, 19, 51, 68, 28, 90, 47, 27, 96, 96, 86, 142, 39, 1, 248, 3, 47, 252, 209, 3, 190, 142, 45, 65, 16, 20, 118, 35, 61, 99, 251, 113, 0, 0, 1, 0, 49, 254, 139, 3, 152, 3, 164, 0, 33, 0, 172, 176, 34, 47, 176, 35, 47, 176, 22, 220, 177, 19, 8, 244, 178, 0, 22, 19, 17, 18, 57, 176, 34, 16, 176, 8, 208, 176, 8, 47, 177, 7, 12, 244, 176, 10, 208, 0, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 19, 62, 89, 176, 0, 69, 88, 176, 20, 47, 27, 177, 20, 19, 62, 89, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 17, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 176, 0, 69, 88, 176, 31, 47, 27, 177, 31, 15, 62, 89, 178, 0, 7, 9, 17, 18, 57, 178, 6, 7, 9, 17, 18, 57, 176, 3, 16, 177, 14, 6, 244, 64, 27, 7, 14, 23, 14, 39, 14, 55, 14, 71, 14, 87, 14, 103, 14, 119, 14, 135, 14, 151, 14, 167, 14, 183, 14, 199, 14, 13, 93, 180, 214, 14, 230, 14, 2, 93, 176, 25, 208, 178, 27, 7, 9, 17, 18, 57, 48, 49, 37, 6, 6, 35, 34, 38, 39, 17, 35, 17, 51, 17, 20, 22, 51, 50, 62, 2, 53, 17, 51, 17, 20, 22, 51, 50, 55, 23, 6, 6, 35, 34, 38, 2, 117, 21, 137, 98, 60, 104, 23, 137, 137, 109, 78, 47, 84, 65, 37, 139, 41, 29, 49, 29, 27, 21, 49, 37, 72, 108, 158, 76, 105, 62, 57, 254, 43, 5, 25, 253, 155, 106, 119, 41, 78, 115, 71, 2, 21, 253, 22, 45, 47, 17, 109, 12, 13, 89, 0, 1, 0, 0, 0, 0, 3, 123, 3, 164, 0, 10, 0, 49, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 19, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 19, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 178, 7, 3, 0, 17, 18, 57, 48, 49, 1, 6, 2, 7, 35, 1, 51, 1, 54, 18, 55, 3, 123, 35, 178, 158, 139, 254, 131, 164, 1, 47, 119, 127, 18, 3, 164, 240, 254, 33, 213, 3, 164, 252, 225, 197, 1, 129, 217, 0, 1, 0, 2, 254, 117, 3, 139, 5, 47, 0, 58, 0, 195, 179, 29, 12, 56, 4, 43, 179, 39, 12, 46, 4, 43, 178, 0, 56, 39, 17, 18, 57, 64, 27, 6, 29, 22, 29, 38, 29, 54, 29, 70, 29, 86, 29, 102, 29, 118, 29, 134, 29, 150, 29, 166, 29, 182, 29, 198, 29, 13, 93, 180, 213, 29, 229, 29, 2, 93, 178, 3, 56, 29, 17, 18, 57, 176, 3, 47, 177, 18, 8, 244, 180, 218, 46, 234, 46, 2, 93, 64, 27, 9, 46, 25, 46, 41, 46, 57, 46, 73, 46, 89, 46, 105, 46, 121, 46, 137, 46, 153, 46, 169, 46, 185, 46, 201, 46, 13, 93, 176, 39, 16, 176, 60, 220, 0, 176, 42, 47, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 21, 62, 89, 179, 34, 3, 51, 4, 43, 179, 22, 6, 23, 4, 43, 178, 0, 23, 22, 17, 18, 57, 176, 8, 16, 177, 15, 6, 244, 180, 217, 15, 233, 15, 2, 93, 64, 27, 8, 15, 24, 15, 40, 15, 56, 15, 72, 15, 88, 15, 104, 15, 120, 15, 136, 15, 152, 15, 168, 15, 184, 15, 200, 15, 13, 93, 48, 49, 1, 38, 38, 53, 52, 62, 2, 51, 50, 22, 23, 7, 38, 38, 35, 34, 6, 21, 20, 22, 51, 51, 21, 35, 34, 14, 2, 21, 20, 30, 2, 23, 30, 3, 21, 20, 6, 7, 39, 54, 54, 53, 52, 46, 2, 39, 46, 3, 53, 52, 54, 1, 27, 111, 115, 68, 113, 147, 80, 78, 164, 63, 43, 70, 122, 70, 117, 153, 139, 141, 246, 246, 76, 125, 88, 47, 70, 115, 147, 76, 71, 132, 98, 59, 116, 117, 60, 88, 68, 33, 59, 88, 55, 117, 195, 141, 80, 148, 2, 176, 35, 166, 96, 78, 127, 88, 49, 35, 35, 106, 35, 24, 125, 100, 113, 127, 116, 39, 72, 94, 55, 78, 92, 49, 19, 6, 6, 21, 51, 88, 74, 86, 153, 41, 104, 33, 96, 47, 37, 43, 25, 12, 4, 10, 35, 80, 133, 109, 108, 166, 0, 0, 2, 255, 236, 255, 233, 3, 188, 3, 186, 0, 19, 0, 39, 0, 226, 176, 40, 47, 176, 41, 47, 176, 0, 220, 176, 40, 16, 176, 10, 208, 176, 10, 47, 176, 0, 16, 177, 20, 12, 244, 180, 218, 20, 234, 20, 2, 93, 64, 27, 9, 20, 25, 20, 41, 20, 57, 20, 73, 20, 89, 20, 105, 20, 121, 20, 137, 20, 153, 20, 169, 20, 185, 20, 201, 20, 13, 93, 176, 10, 16, 177, 30, 12, 244, 64, 23, 6, 30, 22, 30, 38, 30, 54, 30, 70, 30, 86, 30, 102, 30, 118, 30, 134, 30, 150, 30, 166, 30, 11, 93, 180, 182, 30, 198, 30, 2, 93, 180, 213, 30, 229, 30, 2, 93, 0, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 19, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 176, 15, 16, 177, 25, 6, 244, 180, 217, 25, 233, 25, 2, 93, 64, 27, 8, 25, 24, 25, 40, 25, 56, 25, 72, 25, 88, 25, 104, 25, 120, 25, 136, 25, 152, 25, 168, 25, 184, 25, 200, 25, 13, 93, 176, 5, 16, 177, 35, 6, 244, 64, 27, 7, 35, 23, 35, 39, 35, 55, 35, 71, 35, 87, 35, 103, 35, 119, 35, 135, 35, 151, 35, 167, 35, 183, 35, 199, 35, 13, 93, 180, 214, 35, 230, 35, 2, 93, 48, 49, 1, 20, 14, 2, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 30, 2, 7, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 62, 2, 3, 188, 69, 129, 180, 111, 109, 180, 129, 69, 69, 129, 180, 109, 111, 180, 129, 69, 137, 47, 92, 131, 82, 82, 131, 90, 47, 47, 90, 131, 82, 82, 131, 92, 47, 1, 207, 109, 178, 127, 72, 72, 127, 178, 109, 106, 183, 129, 73, 73, 129, 183, 106, 80, 135, 102, 58, 58, 102, 135, 80, 80, 135, 98, 56, 56, 98, 135, 0, 2, 0, 49, 254, 139, 3, 164, 3, 186, 0, 19, 0, 38, 0, 206, 176, 39, 47, 176, 40, 47, 176, 0, 220, 176, 39, 16, 176, 9, 208, 176, 9, 47, 177, 8, 12, 244, 176, 0, 16, 177, 20, 12, 244, 180, 218, 20, 234, 20, 2, 93, 64, 27, 9, 20, 25, 20, 41, 20, 57, 20, 73, 20, 89, 20, 105, 20, 121, 20, 137, 20, 153, 20, 169, 20, 185, 20, 201, 20, 13, 93, 176, 8, 16, 176, 30, 208, 0, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 19, 62, 89, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 17, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 177, 34, 6, 244, 64, 27, 7, 34, 23, 34, 39, 34, 55, 34, 71, 34, 87, 34, 103, 34, 119, 34, 135, 34, 151, 34, 167, 34, 183, 34, 199, 34, 13, 93, 180, 214, 34, 230, 34, 2, 93, 178, 7, 5, 34, 17, 18, 57, 176, 15, 16, 177, 25, 6, 244, 180, 217, 25, 233, 25, 2, 93, 64, 27, 8, 25, 24, 25, 40, 25, 56, 25, 72, 25, 88, 25, 104, 25, 120, 25, 136, 25, 152, 25, 168, 25, 184, 25, 200, 25, 13, 93, 48, 49, 1, 20, 14, 2, 35, 34, 39, 17, 35, 17, 52, 62, 2, 51, 50, 30, 2, 7, 52, 46, 2, 35, 34, 14, 2, 21, 21, 22, 22, 51, 50, 62, 2, 3, 164, 66, 121, 176, 110, 150, 123, 137, 49, 105, 159, 111, 105, 170, 120, 64, 137, 41, 82, 121, 78, 61, 107, 76, 43, 60, 135, 78, 84, 125, 84, 43, 1, 209, 109, 178, 129, 72, 97, 254, 65, 3, 70, 92, 176, 137, 84, 71, 131, 181, 106, 80, 135, 100, 58, 41, 90, 142, 100, 250, 65, 56, 58, 98, 135, 0, 0, 1, 0, 2, 254, 117, 3, 139, 3, 186, 0, 43, 0, 175, 176, 44, 47, 176, 45, 47, 176, 44, 16, 176, 0, 208, 176, 0, 47, 176, 45, 16, 176, 27, 220, 176, 8, 208, 176, 8, 47, 176, 0, 16, 177, 17, 12, 244, 64, 27, 6, 17, 22, 17, 38, 17, 54, 17, 70, 17, 86, 17, 102, 17, 118, 17, 134, 17, 150, 17, 166, 17, 182, 17, 198, 17, 13, 93, 180, 213, 17, 229, 17, 2, 93, 176, 27, 16, 177, 34, 12, 244, 180, 218, 34, 234, 34, 2, 93, 64, 27, 9, 34, 25, 34, 41, 34, 57, 34, 73, 34, 89, 34, 105, 34, 121, 34, 137, 34, 153, 34, 169, 34, 185, 34, 201, 34, 13, 93, 0, 176, 30, 47, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 19, 62, 89, 177, 12, 6, 244, 180, 217, 12, 233, 12, 2, 93, 64, 27, 8, 12, 24, 12, 40, 12, 56, 12, 72, 12, 88, 12, 104, 12, 120, 12, 136, 12, 152, 12, 168, 12, 184, 12, 200, 12, 13, 93, 48, 49, 19, 52, 62, 2, 51, 50, 22, 23, 7, 38, 38, 35, 34, 14, 2, 21, 20, 30, 2, 23, 30, 3, 21, 20, 6, 7, 39, 54, 54, 53, 52, 46, 2, 39, 46, 3, 2, 72, 129, 180, 109, 141, 205, 59, 96, 43, 162, 104, 82, 131, 91, 49, 72, 115, 147, 74, 71, 132, 98, 59, 116, 117, 60, 88, 68, 33, 59, 88, 55, 111, 193, 145, 84, 1, 209, 108, 181, 129, 71, 108, 92, 66, 68, 82, 58, 100, 135, 80, 94, 125, 78, 37, 6, 6, 21, 51, 88, 74, 86, 153, 41, 104, 33, 96, 47, 37, 43, 25, 12, 4, 8, 56, 106, 166, 0, 0, 2, 255, 236, 255, 233, 3, 250, 3, 164, 0, 22, 0, 41, 0, 205, 176, 42, 47, 176, 43, 47, 176, 42, 16, 176, 15, 208, 176, 15, 47, 176, 43, 16, 176, 5, 220, 178, 0, 15, 5, 17, 18, 57, 176, 15, 16, 177, 26, 12, 244, 64, 27, 6, 26, 22, 26, 38, 26, 54, 26, 70, 26, 86, 26, 102, 26, 118, 26, 134, 26, 150, 26, 166, 26, 182, 26, 198, 26, 13, 93, 180, 213, 26, 229, 26, 2, 93, 176, 5, 16, 177, 36, 12, 244, 180, 218, 36, 234, 36, 2, 93, 64, 27, 9, 36, 25, 36, 41, 36, 57, 36, 73, 36, 89, 36, 105, 36, 121, 36, 137, 36, 153, 36, 169, 36, 185, 36, 201, 36, 13, 93, 0, 176, 0, 69, 88, 176, 20, 47, 27, 177, 20, 19, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 15, 62, 89, 176, 20, 16, 177, 0, 6, 244, 176, 23, 208, 176, 10, 16, 177, 31, 6, 244, 64, 27, 7, 31, 23, 31, 39, 31, 55, 31, 71, 31, 87, 31, 103, 31, 119, 31, 135, 31, 151, 31, 167, 31, 183, 31, 199, 31, 13, 93, 180, 214, 31, 230, 31, 2, 93, 176, 23, 16, 176, 41, 208, 48, 49, 1, 30, 3, 21, 20, 14, 2, 35, 34, 46, 2, 53, 52, 62, 2, 51, 33, 21, 33, 34, 6, 21, 20, 30, 2, 51, 50, 62, 2, 53, 52, 46, 2, 39, 2, 137, 43, 84, 68, 41, 66, 121, 166, 100, 102, 166, 119, 65, 73, 131, 181, 106, 2, 35, 253, 219, 170, 182, 43, 82, 114, 74, 74, 117, 84, 43, 35, 66, 90, 57, 3, 47, 18, 78, 105, 120, 62, 102, 166, 121, 66, 72, 127, 178, 109, 106, 174, 123, 66, 117, 192, 160, 78, 135, 98, 58, 51, 88, 125, 74, 60, 118, 105, 80, 20, 0, 1, 0, 0, 255, 233, 3, 164, 3, 164, 0, 19, 0, 92, 179, 5, 8, 0, 4, 43, 0, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 19, 62, 89, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 15, 62, 89, 176, 2, 16, 177, 0, 6, 244, 176, 4, 208, 176, 5, 208, 176, 14, 16, 177, 8, 6, 244, 64, 27, 7, 8, 23, 8, 39, 8, 55, 8, 71, 8, 87, 8, 103, 8, 119, 8, 135, 8, 151, 8, 167, 8, 183, 8, 199, 8, 13, 93, 180, 214, 8, 230, 8, 2, 93, 48, 49, 1, 33, 53, 33, 21, 33, 17, 20, 51, 50, 54, 55, 23, 6, 35, 34, 46, 2, 53, 1, 141, 254, 115, 3, 164, 254, 115, 106, 29, 35, 14, 26, 40, 82, 45, 82, 62, 37, 3, 47, 117, 117, 253, 160, 113, 8, 7, 107, 25, 31, 58, 86, 55, 0, 0, 1, 0, 49, 255, 233, 3, 164, 3, 182, 0, 29, 0, 149, 176, 30, 47, 176, 31, 47, 176, 30, 16, 176, 5, 208, 176, 5, 47, 177, 8, 12, 244, 176, 31, 16, 176, 25, 220, 177, 18, 12, 244, 180, 218, 18, 234, 18, 2, 93, 64, 27, 9, 18, 25, 18, 41, 18, 57, 18, 73, 18, 89, 18, 105, 18, 121, 18, 137, 18, 153, 18, 169, 18, 185, 18, 201, 18, 13, 93, 0, 176, 0, 69, 88, 176, 22, 47, 27, 177, 22, 19, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 177, 13, 3, 244, 64, 27, 7, 13, 23, 13, 39, 13, 55, 13, 71, 13, 87, 13, 103, 13, 119, 13, 135, 13, 151, 13, 167, 13, 183, 13, 199, 13, 13, 93, 180, 214, 13, 230, 13, 2, 93, 48, 49, 5, 34, 46, 2, 53, 17, 51, 17, 20, 30, 2, 51, 50, 62, 2, 53, 52, 38, 39, 55, 22, 22, 21, 20, 14, 2, 1, 211, 94, 154, 110, 60, 137, 45, 76, 103, 57, 92, 125, 76, 35, 37, 43, 133, 41, 43, 53, 113, 176, 23, 48, 96, 141, 96, 2, 62, 253, 194, 61, 98, 68, 35, 78, 123, 147, 68, 104, 189, 92, 53, 96, 219, 123, 94, 191, 153, 97, 0, 2, 255, 236, 254, 139, 3, 190, 3, 186, 0, 33, 0, 45, 0, 183, 179, 25, 12, 18, 4, 43, 179, 11, 8, 12, 4, 43, 179, 5, 12, 37, 4, 43, 64, 27, 6, 25, 22, 25, 38, 25, 54, 25, 70, 25, 86, 25, 102, 25, 118, 25, 134, 25, 150, 25, 166, 25, 182, 25, 198, 25, 13, 93, 180, 213, 25, 229, 25, 2, 93, 176, 12, 16, 176, 28, 208, 176, 11, 16, 176, 34, 208, 180, 218, 37, 234, 37, 2, 93, 64, 27, 9, 37, 25, 37, 41, 37, 57, 37, 73, 37, 89, 37, 105, 37, 121, 37, 137, 37, 153, 37, 169, 37, 185, 37, 201, 37, 13, 93, 176, 5, 16, 176, 47, 220, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 19, 62, 89, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 17, 62, 89, 176, 0, 16, 177, 42, 6, 244, 180, 217, 42, 233, 42, 2, 93, 64, 27, 8, 42, 24, 42, 40, 42, 56, 42, 72, 42, 88, 42, 104, 42, 120, 42, 136, 42, 152, 42, 168, 42, 184, 42, 200, 42, 13, 93, 48, 49, 1, 50, 30, 2, 21, 20, 14, 2, 7, 17, 35, 17, 46, 3, 53, 52, 54, 55, 23, 6, 6, 21, 20, 22, 23, 17, 52, 62, 2, 3, 54, 54, 53, 52, 46, 2, 35, 34, 6, 21, 2, 84, 82, 133, 94, 53, 61, 111, 155, 96, 138, 94, 153, 111, 59, 100, 92, 82, 66, 71, 145, 135, 19, 45, 76, 2, 135, 151, 41, 63, 82, 39, 35, 26, 3, 186, 71, 129, 181, 108, 98, 170, 125, 80, 10, 254, 157, 1, 99, 10, 80, 127, 168, 98, 131, 229, 70, 94, 53, 175, 108, 141, 201, 23, 2, 131, 43, 78, 58, 32, 252, 170, 23, 201, 141, 80, 135, 100, 58, 45, 50, 0, 1, 255, 248, 254, 117, 3, 164, 3, 188, 0, 11, 0, 60, 0, 176, 0, 47, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 19, 62, 89, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 19, 62, 89, 178, 1, 0, 6, 17, 18, 57, 178, 3, 0, 6, 17, 18, 57, 178, 7, 0, 6, 17, 18, 57, 178, 9, 0, 6, 17, 18, 57, 48, 49, 9, 2, 35, 1, 1, 55, 1, 1, 51, 1, 1, 3, 12, 254, 201, 254, 199, 164, 1, 141, 254, 141, 121, 1, 74, 1, 45, 162, 254, 129, 1, 94, 254, 117, 2, 43, 253, 235, 2, 131, 2, 105, 69, 253, 193, 2, 39, 253, 106, 253, 174, 0, 0, 1, 0, 49, 254, 139, 3, 115, 4, 94, 0, 27, 0, 75, 179, 12, 12, 9, 4, 43, 179, 4, 8, 5, 4, 43, 179, 0, 8, 25, 4, 43, 176, 5, 16, 176, 17, 208, 176, 4, 16, 176, 19, 208, 0, 176, 18, 47, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 19, 62, 89, 176, 0, 69, 88, 176, 26, 47, 27, 177, 26, 19, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 17, 62, 89, 48, 49, 1, 20, 2, 7, 17, 35, 17, 38, 2, 53, 17, 51, 17, 20, 30, 2, 23, 17, 51, 17, 62, 3, 53, 17, 51, 3, 115, 168, 180, 138, 182, 166, 137, 17, 45, 82, 67, 138, 65, 82, 47, 16, 138, 1, 209, 205, 255, 0, 22, 254, 157, 1, 99, 22, 1, 2, 205, 1, 209, 254, 45, 53, 117, 102, 78, 15, 3, 250, 252, 6, 15, 78, 102, 117, 53, 1, 211, 0, 1, 255, 242, 255, 233, 3, 182, 3, 182, 0, 52, 0, 214, 179, 19, 12, 8, 4, 43, 179, 28, 8, 25, 4, 43, 179, 45, 12, 34, 4, 43, 178, 0, 25, 28, 17, 18, 57, 64, 27, 6, 19, 22, 19, 38, 19, 54, 19, 70, 19, 86, 19, 102, 19, 118, 19, 134, 19, 150, 19, 166, 19, 182, 19, 198, 19, 13, 93, 180, 213, 19, 229, 19, 2, 93, 180, 218, 34, 234, 34, 2, 93, 64, 27, 9, 34, 25, 34, 41, 34, 57, 34, 73, 34, 89, 34, 105, 34, 121, 34, 137, 34, 153, 34, 169, 34, 185, 34, 201, 34, 13, 93, 176, 45, 16, 176, 54, 220, 0, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 19, 62, 89, 176, 0, 69, 88, 176, 40, 47, 27, 177, 40, 19, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 176, 0, 69, 88, 176, 50, 47, 27, 177, 50, 15, 62, 89, 178, 0, 3, 13, 17, 18, 57, 176, 3, 16, 177, 22, 6, 244, 64, 27, 7, 22, 23, 22, 39, 22, 55, 22, 71, 22, 87, 22, 103, 22, 119, 22, 135, 22, 151, 22, 167, 22, 183, 22, 199, 22, 13, 93, 180, 214, 22, 230, 22, 2, 93, 176, 31, 208, 48, 49, 37, 6, 6, 35, 34, 46, 2, 53, 52, 62, 2, 55, 23, 14, 3, 21, 20, 22, 51, 50, 54, 53, 17, 51, 17, 20, 22, 51, 50, 54, 53, 52, 46, 2, 39, 55, 30, 3, 21, 20, 14, 2, 35, 34, 38, 1, 211, 23, 114, 80, 72, 100, 64, 28, 10, 22, 31, 21, 135, 23, 30, 21, 8, 57, 70, 61, 86, 138, 88, 61, 70, 59, 10, 21, 30, 23, 135, 21, 33, 20, 12, 28, 64, 100, 74, 80, 115, 162, 82, 103, 68, 119, 168, 100, 62, 141, 139, 129, 47, 53, 45, 117, 127, 125, 51, 172, 166, 164, 148, 1, 81, 254, 175, 148, 164, 166, 172, 51, 125, 127, 117, 45, 53, 47, 129, 139, 141, 62, 100, 168, 119, 68, 103, 0, 255, 255, 0, 186, 255, 233, 2, 233, 5, 25, 2, 38, 1, 167, 0, 0, 0, 6, 0, 140, 0, 0, 255, 255, 0, 49, 255, 233, 3, 164, 5, 25, 2, 38, 1, 178, 0, 0, 0, 6, 0, 140, 0, 0, 255, 255, 255, 236, 255, 233, 3, 188, 6, 47, 2, 34, 1, 173, 0, 0, 0, 2, 1, 119, 0, 0, 255, 255, 0, 49, 255, 233, 3, 164, 6, 47, 2, 38, 1, 178, 0, 0, 0, 6, 1, 119, 0, 0, 255, 255, 255, 242, 255, 233, 3, 182, 6, 47, 2, 38, 1, 182, 0, 0, 0, 6, 1, 119, 0, 0, 255, 255, 0, 49, 0, 0, 3, 115, 6, 142, 2, 38, 1, 207, 0, 0, 0, 7, 0, 140, 0, 0, 1, 117, 0, 1, 255, 119, 255, 233, 3, 115, 5, 25, 0, 35, 0, 232, 176, 36, 47, 176, 37, 47, 176, 36, 16, 176, 33, 208, 176, 33, 47, 177, 32, 12, 244, 176, 3, 208, 176, 37, 16, 176, 9, 220, 178, 4, 33, 9, 17, 18, 57, 178, 17, 33, 9, 17, 18, 57, 177, 22, 8, 244, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 21, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 19, 62, 89, 176, 0, 69, 88, 176, 16, 47, 27, 177, 16, 15, 62, 89, 176, 0, 69, 88, 176, 32, 47, 27, 177, 32, 15, 62, 89, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 15, 62, 89, 176, 0, 16, 177, 2, 6, 244, 178, 4, 14, 0, 17, 18, 57, 178, 17, 14, 0, 17, 18, 57, 176, 14, 16, 177, 20, 6, 244, 64, 27, 7, 20, 23, 20, 39, 20, 55, 20, 71, 20, 87, 20, 103, 20, 119, 20, 135, 20, 151, 20, 167, 20, 183, 20, 199, 20, 13, 93, 180, 214, 20, 230, 20, 2, 93, 176, 6, 16, 177, 26, 6, 244, 180, 217, 26, 233, 26, 2, 93, 64, 27, 8, 26, 24, 26, 40, 26, 56, 26, 72, 26, 88, 26, 104, 26, 120, 26, 136, 26, 152, 26, 168, 26, 184, 26, 200, 26, 13, 93, 176, 2, 16, 176, 34, 208, 176, 35, 208, 48, 49, 3, 33, 21, 35, 17, 18, 51, 32, 17, 17, 20, 14, 2, 35, 34, 39, 55, 22, 22, 51, 50, 53, 17, 52, 38, 35, 34, 14, 2, 21, 17, 35, 17, 35, 137, 1, 254, 187, 99, 254, 1, 88, 37, 62, 82, 45, 84, 38, 26, 14, 35, 29, 106, 108, 121, 76, 123, 86, 45, 137, 186, 5, 25, 117, 254, 22, 1, 0, 254, 133, 254, 144, 55, 86, 58, 31, 25, 109, 9, 8, 113, 1, 112, 125, 138, 70, 117, 151, 82, 254, 94, 4, 164, 0, 255, 255, 0, 49, 0, 0, 3, 164, 6, 201, 2, 38, 1, 205, 0, 0, 0, 7, 0, 139, 0, 0, 1, 117, 0, 1, 255, 236, 255, 233, 3, 172, 5, 47, 0, 46, 0, 183, 176, 47, 47, 176, 48, 47, 176, 21, 220, 176, 0, 208, 176, 0, 47, 176, 47, 16, 176, 11, 208, 176, 11, 47, 176, 21, 16, 177, 20, 13, 244, 176, 23, 208, 176, 11, 16, 177, 36, 8, 244, 176, 33, 208, 176, 20, 16, 176, 46, 208, 176, 46, 47, 0, 176, 0, 69, 88, 176, 16, 47, 27, 177, 16, 21, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 179, 34, 6, 35, 4, 43, 178, 19, 4, 16, 17, 18, 57, 176, 16, 16, 177, 28, 6, 244, 180, 217, 28, 233, 28, 2, 93, 64, 27, 8, 28, 24, 28, 40, 28, 56, 28, 72, 28, 88, 28, 104, 28, 120, 28, 136, 28, 152, 28, 168, 28, 184, 28, 200, 28, 13, 93, 176, 4, 16, 177, 44, 6, 244, 64, 27, 7, 44, 23, 44, 39, 44, 55, 44, 71, 44, 87, 44, 103, 44, 119, 44, 135, 44, 151, 44, 167, 44, 183, 44, 199, 44, 13, 93, 180, 214, 44, 230, 44, 2, 93, 48, 49, 1, 6, 7, 6, 35, 34, 46, 4, 53, 52, 62, 2, 51, 50, 22, 23, 53, 51, 17, 35, 52, 46, 2, 35, 34, 14, 2, 7, 33, 21, 33, 22, 22, 23, 30, 3, 51, 50, 19, 3, 172, 51, 116, 116, 176, 91, 145, 112, 79, 51, 23, 54, 119, 191, 137, 121, 171, 42, 117, 117, 53, 90, 122, 69, 96, 134, 85, 43, 5, 2, 70, 253, 186, 3, 35, 38, 21, 55, 71, 87, 53, 244, 96, 1, 86, 167, 100, 98, 52, 91, 126, 150, 167, 88, 131, 244, 188, 113, 86, 88, 152, 254, 84, 70, 122, 90, 51, 84, 138, 176, 91, 117, 88, 171, 71, 39, 66, 48, 27, 1, 39, 0, 1, 0, 25, 255, 233, 3, 131, 5, 47, 0, 63, 0, 211, 179, 12, 10, 32, 4, 43, 179, 42, 11, 41, 4, 43, 176, 41, 16, 177, 0, 8, 244, 176, 12, 16, 176, 8, 208, 176, 41, 16, 176, 44, 208, 176, 32, 16, 177, 54, 12, 244, 176, 42, 16, 176, 65, 220, 0, 176, 0, 69, 88, 176, 41, 47, 27, 177, 41, 21, 62, 89, 176, 0, 69, 88, 176, 43, 47, 27, 177, 43, 19, 62, 89, 176, 0, 69, 88, 176, 37, 47, 27, 177, 37, 21, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 15, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 178, 8, 5, 37, 17, 18, 57, 177, 17, 6, 244, 64, 27, 7, 17, 23, 17, 39, 17, 55, 17, 71, 17, 87, 17, 103, 17, 119, 17, 135, 17, 151, 17, 167, 17, 183, 17, 199, 17, 13, 93, 180, 214, 17, 230, 17, 2, 93, 178, 40, 5, 37, 17, 18, 57, 176, 37, 16, 177, 49, 6, 244, 180, 217, 49, 233, 49, 2, 93, 64, 27, 8, 49, 24, 49, 40, 49, 56, 49, 72, 49, 88, 49, 104, 49, 120, 49, 136, 49, 152, 49, 168, 49, 184, 49, 200, 49, 13, 93, 48, 49, 1, 20, 14, 2, 35, 34, 38, 39, 21, 35, 17, 51, 20, 30, 2, 51, 50, 62, 2, 53, 52, 46, 2, 39, 46, 3, 53, 52, 62, 2, 51, 50, 22, 23, 53, 51, 17, 35, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 23, 30, 3, 3, 131, 68, 114, 148, 80, 110, 184, 54, 116, 116, 62, 96, 125, 65, 58, 98, 74, 43, 55, 93, 116, 60, 71, 142, 112, 70, 68, 110, 146, 77, 95, 161, 45, 121, 121, 49, 84, 108, 60, 53, 96, 72, 43, 51, 86, 113, 59, 74, 146, 116, 74, 1, 84, 82, 133, 96, 52, 82, 80, 139, 1, 141, 67, 111, 80, 45, 33, 61, 88, 56, 63, 90, 64, 45, 22, 25, 55, 84, 121, 90, 80, 125, 86, 45, 78, 80, 136, 254, 139, 59, 103, 73, 43, 24, 53, 84, 58, 51, 72, 55, 45, 23, 26, 64, 90, 131, 0, 1, 0, 186, 0, 0, 2, 233, 5, 25, 0, 11, 0, 61, 179, 10, 8, 3, 4, 43, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 177, 2, 6, 244, 176, 6, 16, 177, 4, 6, 244, 176, 8, 208, 176, 9, 208, 176, 2, 16, 176, 10, 208, 176, 11, 208, 48, 49, 33, 33, 53, 51, 17, 35, 53, 33, 21, 35, 17, 51, 2, 233, 253, 209, 211, 211, 2, 47, 210, 210, 117, 4, 47, 117, 117, 251, 209, 255, 255, 0, 186, 0, 0, 2, 233, 6, 140, 2, 38, 0, 42, 0, 0, 0, 7, 0, 140, 0, 0, 1, 115, 0, 1, 255, 254, 255, 233, 3, 115, 5, 25, 0, 17, 0, 76, 179, 0, 8, 15, 4, 43, 0, 176, 0, 69, 88, 176, 16, 47, 27, 177, 16, 21, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 177, 10, 6, 244, 64, 27, 7, 10, 23, 10, 39, 10, 55, 10, 71, 10, 87, 10, 103, 10, 119, 10, 135, 10, 151, 10, 167, 10, 183, 10, 199, 10, 13, 93, 180, 214, 10, 230, 10, 2, 93, 48, 49, 1, 20, 2, 35, 34, 38, 39, 55, 22, 22, 51, 50, 62, 2, 53, 17, 51, 3, 115, 211, 217, 174, 236, 47, 119, 43, 170, 125, 92, 115, 61, 22, 138, 1, 242, 248, 254, 239, 183, 182, 45, 162, 131, 74, 115, 143, 72, 3, 39, 0, 0, 2, 255, 117, 255, 233, 3, 156, 5, 25, 0, 8, 0, 36, 0, 186, 179, 21, 12, 35, 4, 43, 179, 5, 12, 18, 4, 43, 179, 14, 8, 0, 4, 43, 180, 218, 0, 234, 0, 2, 93, 64, 27, 9, 0, 25, 0, 41, 0, 57, 0, 73, 0, 89, 0, 105, 0, 121, 0, 137, 0, 153, 0, 169, 0, 185, 0, 201, 0, 13, 93, 176, 5, 16, 176, 9, 208, 176, 14, 16, 176, 38, 220, 0, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 21, 62, 89, 176, 0, 69, 88, 176, 17, 47, 27, 177, 17, 15, 62, 89, 176, 0, 69, 88, 176, 29, 47, 27, 177, 29, 15, 62, 89, 176, 0, 69, 88, 176, 26, 47, 27, 177, 26, 15, 62, 89, 179, 11, 6, 3, 4, 43, 176, 9, 16, 177, 19, 6, 244, 178, 30, 26, 9, 17, 18, 57, 176, 26, 16, 177, 33, 6, 244, 64, 27, 7, 33, 23, 33, 39, 33, 55, 33, 71, 33, 87, 33, 103, 33, 119, 33, 135, 33, 151, 33, 167, 33, 183, 33, 199, 33, 13, 93, 180, 214, 33, 230, 33, 2, 93, 48, 49, 1, 52, 38, 35, 35, 17, 51, 50, 54, 1, 17, 51, 50, 22, 21, 20, 6, 35, 35, 17, 35, 17, 20, 14, 2, 35, 34, 38, 39, 55, 22, 22, 51, 50, 53, 17, 3, 18, 108, 92, 76, 76, 92, 108, 254, 236, 74, 161, 179, 179, 163, 209, 187, 32, 58, 76, 43, 40, 54, 22, 24, 13, 32, 25, 94, 1, 113, 127, 133, 254, 0, 127, 4, 37, 253, 208, 188, 188, 187, 182, 4, 164, 252, 43, 55, 86, 58, 31, 9, 10, 115, 9, 8, 113, 4, 74, 0, 2, 0, 49, 0, 0, 3, 156, 5, 25, 0, 8, 0, 27, 0, 159, 179, 27, 12, 9, 4, 43, 179, 16, 12, 13, 4, 43, 179, 20, 8, 0, 4, 43, 180, 218, 0, 234, 0, 2, 93, 64, 27, 9, 0, 25, 0, 41, 0, 57, 0, 73, 0, 89, 0, 105, 0, 121, 0, 137, 0, 153, 0, 169, 0, 185, 0, 201, 0, 13, 93, 176, 16, 16, 176, 4, 208, 176, 27, 16, 176, 11, 208, 176, 13, 16, 176, 24, 208, 176, 20, 16, 176, 29, 220, 0, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 21, 62, 89, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 21, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 15, 62, 89, 176, 0, 69, 88, 176, 23, 47, 27, 177, 23, 15, 62, 89, 179, 17, 6, 3, 4, 43, 176, 23, 16, 177, 5, 6, 244, 176, 17, 16, 176, 12, 208, 176, 3, 16, 176, 25, 208, 48, 49, 1, 52, 38, 35, 35, 17, 51, 50, 54, 5, 17, 51, 17, 51, 17, 51, 17, 51, 50, 22, 21, 20, 6, 35, 35, 17, 35, 17, 3, 18, 108, 92, 76, 76, 92, 108, 253, 31, 137, 187, 137, 74, 161, 179, 179, 163, 209, 187, 1, 113, 127, 133, 254, 0, 127, 244, 5, 25, 253, 208, 2, 48, 253, 208, 188, 188, 187, 182, 2, 117, 253, 139, 0, 0, 1, 255, 119, 0, 0, 3, 115, 5, 25, 0, 23, 0, 161, 176, 24, 47, 176, 25, 47, 176, 24, 16, 176, 21, 208, 176, 21, 47, 177, 20, 12, 244, 176, 3, 208, 176, 25, 16, 176, 9, 220, 178, 4, 21, 9, 17, 18, 57, 177, 10, 8, 244, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 21, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 19, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 15, 62, 89, 176, 0, 69, 88, 176, 20, 47, 27, 177, 20, 15, 62, 89, 176, 0, 16, 177, 2, 6, 244, 178, 4, 9, 0, 17, 18, 57, 176, 6, 16, 177, 14, 6, 244, 180, 217, 14, 233, 14, 2, 93, 64, 27, 8, 14, 24, 14, 40, 14, 56, 14, 72, 14, 88, 14, 104, 14, 120, 14, 136, 14, 152, 14, 168, 14, 184, 14, 200, 14, 13, 93, 176, 2, 16, 176, 22, 208, 176, 23, 208, 48, 49, 3, 33, 21, 35, 17, 18, 51, 32, 17, 17, 35, 17, 52, 38, 35, 34, 14, 2, 21, 17, 35, 17, 35, 137, 1, 254, 187, 99, 254, 1, 88, 138, 108, 121, 76, 123, 86, 45, 137, 186, 5, 25, 117, 254, 22, 1, 0, 254, 133, 253, 193, 2, 63, 125, 138, 70, 117, 151, 82, 254, 94, 4, 164, 255, 255, 0, 49, 0, 0, 3, 158, 6, 201, 2, 38, 1, 212, 0, 0, 0, 7, 0, 139, 0, 0, 1, 117, 255, 255, 255, 225, 255, 233, 3, 193, 6, 123, 2, 38, 1, 221, 0, 0, 0, 7, 0, 217, 0, 0, 1, 117, 0, 1, 0, 49, 254, 193, 3, 115, 5, 25, 0, 11, 0, 83, 179, 8, 12, 5, 4, 43, 179, 2, 8, 3, 4, 43, 179, 0, 8, 9, 4, 43, 0, 176, 2, 47, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 177, 8, 6, 244, 176, 9, 208, 48, 49, 33, 33, 17, 35, 17, 33, 17, 51, 17, 33, 17, 51, 3, 115, 254, 164, 138, 254, 164, 137, 2, 47, 138, 254, 193, 1, 63, 5, 25, 251, 92, 4, 164, 0, 2, 255, 197, 0, 0, 3, 227, 5, 25, 0, 7, 0, 10, 0, 48, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 179, 8, 3, 2, 4, 43, 48, 49, 33, 35, 3, 33, 3, 35, 1, 51, 19, 3, 3, 3, 227, 147, 123, 253, 252, 121, 147, 1, 178, 186, 125, 219, 219, 1, 117, 254, 139, 5, 25, 252, 213, 2, 161, 253, 95, 0, 0, 2, 0, 49, 0, 0, 3, 162, 5, 25, 0, 8, 0, 21, 0, 115, 176, 22, 47, 176, 23, 47, 176, 13, 220, 177, 0, 12, 244, 180, 218, 0, 234, 0, 2, 93, 64, 27, 9, 0, 25, 0, 41, 0, 57, 0, 73, 0, 89, 0, 105, 0, 121, 0, 137, 0, 153, 0, 169, 0, 185, 0, 201, 0, 13, 93, 176, 22, 16, 176, 17, 208, 176, 17, 47, 177, 5, 12, 244, 176, 9, 208, 0, 176, 0, 69, 88, 176, 18, 47, 27, 177, 18, 21, 62, 89, 176, 0, 69, 88, 176, 16, 47, 27, 177, 16, 15, 62, 89, 179, 10, 6, 3, 4, 43, 176, 16, 16, 177, 5, 6, 244, 176, 18, 16, 177, 20, 6, 244, 48, 49, 1, 52, 38, 35, 33, 17, 33, 50, 54, 1, 33, 50, 22, 21, 20, 6, 35, 33, 17, 33, 21, 33, 3, 25, 170, 142, 254, 217, 1, 39, 142, 170, 253, 161, 1, 39, 213, 236, 236, 215, 254, 82, 3, 66, 253, 71, 1, 113, 127, 133, 254, 0, 127, 1, 245, 188, 188, 187, 182, 5, 25, 117, 0, 0, 3, 0, 49, 0, 0, 3, 162, 5, 25, 0, 14, 0, 27, 0, 36, 0, 135, 179, 33, 12, 4, 4, 43, 179, 11, 12, 15, 4, 43, 176, 11, 16, 177, 28, 10, 244, 177, 0, 12, 244, 178, 13, 4, 0, 17, 18, 57, 180, 218, 15, 234, 15, 2, 93, 64, 27, 9, 15, 25, 15, 41, 15, 57, 15, 73, 15, 89, 15, 105, 15, 121, 15, 137, 15, 153, 15, 169, 15, 185, 15, 201, 15, 13, 93, 176, 33, 16, 176, 21, 208, 176, 11, 16, 176, 38, 220, 0, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 21, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 179, 23, 1, 31, 4, 43, 178, 13, 31, 23, 17, 18, 57, 176, 5, 16, 177, 20, 6, 244, 176, 3, 16, 177, 33, 6, 244, 48, 49, 1, 20, 6, 35, 33, 17, 33, 50, 30, 2, 21, 20, 7, 22, 3, 52, 46, 2, 35, 33, 17, 33, 50, 62, 2, 19, 52, 38, 35, 33, 17, 33, 50, 54, 3, 162, 242, 223, 254, 96, 1, 137, 82, 158, 125, 78, 203, 248, 182, 58, 90, 108, 50, 255, 0, 1, 0, 56, 108, 86, 56, 45, 175, 153, 254, 233, 1, 23, 153, 175, 1, 117, 187, 186, 5, 25, 27, 74, 131, 106, 203, 74, 76, 1, 97, 69, 88, 47, 17, 254, 69, 17, 49, 86, 253, 244, 135, 123, 253, 254, 129, 0, 1, 0, 49, 0, 0, 3, 164, 5, 25, 0, 5, 0, 42, 179, 3, 12, 0, 4, 43, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 21, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 176, 0, 16, 177, 2, 6, 244, 48, 49, 19, 33, 21, 33, 17, 35, 49, 3, 115, 253, 22, 137, 5, 25, 117, 251, 92, 0, 0, 2, 0, 0, 254, 193, 3, 164, 5, 25, 0, 15, 0, 24, 0, 82, 179, 13, 11, 0, 4, 43, 179, 16, 12, 5, 4, 43, 179, 8, 12, 22, 4, 43, 179, 10, 11, 11, 4, 43, 176, 10, 16, 176, 26, 220, 0, 176, 10, 47, 176, 14, 47, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 12, 47, 27, 177, 12, 15, 62, 89, 177, 8, 6, 244, 176, 21, 208, 176, 22, 208, 176, 6, 16, 177, 23, 6, 244, 48, 49, 53, 62, 2, 18, 53, 17, 33, 17, 51, 17, 35, 17, 33, 17, 35, 1, 20, 2, 6, 6, 7, 33, 17, 35, 57, 88, 60, 31, 1, 253, 187, 123, 253, 82, 123, 1, 117, 23, 49, 80, 57, 1, 188, 235, 117, 49, 113, 188, 1, 35, 225, 1, 66, 251, 92, 254, 76, 1, 63, 254, 193, 5, 22, 176, 254, 242, 209, 154, 57, 4, 47, 0, 0, 1, 0, 49, 0, 0, 3, 115, 5, 25, 0, 11, 0, 61, 179, 10, 12, 1, 4, 43, 176, 10, 16, 176, 5, 208, 0, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 179, 7, 6, 8, 4, 43, 176, 2, 16, 177, 4, 6, 244, 176, 0, 16, 177, 10, 6, 244, 48, 49, 33, 33, 17, 33, 21, 33, 17, 33, 21, 33, 17, 33, 3, 115, 252, 190, 3, 66, 253, 71, 2, 2, 253, 254, 2, 185, 5, 25, 117, 254, 45, 117, 254, 25, 0, 0, 1, 255, 193, 0, 0, 3, 227, 5, 25, 0, 19, 0, 127, 179, 19, 8, 0, 4, 43, 176, 0, 16, 176, 8, 208, 176, 19, 16, 176, 10, 208, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 21, 62, 89, 176, 0, 69, 88, 176, 12, 47, 27, 177, 12, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 15, 62, 89, 178, 2, 0, 6, 17, 18, 57, 178, 8, 0, 6, 17, 18, 57, 178, 11, 0, 6, 17, 18, 57, 178, 17, 0, 6, 17, 18, 57, 48, 49, 33, 17, 39, 1, 35, 1, 1, 51, 1, 17, 51, 17, 1, 51, 1, 1, 35, 1, 7, 17, 1, 141, 55, 254, 250, 143, 1, 63, 254, 193, 149, 1, 55, 138, 1, 55, 149, 254, 193, 1, 63, 143, 254, 250, 55, 2, 6, 100, 253, 150, 2, 225, 2, 56, 253, 188, 2, 68, 253, 188, 2, 68, 253, 200, 253, 31, 2, 106, 100, 253, 250, 0, 1, 0, 27, 255, 233, 3, 152, 5, 47, 0, 62, 0, 228, 179, 45, 13, 43, 4, 43, 179, 55, 12, 31, 4, 43, 176, 55, 16, 177, 20, 9, 244, 177, 0, 8, 244, 176, 45, 16, 176, 11, 208, 176, 11, 47, 180, 218, 31, 234, 31, 2, 93, 64, 27, 9, 31, 25, 31, 41, 31, 57, 31, 73, 31, 89, 31, 105, 31, 121, 31, 137, 31, 153, 31, 169, 31, 185, 31, 201, 31, 13, 93, 176, 45, 16, 176, 41, 208, 176, 41, 47, 178, 58, 43, 0, 17, 18, 57, 176, 55, 16, 176, 64, 220, 0, 176, 0, 69, 88, 176, 50, 47, 27, 177, 50, 21, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 179, 26, 6, 25, 4, 43, 176, 5, 16, 177, 15, 6, 244, 64, 27, 7, 15, 23, 15, 39, 15, 55, 15, 71, 15, 87, 15, 103, 15, 119, 15, 135, 15, 151, 15, 167, 15, 183, 15, 199, 15, 13, 93, 180, 214, 15, 230, 15, 2, 93, 176, 50, 16, 177, 35, 6, 244, 180, 217, 35, 233, 35, 2, 93, 64, 27, 8, 35, 24, 35, 40, 35, 56, 35, 72, 35, 88, 35, 104, 35, 120, 35, 136, 35, 152, 35, 168, 35, 184, 35, 200, 35, 13, 93, 178, 45, 5, 50, 17, 18, 57, 178, 58, 25, 26, 17, 18, 57, 48, 49, 1, 20, 14, 2, 35, 34, 46, 2, 39, 55, 22, 23, 22, 51, 50, 62, 2, 53, 52, 46, 2, 35, 53, 50, 62, 2, 53, 52, 39, 38, 35, 34, 6, 7, 6, 6, 21, 35, 17, 51, 21, 62, 3, 51, 50, 30, 2, 21, 20, 6, 7, 30, 3, 3, 152, 70, 117, 153, 84, 94, 164, 125, 78, 8, 133, 12, 93, 92, 139, 59, 104, 78, 45, 50, 97, 142, 92, 67, 128, 100, 62, 73, 73, 116, 65, 121, 42, 40, 54, 125, 117, 24, 74, 88, 96, 48, 84, 146, 107, 62, 132, 124, 69, 105, 71, 36, 1, 104, 86, 141, 100, 56, 51, 102, 150, 99, 18, 150, 77, 76, 40, 70, 98, 58, 80, 101, 57, 20, 117, 22, 54, 89, 67, 110, 66, 67, 50, 41, 38, 112, 76, 1, 156, 152, 49, 66, 41, 18, 49, 92, 134, 85, 112, 146, 19, 10, 60, 89, 111, 0, 0, 1, 0, 49, 0, 0, 3, 115, 5, 25, 0, 9, 0, 98, 176, 10, 47, 176, 11, 47, 176, 10, 16, 176, 0, 208, 176, 0, 47, 177, 1, 12, 244, 176, 11, 16, 176, 5, 220, 177, 6, 8, 244, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 21, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 21, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 15, 62, 89, 178, 2, 5, 0, 17, 18, 57, 178, 7, 5, 0, 17, 18, 57, 48, 49, 19, 51, 17, 1, 51, 17, 35, 17, 1, 35, 49, 137, 1, 248, 193, 138, 253, 242, 170, 5, 25, 251, 227, 4, 29, 250, 231, 4, 80, 251, 176, 0, 255, 255, 0, 49, 0, 0, 3, 115, 6, 121, 2, 38, 1, 210, 0, 0, 0, 7, 0, 217, 0, 0, 1, 115, 0, 1, 0, 49, 0, 0, 3, 158, 5, 25, 0, 11, 0, 74, 179, 4, 12, 5, 4, 43, 176, 4, 16, 176, 7, 208, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 178, 8, 0, 6, 17, 18, 57, 48, 49, 33, 35, 1, 7, 17, 35, 17, 51, 17, 1, 51, 1, 3, 158, 168, 254, 78, 138, 137, 137, 2, 47, 181, 254, 0, 2, 127, 154, 254, 27, 5, 25, 253, 133, 2, 123, 253, 198, 0, 1, 255, 231, 255, 233, 3, 115, 5, 25, 0, 19, 0, 139, 176, 20, 47, 176, 21, 47, 176, 1, 220, 177, 2, 8, 244, 176, 20, 16, 176, 18, 208, 176, 18, 47, 177, 5, 8, 244, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 21, 62, 89, 176, 0, 69, 88, 176, 1, 47, 27, 177, 1, 15, 62, 89, 176, 0, 69, 88, 176, 12, 47, 27, 177, 12, 15, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 15, 62, 89, 176, 0, 16, 177, 3, 6, 244, 178, 13, 10, 0, 17, 18, 57, 176, 10, 16, 177, 16, 6, 244, 64, 27, 7, 16, 23, 16, 39, 16, 55, 16, 71, 16, 87, 16, 103, 16, 119, 16, 135, 16, 151, 16, 167, 16, 183, 16, 199, 16, 13, 93, 180, 214, 16, 230, 16, 2, 93, 48, 49, 1, 17, 35, 17, 33, 17, 20, 14, 2, 35, 34, 39, 55, 22, 22, 51, 50, 53, 17, 3, 115, 138, 254, 91, 37, 62, 82, 45, 84, 39, 27, 14, 35, 29, 106, 5, 25, 250, 231, 4, 164, 252, 43, 55, 86, 58, 31, 25, 109, 9, 8, 113, 4, 74, 0, 0, 1, 0, 49, 0, 0, 3, 115, 5, 25, 0, 12, 0, 109, 176, 13, 47, 176, 14, 47, 176, 0, 220, 177, 1, 8, 244, 176, 13, 16, 176, 7, 208, 176, 7, 47, 177, 6, 12, 244, 178, 10, 7, 0, 17, 18, 57, 0, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 21, 62, 89, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 178, 2, 0, 8, 17, 18, 57, 178, 5, 0, 8, 17, 18, 57, 178, 10, 0, 8, 17, 18, 57, 48, 49, 33, 35, 17, 3, 35, 3, 17, 35, 17, 51, 19, 19, 51, 3, 115, 138, 231, 98, 230, 137, 178, 238, 240, 178, 4, 63, 253, 95, 2, 161, 251, 193, 5, 25, 253, 86, 2, 170, 0, 0, 1, 0, 49, 0, 0, 3, 115, 5, 25, 0, 11, 0, 96, 176, 12, 47, 176, 13, 47, 176, 0, 220, 177, 1, 8, 244, 176, 12, 16, 176, 5, 208, 176, 5, 47, 177, 4, 12, 244, 176, 7, 208, 176, 1, 16, 176, 9, 208, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 179, 9, 6, 2, 4, 43, 48, 49, 33, 35, 17, 33, 17, 35, 17, 51, 17, 33, 17, 51, 3, 115, 138, 253, 209, 137, 137, 2, 47, 138, 2, 92, 253, 164, 5, 25, 253, 184, 2, 72, 0, 2, 255, 223, 255, 233, 3, 199, 5, 47, 0, 19, 0, 39, 0, 226, 176, 40, 47, 176, 41, 47, 176, 0, 220, 176, 40, 16, 176, 10, 208, 176, 10, 47, 176, 0, 16, 177, 20, 8, 244, 180, 218, 20, 234, 20, 2, 93, 64, 27, 9, 20, 25, 20, 41, 20, 57, 20, 73, 20, 89, 20, 105, 20, 121, 20, 137, 20, 153, 20, 169, 20, 185, 20, 201, 20, 13, 93, 176, 10, 16, 177, 30, 12, 244, 64, 23, 6, 30, 22, 30, 38, 30, 54, 30, 70, 30, 86, 30, 102, 30, 118, 30, 134, 30, 150, 30, 166, 30, 11, 93, 180, 182, 30, 198, 30, 2, 93, 180, 213, 30, 229, 30, 2, 93, 0, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 21, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 176, 15, 16, 177, 25, 6, 244, 180, 217, 25, 233, 25, 2, 93, 64, 27, 8, 25, 24, 25, 40, 25, 56, 25, 72, 25, 88, 25, 104, 25, 120, 25, 136, 25, 152, 25, 168, 25, 184, 25, 200, 25, 13, 93, 176, 5, 16, 177, 35, 6, 244, 64, 27, 7, 35, 23, 35, 39, 35, 55, 35, 71, 35, 87, 35, 103, 35, 119, 35, 135, 35, 151, 35, 167, 35, 183, 35, 199, 35, 13, 93, 180, 214, 35, 230, 35, 2, 93, 48, 49, 1, 20, 14, 2, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 30, 2, 7, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 62, 2, 3, 199, 54, 118, 191, 137, 137, 191, 119, 53, 53, 121, 191, 135, 135, 191, 118, 56, 138, 49, 92, 135, 86, 107, 139, 84, 33, 33, 84, 139, 107, 106, 140, 84, 32, 2, 139, 131, 244, 186, 113, 113, 186, 244, 131, 131, 244, 188, 113, 113, 188, 244, 131, 129, 207, 146, 77, 100, 162, 198, 99, 98, 199, 159, 101, 101, 159, 199, 0, 1, 0, 49, 0, 0, 3, 115, 5, 25, 0, 7, 0, 75, 176, 8, 47, 176, 9, 47, 176, 0, 220, 177, 1, 8, 244, 176, 8, 16, 176, 5, 208, 176, 5, 47, 177, 4, 12, 244, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 176, 6, 16, 177, 2, 6, 244, 48, 49, 33, 35, 17, 33, 17, 35, 17, 33, 3, 115, 138, 253, 209, 137, 3, 66, 4, 164, 251, 92, 5, 25, 0, 0, 2, 0, 49, 0, 0, 3, 162, 5, 25, 0, 10, 0, 19, 0, 114, 176, 20, 47, 176, 21, 47, 176, 0, 220, 176, 20, 16, 176, 6, 208, 176, 6, 47, 177, 5, 12, 244, 176, 0, 16, 177, 11, 12, 244, 180, 218, 11, 234, 11, 2, 93, 64, 27, 9, 11, 25, 11, 41, 11, 57, 11, 73, 11, 89, 11, 105, 11, 121, 11, 137, 11, 153, 11, 169, 11, 185, 11, 201, 11, 13, 93, 176, 5, 16, 176, 15, 208, 0, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 21, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 179, 17, 6, 3, 4, 43, 176, 7, 16, 177, 14, 6, 244, 48, 49, 1, 20, 6, 35, 33, 17, 35, 17, 33, 50, 22, 7, 52, 38, 35, 33, 17, 33, 50, 54, 3, 162, 236, 213, 254, 217, 137, 1, 174, 215, 236, 137, 170, 142, 254, 217, 1, 39, 142, 170, 3, 164, 189, 184, 253, 209, 5, 25, 187, 186, 135, 121, 254, 0, 121, 0, 0, 1, 255, 236, 255, 236, 3, 172, 5, 47, 0, 37, 0, 227, 176, 38, 47, 176, 39, 47, 176, 18, 220, 176, 0, 208, 176, 0, 47, 176, 38, 16, 176, 8, 208, 176, 8, 47, 176, 18, 16, 177, 17, 13, 244, 176, 20, 208, 176, 8, 16, 177, 30, 12, 244, 64, 27, 6, 30, 22, 30, 38, 30, 54, 30, 70, 30, 86, 30, 102, 30, 118, 30, 134, 30, 150, 30, 166, 30, 182, 30, 198, 30, 13, 93, 180, 213, 30, 229, 30, 2, 93, 176, 17, 16, 176, 37, 208, 176, 37, 47, 0, 176, 0, 69, 88, 176, 17, 47, 27, 177, 17, 21, 62, 89, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 21, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 178, 16, 3, 13, 17, 18, 57, 176, 13, 16, 177, 25, 6, 244, 180, 217, 25, 233, 25, 2, 93, 182, 8, 25, 24, 25, 40, 25, 3, 93, 64, 21, 56, 25, 72, 25, 88, 25, 104, 25, 120, 25, 136, 25, 152, 25, 168, 25, 184, 25, 200, 25, 10, 93, 176, 3, 16, 177, 35, 6, 244, 64, 27, 7, 35, 23, 35, 39, 35, 55, 35, 71, 35, 87, 35, 103, 35, 119, 35, 135, 35, 151, 35, 167, 35, 183, 35, 199, 35, 13, 93, 180, 214, 35, 230, 35, 2, 93, 48, 49, 1, 6, 6, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 22, 23, 53, 51, 17, 35, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 19, 3, 172, 51, 232, 176, 137, 190, 121, 53, 53, 121, 190, 137, 121, 172, 41, 117, 117, 53, 90, 123, 68, 106, 139, 84, 35, 35, 84, 139, 106, 244, 96, 1, 86, 168, 194, 110, 186, 244, 131, 131, 244, 188, 113, 86, 88, 152, 254, 84, 69, 123, 90, 51, 100, 162, 198, 99, 98, 199, 157, 101, 1, 37, 0, 0, 1, 0, 0, 0, 0, 3, 164, 5, 25, 0, 15, 0, 107, 176, 16, 47, 176, 13, 208, 176, 13, 47, 176, 9, 220, 178, 64, 9, 1, 93, 176, 1, 220, 178, 64, 1, 1, 93, 177, 0, 13, 244, 176, 9, 16, 177, 4, 8, 244, 176, 13, 16, 177, 12, 13, 244, 176, 0, 16, 176, 17, 220, 0, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 21, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 176, 14, 16, 177, 2, 6, 244, 176, 6, 16, 177, 4, 6, 244, 176, 8, 208, 176, 9, 208, 176, 2, 16, 176, 10, 208, 176, 11, 208, 48, 49, 1, 35, 17, 33, 17, 51, 21, 33, 53, 51, 17, 33, 17, 35, 17, 33, 3, 164, 117, 254, 232, 210, 253, 209, 211, 254, 232, 117, 3, 164, 3, 96, 1, 68, 251, 209, 117, 117, 4, 47, 254, 188, 1, 185, 0, 0, 1, 255, 225, 255, 233, 3, 193, 5, 25, 0, 18, 0, 90, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 21, 62, 89, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 21, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 177, 10, 6, 244, 64, 27, 7, 10, 23, 10, 39, 10, 55, 10, 71, 10, 87, 10, 103, 10, 119, 10, 135, 10, 151, 10, 167, 10, 183, 10, 199, 10, 13, 93, 180, 214, 10, 230, 10, 2, 93, 178, 17, 4, 0, 17, 18, 57, 48, 49, 1, 1, 6, 6, 35, 34, 39, 55, 22, 22, 51, 50, 54, 55, 55, 1, 51, 1, 1, 3, 193, 254, 8, 39, 142, 86, 96, 96, 27, 47, 90, 28, 68, 51, 19, 57, 254, 96, 162, 1, 80, 1, 74, 5, 25, 251, 112, 98, 62, 35, 119, 20, 17, 66, 45, 141, 3, 191, 252, 208, 3, 48, 0, 3, 255, 236, 0, 0, 3, 188, 5, 25, 0, 25, 0, 34, 0, 43, 0, 145, 179, 35, 12, 13, 4, 43, 179, 6, 8, 7, 4, 43, 179, 0, 12, 26, 4, 43, 176, 7, 16, 176, 18, 208, 176, 6, 16, 176, 20, 208, 180, 218, 26, 234, 26, 2, 93, 64, 27, 9, 26, 25, 26, 41, 26, 57, 26, 73, 26, 89, 26, 105, 26, 121, 26, 137, 26, 153, 26, 169, 26, 185, 26, 201, 26, 13, 93, 176, 6, 16, 176, 31, 208, 64, 27, 6, 35, 22, 35, 38, 35, 54, 35, 70, 35, 86, 35, 102, 35, 118, 35, 134, 35, 150, 35, 166, 35, 182, 35, 198, 35, 13, 93, 180, 213, 35, 229, 35, 2, 93, 176, 7, 16, 176, 38, 208, 0, 176, 0, 69, 88, 176, 19, 47, 27, 177, 19, 21, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 48, 49, 1, 20, 14, 2, 7, 21, 35, 53, 46, 3, 53, 52, 62, 2, 55, 53, 51, 21, 30, 3, 7, 52, 46, 2, 39, 17, 54, 54, 37, 20, 22, 23, 17, 14, 3, 3, 188, 61, 111, 155, 94, 138, 94, 153, 111, 59, 59, 111, 153, 94, 138, 94, 155, 111, 61, 137, 39, 71, 107, 67, 135, 149, 253, 66, 145, 135, 67, 105, 71, 37, 2, 143, 98, 168, 127, 80, 10, 172, 174, 10, 80, 125, 168, 98, 99, 168, 129, 79, 13, 162, 162, 10, 82, 127, 170, 99, 70, 125, 98, 64, 12, 253, 37, 22, 199, 141, 141, 199, 22, 2, 219, 12, 66, 96, 125, 0, 1, 255, 233, 0, 0, 3, 186, 5, 25, 0, 27, 0, 122, 0, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 21, 62, 89, 176, 0, 69, 88, 176, 21, 47, 27, 177, 21, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 15, 62, 89, 177, 2, 6, 244, 176, 3, 208, 178, 4, 0, 14, 17, 18, 57, 176, 5, 208, 176, 6, 208, 176, 9, 208, 176, 10, 208, 176, 14, 16, 177, 12, 6, 244, 176, 16, 208, 176, 17, 208, 178, 18, 0, 14, 17, 18, 57, 176, 19, 208, 176, 20, 208, 176, 23, 208, 176, 24, 208, 176, 10, 16, 176, 26, 208, 176, 27, 208, 48, 49, 33, 33, 53, 51, 3, 3, 51, 21, 33, 53, 51, 1, 1, 35, 53, 33, 21, 35, 19, 19, 35, 53, 33, 21, 35, 1, 1, 51, 3, 186, 254, 142, 88, 205, 207, 88, 254, 141, 127, 1, 27, 254, 234, 109, 1, 117, 109, 203, 197, 105, 1, 117, 113, 254, 240, 1, 24, 127, 117, 1, 172, 254, 84, 117, 117, 2, 28, 2, 19, 117, 117, 254, 94, 1, 162, 117, 117, 253, 237, 253, 228, 0, 0, 1, 0, 49, 254, 193, 4, 31, 5, 25, 0, 11, 0, 79, 179, 7, 12, 4, 4, 43, 179, 11, 8, 8, 4, 43, 179, 1, 11, 2, 4, 43, 176, 1, 16, 176, 13, 220, 0, 176, 1, 47, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 21, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 21, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 177, 0, 6, 244, 176, 7, 208, 176, 8, 208, 48, 49, 37, 17, 35, 17, 33, 17, 51, 17, 33, 17, 51, 17, 4, 31, 123, 252, 141, 137, 2, 47, 138, 117, 254, 76, 1, 63, 5, 25, 251, 92, 4, 164, 251, 92, 0, 0, 1, 0, 49, 0, 0, 3, 115, 5, 25, 0, 19, 0, 94, 176, 20, 47, 176, 21, 47, 176, 20, 16, 176, 0, 208, 176, 0, 47, 177, 1, 12, 244, 176, 21, 16, 176, 12, 220, 177, 11, 8, 244, 176, 14, 208, 178, 15, 0, 12, 17, 18, 57, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 21, 62, 89, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 21, 62, 89, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 15, 62, 89, 179, 5, 6, 17, 4, 43, 178, 15, 13, 0, 17, 18, 57, 48, 49, 19, 51, 17, 20, 22, 51, 50, 62, 2, 53, 17, 51, 17, 35, 17, 2, 35, 32, 17, 49, 137, 109, 121, 76, 122, 86, 45, 138, 138, 98, 254, 254, 168, 5, 25, 253, 192, 125, 137, 70, 116, 152, 82, 1, 162, 250, 231, 2, 94, 255, 0, 1, 123, 0, 0, 1, 0, 0, 0, 0, 3, 164, 5, 25, 0, 11, 0, 124, 176, 12, 47, 176, 7, 208, 176, 7, 47, 176, 0, 220, 178, 239, 0, 1, 93, 178, 64, 0, 1, 93, 177, 1, 8, 244, 176, 0, 16, 176, 3, 220, 178, 239, 3, 1, 93, 178, 64, 3, 1, 93, 177, 6, 12, 244, 176, 7, 16, 177, 10, 12, 244, 176, 6, 16, 176, 13, 220, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 21, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 21, 62, 89, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 21, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 177, 2, 6, 244, 176, 10, 208, 176, 11, 208, 48, 49, 1, 51, 17, 33, 17, 51, 17, 33, 17, 51, 17, 33, 1, 141, 138, 1, 4, 137, 252, 92, 137, 1, 4, 5, 25, 251, 92, 4, 164, 250, 231, 5, 25, 251, 92, 0, 0, 1, 0, 0, 254, 193, 4, 31, 5, 25, 0, 15, 0, 111, 179, 3, 12, 0, 4, 43, 179, 7, 8, 4, 4, 43, 179, 11, 12, 8, 4, 43, 176, 11, 16, 177, 12, 11, 244, 176, 11, 16, 176, 14, 208, 176, 11, 16, 176, 17, 220, 0, 176, 13, 47, 176, 0, 69, 88, 176, 1, 47, 27, 177, 1, 21, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 21, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 177, 3, 6, 244, 176, 7, 208, 176, 8, 208, 176, 11, 208, 176, 12, 208, 48, 49, 49, 17, 51, 17, 33, 17, 51, 17, 33, 17, 51, 17, 51, 17, 35, 17, 137, 1, 4, 138, 1, 4, 137, 123, 123, 5, 25, 251, 92, 4, 164, 251, 92, 4, 164, 251, 92, 254, 76, 1, 63, 0, 2, 0, 0, 0, 0, 3, 162, 5, 25, 0, 12, 0, 21, 0, 118, 176, 22, 47, 176, 23, 47, 176, 22, 16, 176, 10, 208, 176, 10, 47, 177, 18, 12, 244, 176, 1, 208, 176, 23, 16, 176, 6, 220, 177, 13, 12, 244, 180, 218, 13, 234, 13, 2, 93, 64, 27, 9, 13, 25, 13, 41, 13, 57, 13, 73, 13, 89, 13, 105, 13, 121, 13, 137, 13, 153, 13, 169, 13, 185, 13, 201, 13, 13, 93, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 21, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 15, 62, 89, 179, 3, 6, 16, 4, 43, 176, 0, 16, 177, 11, 6, 244, 176, 9, 16, 177, 18, 6, 244, 48, 49, 17, 33, 17, 51, 50, 22, 21, 20, 6, 35, 33, 17, 35, 1, 52, 38, 35, 35, 17, 51, 50, 54, 1, 117, 178, 180, 199, 199, 182, 254, 199, 236, 3, 25, 129, 111, 180, 180, 111, 129, 5, 25, 253, 208, 188, 188, 187, 182, 4, 164, 252, 205, 127, 133, 254, 0, 127, 0, 0, 3, 0, 0, 0, 0, 3, 164, 5, 25, 0, 10, 0, 19, 0, 23, 0, 135, 179, 1, 12, 0, 4, 43, 179, 6, 12, 11, 4, 43, 179, 21, 12, 20, 4, 43, 180, 218, 11, 234, 11, 2, 93, 64, 27, 9, 11, 25, 11, 41, 11, 57, 11, 73, 11, 89, 11, 105, 11, 121, 11, 137, 11, 153, 11, 169, 11, 185, 11, 201, 11, 13, 93, 176, 1, 16, 176, 15, 208, 176, 21, 16, 176, 25, 220, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 21, 62, 89, 176, 0, 69, 88, 176, 20, 47, 27, 177, 20, 21, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 15, 62, 89, 176, 0, 69, 88, 176, 22, 47, 27, 177, 22, 15, 62, 89, 179, 3, 6, 14, 4, 43, 176, 9, 16, 177, 16, 6, 244, 48, 49, 17, 51, 17, 51, 50, 22, 21, 20, 6, 35, 33, 1, 52, 38, 35, 35, 17, 51, 50, 54, 1, 51, 17, 35, 137, 135, 162, 178, 178, 164, 254, 242, 1, 219, 108, 93, 137, 137, 93, 108, 1, 64, 137, 137, 5, 25, 253, 208, 188, 188, 187, 182, 1, 113, 127, 133, 254, 0, 127, 4, 37, 250, 231, 0, 2, 0, 49, 0, 0, 3, 162, 5, 25, 0, 8, 0, 19, 0, 108, 176, 20, 47, 176, 21, 47, 176, 13, 220, 177, 0, 12, 244, 180, 218, 0, 234, 0, 2, 93, 64, 27, 9, 0, 25, 0, 41, 0, 57, 0, 73, 0, 89, 0, 105, 0, 121, 0, 137, 0, 153, 0, 169, 0, 185, 0, 201, 0, 13, 93, 176, 20, 16, 176, 17, 208, 176, 17, 47, 177, 5, 12, 244, 176, 9, 208, 0, 176, 0, 69, 88, 176, 18, 47, 27, 177, 18, 21, 62, 89, 176, 0, 69, 88, 176, 16, 47, 27, 177, 16, 15, 62, 89, 179, 10, 6, 3, 4, 43, 176, 16, 16, 177, 5, 6, 244, 48, 49, 1, 52, 38, 35, 33, 17, 33, 50, 54, 1, 33, 50, 22, 21, 20, 6, 35, 33, 17, 51, 3, 25, 170, 142, 254, 217, 1, 39, 142, 170, 253, 161, 1, 39, 213, 236, 236, 215, 254, 82, 137, 1, 113, 127, 133, 254, 0, 127, 1, 245, 188, 188, 187, 182, 5, 25, 0, 1, 255, 248, 255, 233, 3, 184, 5, 47, 0, 46, 0, 190, 176, 47, 47, 176, 48, 47, 176, 47, 16, 176, 24, 208, 176, 24, 47, 177, 23, 13, 244, 176, 0, 208, 176, 0, 47, 176, 48, 16, 176, 35, 220, 177, 10, 8, 244, 176, 13, 208, 176, 23, 16, 176, 26, 208, 176, 24, 16, 176, 46, 208, 176, 46, 47, 178, 27, 46, 35, 17, 18, 57, 0, 176, 0, 69, 88, 176, 30, 47, 27, 177, 30, 21, 62, 89, 176, 0, 69, 88, 176, 42, 47, 27, 177, 42, 15, 62, 89, 179, 13, 6, 10, 4, 43, 176, 42, 16, 177, 2, 6, 244, 64, 27, 7, 2, 23, 2, 39, 2, 55, 2, 71, 2, 87, 2, 103, 2, 119, 2, 135, 2, 151, 2, 167, 2, 183, 2, 199, 2, 13, 93, 180, 214, 2, 230, 2, 2, 93, 176, 30, 16, 177, 18, 6, 244, 180, 217, 18, 233, 18, 2, 93, 64, 27, 8, 18, 24, 18, 40, 18, 56, 18, 72, 18, 88, 18, 104, 18, 120, 18, 136, 18, 152, 18, 168, 18, 184, 18, 200, 18, 13, 93, 178, 27, 42, 30, 17, 18, 57, 48, 49, 19, 18, 51, 50, 62, 2, 55, 54, 54, 55, 33, 53, 33, 46, 3, 35, 34, 14, 2, 21, 35, 17, 51, 21, 54, 54, 51, 50, 30, 2, 21, 20, 14, 4, 35, 34, 39, 38, 39, 111, 96, 244, 53, 87, 71, 55, 21, 38, 35, 3, 253, 186, 2, 70, 5, 43, 85, 134, 96, 69, 122, 90, 53, 117, 117, 42, 171, 121, 137, 191, 119, 54, 23, 51, 79, 112, 145, 91, 176, 116, 116, 51, 1, 133, 254, 217, 27, 48, 66, 39, 71, 171, 88, 117, 91, 176, 138, 84, 51, 90, 122, 70, 1, 172, 152, 88, 86, 113, 188, 244, 131, 88, 167, 150, 126, 91, 52, 98, 100, 167, 0, 2, 0, 49, 255, 233, 3, 168, 5, 47, 0, 14, 0, 34, 0, 222, 179, 1, 12, 0, 4, 43, 179, 30, 8, 11, 4, 43, 179, 7, 12, 20, 4, 43, 176, 11, 16, 176, 3, 208, 176, 1, 16, 176, 12, 208, 180, 218, 20, 234, 20, 2, 93, 64, 27, 9, 20, 25, 20, 41, 20, 57, 20, 73, 20, 89, 20, 105, 20, 121, 20, 137, 20, 153, 20, 169, 20, 185, 20, 201, 20, 13, 93, 176, 7, 16, 176, 36, 220, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 21, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 21, 62, 89, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 15, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 15, 62, 89, 179, 3, 6, 11, 4, 43, 176, 9, 16, 177, 15, 6, 244, 64, 27, 7, 15, 23, 15, 39, 15, 55, 15, 71, 15, 87, 15, 103, 15, 119, 15, 135, 15, 151, 15, 167, 15, 183, 15, 199, 15, 13, 93, 180, 214, 15, 230, 15, 2, 93, 176, 5, 16, 177, 25, 6, 244, 180, 217, 25, 233, 25, 2, 93, 64, 27, 8, 25, 24, 25, 40, 25, 56, 25, 72, 25, 88, 25, 104, 25, 120, 25, 136, 25, 152, 25, 168, 25, 184, 25, 200, 25, 13, 93, 48, 49, 19, 51, 17, 51, 18, 33, 32, 17, 16, 33, 32, 3, 35, 17, 35, 37, 50, 62, 2, 53, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 49, 137, 172, 13, 1, 20, 1, 33, 254, 223, 254, 236, 13, 172, 137, 2, 86, 47, 60, 32, 13, 13, 32, 60, 47, 47, 59, 33, 12, 12, 33, 59, 5, 25, 253, 174, 2, 104, 253, 92, 253, 94, 2, 105, 253, 174, 94, 82, 148, 204, 123, 123, 207, 147, 82, 82, 147, 207, 123, 123, 204, 148, 82, 0, 2, 255, 244, 0, 0, 3, 115, 5, 25, 0, 15, 0, 24, 0, 148, 176, 25, 47, 176, 26, 47, 176, 25, 16, 176, 5, 208, 176, 5, 47, 176, 26, 16, 176, 10, 220, 177, 11, 8, 244, 176, 5, 16, 176, 15, 208, 176, 15, 47, 176, 5, 16, 177, 16, 8, 244, 64, 27, 6, 16, 22, 16, 38, 16, 54, 16, 70, 16, 86, 16, 102, 16, 118, 16, 134, 16, 150, 16, 166, 16, 182, 16, 198, 16, 13, 93, 180, 213, 16, 229, 16, 2, 93, 176, 11, 16, 176, 20, 208, 0, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 21, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 15, 62, 89, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 15, 62, 89, 179, 19, 1, 0, 4, 43, 176, 0, 16, 176, 12, 208, 176, 12, 47, 176, 8, 16, 177, 21, 6, 244, 48, 49, 1, 46, 3, 53, 52, 54, 51, 33, 17, 35, 17, 35, 1, 35, 19, 20, 22, 51, 33, 17, 33, 34, 6, 1, 125, 82, 139, 101, 57, 236, 215, 1, 174, 138, 202, 254, 131, 174, 155, 166, 144, 1, 36, 254, 220, 144, 166, 2, 53, 6, 56, 92, 131, 82, 186, 187, 250, 231, 2, 47, 253, 209, 3, 164, 135, 121, 2, 0, 123, 0, 0, 2, 255, 254, 255, 233, 3, 115, 3, 186, 0, 38, 0, 55, 0, 237, 176, 56, 47, 176, 57, 47, 176, 56, 16, 176, 0, 208, 176, 0, 47, 176, 57, 16, 176, 28, 220, 177, 11, 8, 244, 176, 30, 208, 178, 31, 0, 28, 17, 18, 57, 176, 11, 16, 176, 44, 208, 176, 0, 16, 177, 53, 12, 244, 64, 27, 6, 53, 22, 53, 38, 53, 54, 53, 70, 53, 86, 53, 102, 53, 118, 53, 134, 53, 150, 53, 166, 53, 182, 53, 198, 53, 13, 93, 180, 213, 53, 229, 53, 2, 93, 0, 176, 0, 69, 88, 176, 23, 47, 27, 177, 23, 19, 62, 89, 176, 0, 69, 88, 176, 29, 47, 27, 177, 29, 15, 62, 89, 176, 0, 69, 88, 176, 36, 47, 27, 177, 36, 15, 62, 89, 179, 5, 6, 48, 4, 43, 176, 23, 16, 177, 16, 6, 244, 180, 217, 16, 233, 16, 2, 93, 64, 27, 8, 16, 24, 16, 40, 16, 56, 16, 72, 16, 88, 16, 104, 16, 120, 16, 136, 16, 152, 16, 168, 16, 184, 16, 200, 16, 13, 93, 178, 31, 36, 23, 17, 18, 57, 176, 36, 16, 177, 39, 6, 244, 64, 27, 7, 39, 23, 39, 39, 39, 55, 39, 71, 39, 87, 39, 103, 39, 119, 39, 135, 39, 151, 39, 167, 39, 183, 39, 199, 39, 13, 93, 180, 214, 39, 230, 39, 2, 93, 176, 48, 16, 176, 45, 208, 176, 45, 47, 48, 49, 39, 52, 62, 2, 51, 50, 30, 2, 23, 53, 52, 46, 2, 35, 34, 6, 7, 39, 54, 54, 51, 50, 30, 2, 21, 17, 35, 53, 14, 3, 35, 34, 38, 5, 50, 62, 2, 53, 53, 38, 38, 35, 34, 14, 2, 21, 20, 22, 2, 88, 143, 185, 96, 37, 59, 53, 54, 32, 59, 86, 94, 33, 104, 176, 76, 62, 84, 209, 125, 76, 147, 117, 70, 138, 36, 91, 100, 100, 45, 185, 190, 1, 119, 86, 137, 96, 53, 67, 123, 45, 74, 137, 102, 62, 115, 252, 88, 119, 69, 31, 2, 4, 6, 4, 67, 68, 88, 51, 21, 56, 47, 103, 51, 65, 39, 81, 132, 92, 253, 158, 156, 45, 68, 43, 23, 142, 25, 51, 76, 86, 35, 88, 10, 2, 20, 45, 72, 53, 59, 99, 0, 0, 2, 0, 0, 255, 233, 3, 164, 5, 47, 0, 13, 0, 58, 1, 10, 176, 59, 47, 176, 60, 47, 176, 59, 16, 176, 14, 208, 176, 14, 47, 177, 41, 8, 244, 64, 27, 6, 41, 22, 41, 38, 41, 54, 41, 70, 41, 86, 41, 102, 41, 118, 41, 134, 41, 150, 41, 166, 41, 182, 41, 198, 41, 13, 93, 180, 213, 41, 229, 41, 2, 93, 176, 0, 208, 176, 0, 47, 176, 60, 16, 176, 51, 220, 177, 8, 12, 244, 180, 218, 8, 234, 8, 2, 93, 64, 27, 9, 8, 25, 8, 41, 8, 57, 8, 73, 8, 89, 8, 105, 8, 121, 8, 137, 8, 153, 8, 169, 8, 185, 8, 201, 8, 13, 93, 176, 27, 208, 176, 27, 47, 0, 176, 0, 69, 88, 176, 19, 47, 27, 177, 19, 21, 62, 89, 176, 0, 69, 88, 176, 27, 47, 27, 177, 27, 21, 62, 89, 176, 0, 69, 88, 176, 56, 47, 27, 177, 56, 15, 62, 89, 179, 46, 6, 11, 4, 43, 176, 56, 16, 177, 3, 6, 244, 64, 27, 7, 3, 23, 3, 39, 3, 55, 3, 71, 3, 87, 3, 103, 3, 119, 3, 135, 3, 151, 3, 167, 3, 183, 3, 199, 3, 13, 93, 180, 214, 3, 230, 3, 2, 93, 176, 19, 16, 177, 36, 6, 244, 180, 217, 36, 233, 36, 2, 93, 64, 27, 8, 36, 24, 36, 40, 36, 56, 36, 72, 36, 88, 36, 104, 36, 120, 36, 136, 36, 152, 36, 168, 36, 184, 36, 200, 36, 13, 93, 177, 24, 2, 244, 177, 31, 6, 244, 178, 41, 56, 19, 17, 18, 57, 48, 49, 19, 20, 22, 51, 50, 62, 2, 53, 52, 38, 35, 34, 6, 39, 52, 62, 2, 51, 50, 30, 2, 51, 50, 54, 55, 23, 6, 6, 35, 34, 46, 2, 35, 34, 14, 2, 21, 62, 3, 51, 50, 30, 2, 21, 20, 14, 2, 35, 34, 2, 150, 172, 151, 70, 119, 86, 47, 168, 154, 166, 157, 150, 63, 115, 158, 96, 45, 62, 49, 45, 31, 41, 57, 41, 71, 43, 116, 51, 39, 58, 49, 51, 35, 61, 107, 80, 45, 25, 72, 88, 100, 49, 98, 168, 123, 70, 70, 123, 168, 98, 235, 238, 1, 188, 159, 191, 49, 93, 129, 79, 160, 191, 191, 47, 150, 248, 178, 100, 18, 25, 18, 28, 33, 82, 41, 55, 18, 25, 18, 67, 127, 180, 113, 45, 70, 49, 24, 59, 117, 174, 117, 98, 172, 125, 72, 1, 72, 0, 0, 3, 0, 49, 0, 0, 3, 162, 3, 164, 0, 16, 0, 29, 0, 38, 0, 169, 179, 35, 12, 4, 4, 43, 179, 11, 12, 17, 4, 43, 180, 218, 17, 234, 17, 2, 93, 64, 27, 9, 17, 25, 17, 41, 17, 57, 17, 73, 17, 89, 17, 105, 17, 121, 17, 137, 17, 153, 17, 169, 17, 185, 17, 201, 17, 13, 93, 178, 30, 17, 11, 17, 18, 57, 176, 30, 47, 180, 218, 30, 234, 30, 2, 93, 64, 27, 9, 30, 25, 30, 41, 30, 57, 30, 73, 30, 89, 30, 105, 30, 121, 30, 137, 30, 153, 30, 169, 30, 185, 30, 201, 30, 13, 93, 177, 0, 12, 244, 178, 14, 4, 0, 17, 18, 57, 176, 35, 16, 176, 23, 208, 0, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 19, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 179, 25, 6, 33, 4, 43, 178, 14, 33, 25, 17, 18, 57, 176, 5, 16, 177, 22, 6, 244, 176, 3, 16, 177, 35, 6, 244, 48, 49, 1, 20, 6, 35, 33, 17, 33, 50, 30, 2, 21, 20, 6, 7, 22, 22, 3, 52, 46, 2, 35, 33, 17, 33, 50, 62, 2, 19, 52, 38, 35, 33, 17, 33, 50, 54, 3, 162, 199, 186, 254, 16, 1, 209, 68, 133, 104, 66, 70, 102, 125, 92, 182, 46, 67, 82, 39, 254, 184, 1, 72, 41, 84, 68, 41, 45, 134, 116, 254, 155, 1, 101, 116, 134, 1, 10, 135, 131, 3, 164, 21, 53, 94, 76, 72, 98, 26, 29, 113, 1, 74, 43, 53, 29, 10, 254, 244, 10, 31, 51, 254, 145, 82, 76, 254, 199, 78, 0, 1, 0, 49, 0, 0, 3, 164, 3, 164, 0, 5, 0, 42, 179, 3, 12, 0, 4, 43, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 19, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 176, 0, 16, 177, 2, 6, 244, 48, 49, 19, 33, 21, 33, 17, 35, 49, 3, 115, 253, 22, 137, 3, 164, 117, 252, 209, 0, 0, 2, 0, 0, 254, 193, 3, 164, 3, 164, 0, 15, 0, 24, 0, 82, 179, 13, 11, 0, 4, 43, 179, 16, 12, 5, 4, 43, 179, 8, 12, 22, 4, 43, 179, 10, 11, 11, 4, 43, 176, 10, 16, 176, 26, 220, 0, 176, 10, 47, 176, 14, 47, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 19, 62, 89, 176, 0, 69, 88, 176, 12, 47, 27, 177, 12, 15, 62, 89, 177, 8, 6, 244, 176, 21, 208, 176, 22, 208, 176, 6, 16, 177, 23, 6, 244, 48, 49, 53, 62, 3, 53, 53, 33, 17, 51, 17, 35, 17, 33, 17, 35, 1, 20, 14, 2, 7, 33, 17, 35, 47, 86, 64, 39, 1, 253, 187, 123, 253, 82, 123, 1, 117, 33, 53, 68, 33, 1, 166, 235, 117, 10, 88, 156, 223, 145, 193, 252, 209, 254, 76, 1, 63, 254, 193, 4, 34, 116, 203, 160, 115, 28, 2, 186, 0, 2, 255, 252, 255, 233, 3, 174, 3, 186, 0, 25, 0, 34, 0, 123, 0, 176, 0, 69, 88, 176, 20, 47, 27, 177, 20, 19, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 15, 62, 89, 179, 34, 6, 0, 4, 43, 176, 10, 16, 177, 3, 6, 244, 64, 27, 7, 3, 23, 3, 39, 3, 55, 3, 71, 3, 87, 3, 103, 3, 119, 3, 135, 3, 151, 3, 167, 3, 183, 3, 199, 3, 13, 93, 180, 214, 3, 230, 3, 2, 93, 176, 20, 16, 177, 29, 6, 244, 180, 217, 29, 233, 29, 2, 93, 64, 27, 8, 29, 24, 29, 40, 29, 56, 29, 72, 29, 88, 29, 104, 29, 120, 29, 136, 29, 152, 29, 168, 29, 184, 29, 200, 29, 13, 93, 48, 49, 19, 22, 22, 51, 50, 54, 55, 23, 6, 6, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 30, 2, 21, 39, 38, 38, 35, 34, 14, 2, 7, 137, 15, 186, 149, 105, 164, 41, 96, 70, 194, 142, 108, 180, 131, 72, 65, 123, 176, 109, 119, 178, 119, 57, 145, 23, 176, 129, 66, 112, 86, 58, 8, 1, 162, 148, 176, 86, 64, 66, 98, 103, 72, 129, 178, 109, 106, 179, 131, 73, 80, 141, 196, 119, 117, 153, 150, 43, 80, 113, 67, 0, 1, 255, 240, 0, 0, 3, 180, 3, 164, 0, 19, 0, 127, 179, 6, 8, 3, 4, 43, 176, 6, 16, 176, 13, 208, 176, 3, 16, 176, 15, 208, 0, 176, 0, 69, 88, 176, 1, 47, 27, 177, 1, 19, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 19, 62, 89, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 19, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 15, 62, 89, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 15, 62, 89, 176, 0, 69, 88, 176, 18, 47, 27, 177, 18, 15, 62, 89, 178, 3, 10, 1, 17, 18, 57, 178, 6, 10, 1, 17, 18, 57, 178, 12, 10, 1, 17, 18, 57, 178, 17, 10, 1, 17, 18, 57, 48, 49, 1, 1, 51, 1, 17, 51, 17, 1, 51, 1, 1, 35, 3, 7, 17, 35, 17, 39, 3, 35, 1, 14, 254, 226, 153, 1, 4, 138, 1, 4, 153, 254, 226, 1, 30, 147, 217, 49, 138, 49, 217, 147, 2, 12, 1, 152, 254, 119, 1, 137, 254, 119, 1, 137, 254, 104, 253, 244, 1, 162, 72, 254, 166, 1, 90, 72, 254, 94, 0, 0, 1, 255, 254, 255, 233, 3, 127, 3, 186, 0, 46, 0, 197, 179, 6, 8, 32, 4, 43, 176, 6, 16, 176, 0, 208, 176, 0, 47, 180, 218, 32, 234, 32, 2, 93, 64, 27, 9, 32, 25, 32, 41, 32, 57, 32, 73, 32, 89, 32, 105, 32, 121, 32, 137, 32, 153, 32, 169, 32, 185, 32, 201, 32, 13, 93, 176, 32, 16, 176, 21, 208, 176, 21, 47, 176, 6, 16, 176, 48, 220, 0, 176, 0, 69, 88, 176, 42, 47, 27, 177, 42, 19, 62, 89, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 15, 62, 89, 179, 29, 6, 26, 4, 43, 178, 3, 26, 29, 17, 18, 57, 176, 11, 16, 177, 18, 6, 244, 64, 27, 7, 18, 23, 18, 39, 18, 55, 18, 71, 18, 87, 18, 103, 18, 119, 18, 135, 18, 151, 18, 167, 18, 183, 18, 199, 18, 13, 93, 180, 214, 18, 230, 18, 2, 93, 176, 42, 16, 177, 35, 6, 244, 180, 217, 35, 233, 35, 2, 93, 64, 27, 8, 35, 24, 35, 40, 35, 56, 35, 72, 35, 88, 35, 104, 35, 120, 35, 136, 35, 152, 35, 168, 35, 184, 35, 200, 35, 13, 93, 48, 49, 1, 20, 6, 7, 22, 22, 21, 20, 14, 2, 35, 34, 38, 39, 55, 22, 22, 51, 50, 54, 53, 52, 46, 2, 35, 35, 53, 51, 50, 54, 53, 52, 38, 35, 34, 6, 7, 39, 54, 54, 51, 50, 30, 2, 3, 115, 95, 98, 92, 113, 72, 125, 170, 100, 160, 207, 63, 96, 47, 164, 123, 147, 183, 35, 68, 100, 68, 156, 156, 131, 127, 163, 142, 118, 154, 41, 102, 61, 201, 153, 97, 161, 119, 66, 2, 164, 68, 119, 16, 18, 119, 72, 67, 107, 74, 39, 99, 100, 66, 72, 76, 90, 80, 27, 55, 43, 27, 116, 93, 51, 74, 88, 84, 70, 70, 100, 100, 39, 71, 105, 0, 0, 1, 0, 49, 0, 0, 3, 115, 3, 164, 0, 9, 0, 98, 176, 10, 47, 176, 11, 47, 176, 10, 16, 176, 0, 208, 176, 0, 47, 177, 1, 12, 244, 176, 11, 16, 176, 5, 220, 177, 6, 8, 244, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 19, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 19, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 15, 62, 89, 178, 2, 5, 0, 17, 18, 57, 178, 7, 5, 0, 17, 18, 57, 48, 49, 19, 51, 17, 1, 51, 17, 35, 17, 1, 35, 49, 137, 1, 248, 193, 138, 253, 242, 170, 3, 164, 253, 16, 2, 240, 252, 92, 3, 18, 252, 238, 0, 255, 255, 0, 49, 0, 0, 3, 115, 5, 6, 2, 38, 1, 242, 0, 0, 0, 6, 0, 217, 0, 0, 0, 1, 0, 49, 0, 0, 3, 162, 3, 164, 0, 11, 0, 74, 179, 4, 12, 5, 4, 43, 176, 4, 16, 176, 7, 208, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 19, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 178, 8, 0, 6, 17, 18, 57, 48, 49, 33, 35, 1, 7, 17, 35, 17, 51, 17, 1, 51, 1, 3, 162, 195, 254, 131, 168, 137, 137, 2, 19, 196, 254, 45, 1, 162, 154, 254, 248, 3, 164, 254, 10, 1, 246, 254, 84, 0, 1, 255, 231, 255, 233, 3, 115, 3, 164, 0, 19, 0, 139, 176, 20, 47, 176, 21, 47, 176, 1, 220, 177, 2, 8, 244, 176, 20, 16, 176, 18, 208, 176, 18, 47, 177, 5, 8, 244, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 19, 62, 89, 176, 0, 69, 88, 176, 1, 47, 27, 177, 1, 15, 62, 89, 176, 0, 69, 88, 176, 12, 47, 27, 177, 12, 15, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 15, 62, 89, 176, 0, 16, 177, 3, 6, 244, 178, 13, 10, 0, 17, 18, 57, 176, 10, 16, 177, 16, 6, 244, 64, 27, 7, 16, 23, 16, 39, 16, 55, 16, 71, 16, 87, 16, 103, 16, 119, 16, 135, 16, 151, 16, 167, 16, 183, 16, 199, 16, 13, 93, 180, 214, 16, 230, 16, 2, 93, 48, 49, 1, 17, 35, 17, 33, 17, 20, 14, 2, 35, 34, 39, 55, 22, 22, 51, 50, 53, 17, 3, 115, 138, 254, 91, 37, 62, 82, 45, 84, 39, 27, 14, 35, 29, 106, 3, 164, 252, 92, 3, 47, 253, 160, 55, 86, 58, 31, 25, 109, 9, 8, 113, 2, 213, 0, 0, 1, 0, 49, 0, 0, 3, 115, 3, 164, 0, 12, 0, 109, 176, 13, 47, 176, 14, 47, 176, 0, 220, 177, 1, 8, 244, 176, 13, 16, 176, 7, 208, 176, 7, 47, 177, 6, 12, 244, 178, 10, 7, 0, 17, 18, 57, 0, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 19, 62, 89, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 178, 2, 0, 8, 17, 18, 57, 178, 5, 0, 8, 17, 18, 57, 178, 10, 0, 8, 17, 18, 57, 48, 49, 33, 35, 17, 3, 35, 3, 17, 35, 17, 51, 19, 19, 51, 3, 115, 138, 229, 98, 232, 137, 178, 240, 238, 178, 2, 227, 254, 29, 1, 227, 253, 29, 3, 164, 254, 26, 1, 230, 0, 0, 1, 0, 49, 0, 0, 3, 115, 3, 164, 0, 11, 0, 96, 176, 12, 47, 176, 13, 47, 176, 0, 220, 177, 1, 8, 244, 176, 12, 16, 176, 5, 208, 176, 5, 47, 177, 4, 12, 244, 176, 7, 208, 176, 1, 16, 176, 9, 208, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 19, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 179, 9, 6, 2, 4, 43, 48, 49, 33, 35, 17, 33, 17, 35, 17, 51, 17, 33, 17, 51, 3, 115, 138, 253, 209, 137, 137, 2, 47, 138, 1, 162, 254, 94, 3, 164, 254, 115, 1, 141, 0, 2, 255, 236, 255, 233, 3, 188, 3, 186, 0, 19, 0, 39, 0, 226, 176, 40, 47, 176, 41, 47, 176, 0, 220, 176, 40, 16, 176, 10, 208, 176, 10, 47, 176, 0, 16, 177, 20, 12, 244, 180, 218, 20, 234, 20, 2, 93, 64, 27, 9, 20, 25, 20, 41, 20, 57, 20, 73, 20, 89, 20, 105, 20, 121, 20, 137, 20, 153, 20, 169, 20, 185, 20, 201, 20, 13, 93, 176, 10, 16, 177, 30, 12, 244, 64, 23, 6, 30, 22, 30, 38, 30, 54, 30, 70, 30, 86, 30, 102, 30, 118, 30, 134, 30, 150, 30, 166, 30, 11, 93, 180, 182, 30, 198, 30, 2, 93, 180, 213, 30, 229, 30, 2, 93, 0, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 19, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 176, 15, 16, 177, 25, 6, 244, 180, 217, 25, 233, 25, 2, 93, 64, 27, 8, 25, 24, 25, 40, 25, 56, 25, 72, 25, 88, 25, 104, 25, 120, 25, 136, 25, 152, 25, 168, 25, 184, 25, 200, 25, 13, 93, 176, 5, 16, 177, 35, 6, 244, 64, 27, 7, 35, 23, 35, 39, 35, 55, 35, 71, 35, 87, 35, 103, 35, 119, 35, 135, 35, 151, 35, 167, 35, 183, 35, 199, 35, 13, 93, 180, 214, 35, 230, 35, 2, 93, 48, 49, 1, 20, 14, 2, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 30, 2, 7, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 62, 2, 3, 188, 69, 129, 180, 111, 109, 180, 129, 69, 69, 129, 180, 109, 111, 180, 129, 69, 137, 47, 92, 131, 82, 82, 131, 90, 47, 47, 90, 131, 82, 82, 131, 92, 47, 1, 207, 109, 178, 127, 72, 72, 127, 178, 109, 106, 183, 129, 73, 73, 129, 183, 106, 80, 135, 102, 58, 58, 102, 135, 80, 80, 135, 98, 56, 56, 98, 135, 0, 1, 0, 49, 0, 0, 3, 115, 3, 164, 0, 7, 0, 75, 176, 8, 47, 176, 9, 47, 176, 0, 220, 177, 1, 8, 244, 176, 8, 16, 176, 5, 208, 176, 5, 47, 177, 4, 12, 244, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 176, 6, 16, 177, 2, 6, 244, 48, 49, 33, 35, 17, 33, 17, 35, 17, 33, 3, 115, 138, 253, 209, 137, 3, 66, 3, 47, 252, 209, 3, 164, 0, 0, 2, 0, 49, 254, 139, 3, 164, 3, 186, 0, 19, 0, 36, 0, 236, 176, 37, 47, 176, 38, 47, 176, 0, 220, 176, 37, 16, 176, 10, 208, 176, 10, 47, 177, 9, 12, 244, 176, 12, 208, 178, 13, 10, 0, 17, 18, 57, 176, 0, 16, 177, 20, 12, 244, 180, 218, 20, 234, 20, 2, 93, 64, 27, 9, 20, 25, 20, 41, 20, 57, 20, 73, 20, 89, 20, 105, 20, 121, 20, 137, 20, 153, 20, 169, 20, 185, 20, 201, 20, 13, 93, 176, 9, 16, 176, 28, 208, 0, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 19, 62, 89, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 19, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 17, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 177, 32, 6, 244, 64, 27, 7, 32, 23, 32, 39, 32, 55, 32, 71, 32, 87, 32, 103, 32, 119, 32, 135, 32, 151, 32, 167, 32, 183, 32, 199, 32, 13, 93, 180, 214, 32, 230, 32, 2, 93, 178, 8, 5, 32, 17, 18, 57, 176, 15, 16, 177, 25, 6, 244, 180, 217, 25, 233, 25, 2, 93, 64, 27, 8, 25, 24, 25, 40, 25, 56, 25, 72, 25, 88, 25, 104, 25, 120, 25, 136, 25, 152, 25, 168, 25, 184, 25, 200, 25, 13, 93, 178, 13, 15, 25, 17, 18, 57, 48, 49, 1, 20, 14, 2, 35, 34, 38, 39, 17, 35, 17, 51, 21, 54, 51, 50, 30, 2, 7, 52, 46, 2, 35, 34, 6, 7, 17, 22, 22, 51, 50, 62, 2, 3, 164, 68, 123, 174, 108, 74, 139, 60, 137, 137, 127, 146, 108, 174, 123, 68, 137, 43, 86, 125, 82, 78, 135, 60, 60, 135, 78, 82, 125, 86, 43, 1, 209, 109, 178, 129, 72, 54, 53, 254, 55, 5, 25, 86, 108, 71, 131, 181, 106, 78, 137, 100, 58, 58, 65, 254, 12, 65, 56, 58, 100, 135, 0, 1, 0, 0, 255, 233, 3, 129, 3, 186, 0, 40, 0, 215, 176, 41, 47, 176, 42, 47, 176, 20, 220, 176, 0, 208, 176, 0, 47, 176, 41, 16, 176, 8, 208, 176, 8, 47, 176, 20, 16, 177, 19, 11, 244, 176, 22, 208, 176, 8, 16, 177, 32, 12, 244, 64, 27, 6, 32, 22, 32, 38, 32, 54, 32, 70, 32, 86, 32, 102, 32, 118, 32, 134, 32, 150, 32, 166, 32, 182, 32, 198, 32, 13, 93, 180, 213, 32, 229, 32, 2, 93, 0, 176, 0, 69, 88, 176, 19, 47, 27, 177, 19, 19, 62, 89, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 19, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 178, 18, 3, 13, 17, 18, 57, 176, 13, 16, 177, 27, 6, 244, 180, 217, 27, 233, 27, 2, 93, 64, 27, 8, 27, 24, 27, 40, 27, 56, 27, 72, 27, 88, 27, 104, 27, 120, 27, 136, 27, 152, 27, 168, 27, 184, 27, 200, 27, 13, 93, 176, 3, 16, 177, 37, 6, 244, 64, 27, 7, 37, 23, 37, 39, 37, 55, 37, 71, 37, 87, 37, 103, 37, 119, 37, 135, 37, 151, 37, 167, 37, 183, 37, 199, 37, 13, 93, 180, 214, 37, 230, 37, 2, 93, 48, 49, 37, 6, 6, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 30, 2, 23, 53, 51, 17, 35, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 51, 50, 54, 55, 3, 129, 59, 205, 141, 109, 182, 129, 72, 66, 122, 177, 108, 43, 90, 80, 64, 16, 123, 123, 45, 78, 108, 62, 84, 125, 84, 43, 49, 93, 131, 82, 104, 162, 43, 176, 92, 107, 72, 129, 178, 109, 106, 181, 129, 73, 20, 41, 57, 39, 135, 254, 139, 62, 102, 74, 41, 58, 100, 135, 80, 80, 135, 98, 58, 80, 68, 0, 0, 1, 0, 0, 0, 0, 3, 164, 3, 164, 0, 15, 0, 107, 176, 16, 47, 176, 13, 208, 176, 13, 47, 176, 9, 220, 178, 64, 9, 1, 93, 176, 1, 220, 178, 64, 1, 1, 93, 177, 0, 13, 244, 176, 9, 16, 177, 4, 8, 244, 176, 13, 16, 177, 12, 13, 244, 176, 0, 16, 176, 17, 220, 0, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 19, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 176, 14, 16, 177, 2, 6, 244, 176, 6, 16, 177, 4, 6, 244, 176, 8, 208, 176, 9, 208, 176, 2, 16, 176, 10, 208, 176, 11, 208, 48, 49, 1, 35, 17, 33, 17, 51, 21, 33, 53, 51, 17, 33, 17, 35, 17, 33, 3, 164, 117, 254, 232, 210, 253, 209, 211, 254, 232, 117, 3, 164, 1, 236, 1, 67, 253, 70, 117, 117, 2, 186, 254, 189, 1, 184, 0, 0, 1, 255, 225, 254, 117, 3, 193, 3, 164, 0, 18, 0, 35, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 19, 62, 89, 176, 0, 69, 88, 176, 15, 47, 27, 177, 15, 19, 62, 89, 179, 10, 6, 4, 4, 43, 48, 49, 1, 1, 6, 6, 35, 34, 39, 55, 22, 22, 51, 50, 54, 55, 55, 1, 51, 1, 1, 3, 193, 254, 8, 39, 142, 86, 96, 96, 27, 47, 90, 28, 68, 51, 19, 57, 254, 96, 162, 1, 80, 1, 74, 3, 164, 251, 112, 98, 61, 35, 118, 20, 17, 66, 45, 141, 3, 191, 252, 209, 3, 47, 0, 0, 3, 255, 227, 254, 139, 3, 193, 5, 25, 0, 10, 0, 36, 0, 47, 1, 50, 176, 48, 47, 176, 16, 208, 176, 16, 47, 176, 0, 220, 178, 128, 0, 1, 93, 178, 208, 0, 1, 93, 178, 48, 0, 1, 93, 176, 16, 16, 177, 5, 8, 244, 176, 0, 16, 176, 11, 208, 176, 0, 16, 176, 21, 208, 176, 0, 16, 177, 47, 8, 244, 176, 23, 208, 176, 0, 16, 176, 42, 220, 178, 128, 42, 1, 93, 178, 208, 42, 1, 93, 178, 48, 42, 1, 93, 178, 24, 0, 42, 17, 18, 57, 177, 29, 8, 244, 176, 47, 16, 176, 34, 208, 176, 29, 16, 176, 49, 220, 0, 176, 0, 69, 88, 176, 22, 47, 27, 177, 22, 21, 62, 89, 176, 0, 69, 88, 176, 19, 47, 27, 177, 19, 19, 62, 89, 176, 0, 69, 88, 176, 26, 47, 27, 177, 26, 19, 62, 89, 176, 0, 69, 88, 176, 35, 47, 27, 177, 35, 17, 62, 89, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 15, 62, 89, 176, 0, 69, 88, 176, 32, 47, 27, 177, 32, 15, 62, 89, 176, 19, 16, 177, 2, 6, 244, 180, 217, 2, 233, 2, 2, 93, 64, 27, 8, 2, 24, 2, 40, 2, 56, 2, 72, 2, 88, 2, 104, 2, 120, 2, 136, 2, 152, 2, 168, 2, 184, 2, 200, 2, 13, 93, 176, 13, 16, 177, 8, 6, 244, 64, 27, 7, 8, 23, 8, 39, 8, 55, 8, 71, 8, 87, 8, 103, 8, 119, 8, 135, 8, 151, 8, 167, 8, 183, 8, 199, 8, 13, 93, 180, 214, 8, 230, 8, 2, 93, 178, 11, 13, 8, 17, 18, 57, 178, 21, 19, 2, 17, 18, 57, 178, 24, 19, 2, 17, 18, 57, 178, 34, 13, 8, 17, 18, 57, 176, 39, 208, 176, 2, 16, 176, 45, 208, 48, 49, 1, 38, 35, 34, 6, 21, 20, 22, 51, 50, 55, 21, 6, 35, 34, 38, 53, 52, 54, 51, 50, 23, 17, 51, 17, 54, 51, 50, 22, 21, 20, 6, 35, 34, 39, 17, 35, 19, 22, 51, 50, 54, 53, 52, 38, 35, 34, 7, 1, 141, 57, 84, 74, 73, 73, 74, 84, 57, 53, 88, 143, 142, 142, 143, 88, 53, 138, 53, 88, 143, 142, 142, 143, 88, 53, 138, 138, 57, 84, 74, 73, 73, 74, 84, 57, 2, 231, 95, 172, 201, 201, 170, 94, 125, 86, 252, 236, 235, 254, 86, 1, 181, 254, 75, 86, 254, 235, 236, 252, 86, 254, 76, 2, 49, 94, 170, 201, 201, 172, 95, 0, 1, 255, 236, 0, 0, 3, 186, 3, 164, 0, 27, 0, 119, 0, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 19, 62, 89, 176, 0, 69, 88, 176, 21, 47, 27, 177, 21, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 15, 62, 89, 177, 2, 3, 244, 178, 4, 0, 14, 17, 18, 57, 176, 5, 208, 176, 6, 208, 176, 9, 208, 176, 10, 208, 176, 14, 16, 177, 12, 4, 244, 176, 16, 208, 176, 17, 208, 178, 18, 0, 14, 17, 18, 57, 176, 19, 208, 176, 20, 208, 176, 23, 208, 176, 24, 208, 176, 10, 16, 176, 26, 208, 176, 27, 208, 48, 49, 33, 33, 53, 51, 3, 3, 51, 21, 33, 53, 51, 1, 3, 35, 53, 33, 21, 35, 23, 55, 35, 53, 33, 21, 35, 3, 1, 51, 3, 186, 254, 127, 82, 184, 182, 75, 254, 132, 145, 1, 0, 246, 135, 1, 127, 86, 170, 172, 94, 1, 131, 131, 246, 1, 0, 143, 121, 1, 14, 254, 242, 121, 121, 1, 96, 1, 80, 123, 123, 254, 254, 123, 123, 254, 176, 254, 160, 0, 1, 0, 49, 254, 193, 4, 31, 3, 164, 0, 11, 0, 79, 179, 7, 12, 4, 4, 43, 179, 11, 8, 8, 4, 43, 179, 1, 11, 2, 4, 43, 176, 1, 16, 176, 13, 220, 0, 176, 1, 47, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 19, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 19, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 177, 0, 6, 244, 176, 7, 208, 176, 8, 208, 48, 49, 37, 17, 35, 17, 33, 17, 51, 17, 33, 17, 51, 17, 4, 31, 123, 252, 141, 137, 2, 47, 138, 121, 254, 72, 1, 63, 3, 164, 252, 209, 3, 47, 252, 213, 0, 0, 1, 0, 49, 0, 0, 3, 115, 3, 164, 0, 19, 0, 94, 176, 20, 47, 176, 21, 47, 176, 20, 16, 176, 0, 208, 176, 0, 47, 177, 1, 12, 244, 176, 21, 16, 176, 12, 220, 177, 11, 8, 244, 176, 14, 208, 178, 15, 0, 12, 17, 18, 57, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 19, 62, 89, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 19, 62, 89, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 15, 62, 89, 179, 5, 6, 17, 4, 43, 178, 15, 13, 0, 17, 18, 57, 48, 49, 19, 51, 17, 20, 22, 51, 50, 62, 2, 53, 53, 51, 17, 35, 17, 2, 35, 32, 17, 49, 137, 109, 121, 76, 122, 86, 45, 138, 138, 98, 254, 254, 168, 3, 164, 254, 215, 125, 137, 69, 117, 152, 82, 139, 252, 92, 2, 0, 255, 0, 1, 123, 0, 1, 0, 0, 0, 0, 3, 164, 3, 164, 0, 11, 0, 124, 176, 12, 47, 176, 7, 208, 176, 7, 47, 176, 0, 220, 178, 239, 0, 1, 93, 178, 64, 0, 1, 93, 177, 1, 8, 244, 176, 0, 16, 176, 3, 220, 178, 239, 3, 1, 93, 178, 64, 3, 1, 93, 177, 6, 12, 244, 176, 7, 16, 177, 10, 12, 244, 176, 6, 16, 176, 13, 220, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 19, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 19, 62, 89, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 19, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 177, 2, 6, 244, 176, 10, 208, 176, 11, 208, 48, 49, 1, 51, 17, 33, 17, 51, 17, 33, 17, 51, 17, 33, 1, 141, 138, 1, 4, 137, 252, 92, 137, 1, 4, 3, 164, 252, 209, 3, 47, 252, 92, 3, 164, 252, 209, 0, 0, 1, 0, 0, 254, 193, 4, 31, 3, 164, 0, 15, 0, 117, 179, 3, 12, 0, 4, 43, 179, 7, 8, 4, 4, 43, 179, 11, 12, 8, 4, 43, 176, 11, 16, 177, 12, 11, 244, 176, 11, 16, 176, 14, 208, 176, 11, 16, 176, 17, 220, 0, 176, 13, 47, 176, 0, 69, 88, 176, 1, 47, 27, 177, 1, 19, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 19, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 177, 3, 6, 244, 176, 7, 208, 176, 8, 208, 176, 11, 208, 176, 11, 47, 176, 12, 208, 176, 12, 47, 48, 49, 49, 17, 51, 17, 33, 17, 51, 17, 33, 17, 51, 17, 51, 17, 35, 17, 137, 1, 4, 138, 1, 4, 137, 123, 123, 3, 164, 252, 209, 3, 47, 252, 209, 3, 47, 252, 213, 254, 72, 1, 63, 0, 2, 0, 0, 0, 0, 3, 162, 3, 164, 0, 12, 0, 21, 0, 118, 176, 22, 47, 176, 23, 47, 176, 22, 16, 176, 10, 208, 176, 10, 47, 177, 18, 12, 244, 176, 1, 208, 176, 23, 16, 176, 6, 220, 177, 13, 12, 244, 180, 218, 13, 234, 13, 2, 93, 64, 27, 9, 13, 25, 13, 41, 13, 57, 13, 73, 13, 89, 13, 105, 13, 121, 13, 137, 13, 153, 13, 169, 13, 185, 13, 201, 13, 13, 93, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 19, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 15, 62, 89, 179, 3, 6, 16, 4, 43, 176, 0, 16, 177, 11, 6, 244, 176, 9, 16, 177, 18, 6, 244, 48, 49, 17, 33, 17, 51, 50, 22, 21, 20, 6, 35, 33, 17, 35, 1, 52, 38, 35, 35, 17, 51, 50, 54, 1, 117, 221, 162, 174, 174, 160, 254, 152, 236, 3, 25, 105, 92, 223, 223, 92, 105, 3, 164, 254, 139, 133, 145, 146, 135, 3, 47, 253, 234, 77, 84, 254, 187, 86, 0, 0, 3, 0, 0, 0, 0, 3, 164, 3, 164, 0, 3, 0, 14, 0, 23, 0, 135, 179, 20, 12, 12, 4, 43, 179, 8, 12, 15, 4, 43, 179, 1, 12, 0, 4, 43, 176, 20, 16, 176, 4, 208, 180, 218, 15, 234, 15, 2, 93, 64, 27, 9, 15, 25, 15, 41, 15, 57, 15, 73, 15, 89, 15, 105, 15, 121, 15, 137, 15, 153, 15, 169, 15, 185, 15, 201, 15, 13, 93, 176, 1, 16, 176, 25, 220, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 19, 62, 89, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 19, 62, 89, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 15, 62, 89, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 15, 62, 89, 179, 5, 6, 18, 4, 43, 176, 11, 16, 177, 20, 6, 244, 48, 49, 1, 51, 17, 35, 1, 51, 50, 22, 21, 20, 6, 35, 33, 17, 51, 1, 52, 38, 35, 35, 17, 51, 50, 54, 3, 27, 137, 137, 253, 110, 160, 154, 161, 161, 152, 254, 213, 137, 1, 82, 92, 84, 162, 162, 84, 92, 3, 164, 252, 92, 2, 47, 133, 145, 146, 135, 3, 164, 253, 117, 77, 84, 254, 187, 86, 0, 2, 0, 49, 0, 0, 3, 162, 3, 164, 0, 10, 0, 19, 0, 111, 176, 20, 47, 176, 21, 47, 176, 20, 16, 176, 8, 208, 176, 8, 47, 177, 16, 12, 244, 176, 0, 208, 176, 21, 16, 176, 4, 220, 177, 11, 12, 244, 180, 218, 11, 234, 11, 2, 93, 64, 27, 9, 11, 25, 11, 41, 11, 57, 11, 73, 11, 89, 11, 105, 11, 121, 11, 137, 11, 153, 11, 169, 11, 185, 11, 201, 11, 13, 93, 0, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 19, 62, 89, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 15, 62, 89, 179, 1, 6, 14, 4, 43, 176, 7, 16, 177, 16, 6, 244, 48, 49, 19, 33, 50, 22, 21, 20, 6, 35, 33, 17, 51, 1, 52, 38, 35, 33, 17, 33, 50, 54, 186, 1, 101, 186, 201, 199, 186, 254, 16, 137, 2, 95, 134, 116, 254, 155, 1, 101, 116, 134, 2, 47, 133, 145, 146, 135, 3, 164, 253, 117, 77, 84, 254, 187, 86, 0, 1, 0, 35, 255, 233, 3, 164, 3, 186, 0, 32, 0, 123, 0, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 19, 62, 89, 176, 0, 69, 88, 176, 21, 47, 27, 177, 21, 15, 62, 89, 179, 1, 6, 31, 4, 43, 176, 11, 16, 177, 4, 6, 244, 180, 217, 4, 233, 4, 2, 93, 64, 27, 8, 4, 24, 4, 40, 4, 56, 4, 72, 4, 88, 4, 104, 4, 120, 4, 136, 4, 152, 4, 168, 4, 184, 4, 200, 4, 13, 93, 176, 21, 16, 177, 28, 6, 244, 64, 27, 7, 28, 23, 28, 39, 28, 55, 28, 71, 28, 87, 28, 103, 28, 119, 28, 135, 28, 151, 28, 167, 28, 183, 28, 199, 28, 13, 93, 180, 214, 28, 230, 28, 2, 93, 48, 49, 1, 33, 38, 38, 35, 34, 6, 7, 39, 54, 54, 51, 50, 30, 2, 21, 20, 14, 2, 35, 34, 38, 39, 55, 22, 22, 51, 50, 54, 55, 33, 1, 23, 1, 253, 20, 180, 148, 104, 162, 43, 96, 59, 205, 141, 109, 182, 129, 72, 72, 129, 182, 109, 141, 205, 59, 96, 43, 162, 104, 154, 184, 15, 253, 254, 2, 23, 133, 170, 82, 68, 66, 92, 108, 71, 129, 181, 108, 109, 178, 129, 72, 107, 92, 66, 68, 80, 182, 142, 0, 2, 0, 49, 255, 233, 3, 164, 3, 186, 0, 14, 0, 22, 0, 222, 179, 1, 12, 0, 4, 43, 179, 21, 12, 11, 4, 43, 179, 7, 12, 17, 4, 43, 176, 11, 16, 176, 3, 208, 176, 1, 16, 176, 12, 208, 180, 218, 17, 234, 17, 2, 93, 64, 27, 9, 17, 25, 17, 41, 17, 57, 17, 73, 17, 89, 17, 105, 17, 121, 17, 137, 17, 153, 17, 169, 17, 185, 17, 201, 17, 13, 93, 176, 7, 16, 176, 24, 220, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 19, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 19, 62, 89, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 15, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 15, 62, 89, 179, 3, 6, 11, 4, 43, 176, 9, 16, 177, 15, 1, 244, 64, 27, 7, 15, 23, 15, 39, 15, 55, 15, 71, 15, 87, 15, 103, 15, 119, 15, 135, 15, 151, 15, 167, 15, 183, 15, 199, 15, 13, 93, 180, 214, 15, 230, 15, 2, 93, 176, 5, 16, 177, 19, 1, 244, 180, 217, 19, 233, 19, 2, 93, 64, 27, 8, 19, 24, 19, 40, 19, 56, 19, 72, 19, 88, 19, 104, 19, 120, 19, 136, 19, 152, 19, 168, 19, 184, 19, 200, 19, 13, 93, 48, 49, 19, 51, 17, 51, 18, 33, 32, 17, 16, 33, 32, 3, 35, 17, 35, 37, 50, 17, 16, 35, 34, 17, 16, 49, 137, 189, 18, 1, 4, 1, 23, 254, 233, 254, 248, 14, 189, 137, 2, 92, 142, 142, 141, 3, 164, 254, 104, 1, 174, 254, 23, 254, 24, 1, 175, 254, 104, 88, 1, 121, 1, 119, 254, 137, 254, 135, 0, 2, 255, 244, 0, 0, 3, 115, 3, 164, 0, 13, 0, 22, 0, 145, 176, 23, 47, 176, 24, 47, 176, 23, 16, 176, 3, 208, 176, 3, 47, 176, 24, 16, 176, 8, 220, 177, 9, 8, 244, 176, 3, 16, 176, 13, 208, 176, 13, 47, 176, 3, 16, 177, 14, 12, 244, 64, 27, 6, 14, 22, 14, 38, 14, 54, 14, 70, 14, 86, 14, 102, 14, 118, 14, 134, 14, 150, 14, 166, 14, 182, 14, 198, 14, 13, 93, 180, 213, 14, 229, 14, 2, 93, 176, 9, 16, 176, 18, 208, 0, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 19, 62, 89, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 15, 62, 89, 176, 0, 69, 88, 176, 12, 47, 27, 177, 12, 15, 62, 89, 179, 17, 6, 0, 4, 43, 176, 0, 16, 176, 10, 208, 176, 6, 16, 177, 19, 6, 244, 48, 49, 1, 38, 38, 53, 52, 54, 51, 33, 17, 35, 17, 35, 1, 35, 19, 20, 22, 51, 33, 17, 33, 34, 6, 1, 90, 166, 178, 199, 186, 1, 240, 138, 223, 254, 172, 194, 151, 133, 117, 1, 100, 254, 156, 117, 133, 1, 117, 8, 133, 137, 146, 135, 252, 92, 1, 117, 254, 139, 2, 139, 78, 84, 1, 70, 86, 255, 255, 255, 252, 255, 233, 3, 174, 5, 25, 2, 38, 1, 239, 0, 0, 0, 6, 0, 140, 0, 0, 0, 1, 255, 143, 254, 117, 3, 115, 5, 25, 0, 39, 0, 175, 176, 40, 47, 176, 41, 47, 176, 40, 16, 176, 1, 208, 176, 1, 47, 177, 4, 12, 244, 176, 7, 208, 176, 41, 16, 176, 13, 220, 178, 8, 1, 13, 17, 18, 57, 178, 21, 1, 13, 17, 18, 57, 177, 26, 8, 244, 176, 4, 16, 176, 35, 208, 176, 1, 16, 176, 37, 208, 0, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 21, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 19, 62, 89, 176, 0, 69, 88, 176, 36, 47, 27, 177, 36, 15, 62, 89, 179, 24, 6, 18, 4, 43, 179, 5, 6, 6, 4, 43, 176, 5, 16, 176, 0, 208, 178, 8, 36, 2, 17, 18, 57, 176, 10, 16, 177, 30, 6, 244, 180, 217, 30, 233, 30, 2, 93, 64, 27, 8, 30, 24, 30, 40, 30, 56, 30, 72, 30, 88, 30, 104, 30, 120, 30, 136, 30, 152, 30, 168, 30, 184, 30, 200, 30, 13, 93, 176, 6, 16, 176, 38, 208, 48, 49, 3, 51, 53, 51, 21, 51, 21, 35, 17, 18, 51, 32, 17, 17, 20, 14, 2, 35, 34, 39, 55, 22, 22, 51, 50, 53, 17, 52, 38, 35, 34, 14, 2, 21, 17, 35, 17, 35, 113, 162, 137, 187, 187, 99, 254, 1, 88, 37, 62, 82, 45, 84, 38, 26, 14, 35, 29, 106, 108, 121, 76, 123, 86, 45, 137, 162, 4, 94, 187, 187, 117, 254, 209, 1, 0, 254, 133, 253, 27, 55, 86, 58, 30, 24, 109, 8, 9, 113, 2, 229, 125, 138, 70, 117, 151, 82, 254, 94, 3, 233, 0, 255, 255, 0, 49, 0, 0, 3, 164, 5, 84, 2, 38, 1, 237, 0, 0, 0, 6, 0, 139, 0, 0, 0, 1, 0, 0, 255, 233, 3, 129, 3, 186, 0, 32, 0, 123, 0, 176, 0, 69, 88, 176, 20, 47, 27, 177, 20, 19, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 15, 62, 89, 179, 30, 6, 0, 4, 43, 176, 10, 16, 177, 3, 6, 244, 64, 27, 7, 3, 23, 3, 39, 3, 55, 3, 71, 3, 87, 3, 103, 3, 119, 3, 135, 3, 151, 3, 167, 3, 183, 3, 199, 3, 13, 93, 180, 214, 3, 230, 3, 2, 93, 176, 20, 16, 177, 27, 6, 244, 180, 217, 27, 233, 27, 2, 93, 64, 27, 8, 27, 24, 27, 40, 27, 56, 27, 72, 27, 88, 27, 104, 27, 120, 27, 136, 27, 152, 27, 168, 27, 184, 27, 200, 27, 13, 93, 48, 49, 19, 22, 22, 51, 50, 54, 55, 23, 6, 6, 35, 34, 46, 2, 53, 52, 62, 2, 51, 50, 22, 23, 7, 38, 38, 35, 34, 6, 7, 33, 21, 139, 15, 184, 154, 104, 162, 43, 96, 59, 205, 141, 109, 182, 129, 72, 72, 129, 182, 109, 141, 205, 59, 96, 43, 162, 104, 148, 182, 21, 2, 6, 1, 162, 142, 182, 80, 68, 66, 92, 107, 72, 129, 178, 109, 108, 181, 129, 71, 108, 92, 66, 68, 82, 170, 133, 117, 0, 1, 255, 246, 255, 233, 3, 139, 3, 186, 0, 50, 0, 217, 176, 51, 47, 176, 52, 47, 176, 0, 220, 177, 14, 12, 244, 180, 218, 14, 234, 14, 2, 93, 64, 27, 9, 14, 25, 14, 41, 14, 57, 14, 73, 14, 89, 14, 105, 14, 121, 14, 137, 14, 153, 14, 169, 14, 185, 14, 201, 14, 13, 93, 176, 51, 16, 176, 24, 208, 176, 24, 47, 177, 41, 12, 244, 64, 23, 6, 41, 22, 41, 38, 41, 54, 41, 70, 41, 86, 41, 102, 41, 118, 41, 134, 41, 150, 41, 166, 41, 11, 93, 180, 182, 41, 198, 41, 2, 93, 180, 213, 41, 229, 41, 2, 93, 0, 176, 0, 69, 88, 176, 29, 47, 27, 177, 29, 19, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 177, 12, 6, 244, 64, 27, 7, 12, 23, 12, 39, 12, 55, 12, 71, 12, 87, 12, 103, 12, 119, 12, 135, 12, 151, 12, 167, 12, 183, 12, 199, 12, 13, 93, 180, 214, 12, 230, 12, 2, 93, 176, 29, 16, 177, 36, 6, 244, 180, 217, 36, 233, 36, 2, 93, 64, 27, 8, 36, 24, 36, 40, 36, 56, 36, 72, 36, 88, 36, 104, 36, 120, 36, 136, 36, 152, 36, 168, 36, 184, 36, 200, 36, 13, 93, 48, 49, 1, 20, 14, 2, 35, 34, 38, 39, 55, 22, 22, 51, 32, 53, 52, 46, 2, 39, 46, 3, 53, 52, 62, 2, 51, 50, 22, 23, 7, 38, 38, 35, 34, 14, 2, 21, 20, 30, 2, 23, 30, 3, 3, 139, 82, 129, 159, 76, 127, 252, 92, 61, 103, 200, 107, 1, 53, 51, 86, 111, 61, 78, 154, 127, 77, 71, 119, 160, 86, 123, 194, 78, 55, 80, 164, 96, 43, 105, 90, 61, 51, 86, 111, 61, 76, 155, 127, 78, 1, 2, 82, 108, 64, 27, 74, 60, 118, 65, 70, 160, 39, 49, 31, 18, 8, 11, 30, 60, 100, 82, 70, 102, 68, 32, 57, 53, 107, 56, 45, 15, 37, 59, 45, 39, 47, 31, 18, 8, 11, 30, 58, 100, 0, 0, 2, 0, 186, 0, 0, 2, 233, 5, 25, 0, 3, 0, 13, 0, 95, 179, 12, 14, 6, 4, 43, 178, 1, 6, 12, 17, 18, 57, 176, 1, 47, 177, 0, 8, 244, 176, 12, 16, 177, 7, 8, 244, 176, 6, 16, 176, 9, 208, 0, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 21, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 19, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 177, 6, 6, 244, 176, 10, 16, 177, 8, 6, 244, 176, 6, 16, 176, 12, 208, 176, 13, 208, 48, 49, 1, 35, 53, 51, 19, 33, 53, 51, 17, 35, 53, 33, 17, 51, 2, 47, 186, 186, 186, 253, 209, 211, 211, 1, 93, 210, 4, 94, 187, 250, 231, 117, 2, 186, 117, 252, 209, 255, 255, 0, 186, 0, 0, 2, 233, 5, 25, 2, 38, 0, 213, 0, 0, 0, 6, 0, 140, 0, 0, 0, 2, 0, 4, 254, 117, 2, 233, 5, 25, 0, 3, 0, 22, 0, 62, 179, 0, 8, 1, 4, 43, 178, 15, 1, 0, 17, 18, 57, 176, 15, 47, 177, 20, 12, 244, 0, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 21, 62, 89, 176, 0, 69, 88, 176, 18, 47, 27, 177, 18, 19, 62, 89, 179, 10, 6, 4, 4, 43, 176, 18, 16, 177, 16, 6, 244, 48, 49, 1, 35, 53, 51, 1, 34, 39, 55, 22, 22, 51, 50, 62, 2, 53, 17, 35, 53, 33, 17, 20, 6, 2, 233, 186, 186, 254, 115, 246, 98, 105, 36, 117, 86, 68, 92, 53, 23, 211, 1, 92, 189, 4, 94, 187, 249, 92, 202, 72, 76, 82, 39, 72, 102, 66, 3, 47, 117, 252, 92, 180, 215, 0, 2, 255, 117, 255, 233, 3, 176, 3, 164, 0, 27, 0, 36, 0, 149, 179, 1, 12, 15, 4, 43, 179, 33, 12, 26, 4, 43, 179, 22, 12, 28, 4, 43, 176, 33, 16, 176, 17, 208, 180, 218, 28, 234, 28, 2, 93, 64, 27, 9, 28, 25, 28, 41, 28, 57, 28, 73, 28, 89, 28, 105, 28, 121, 28, 137, 28, 153, 28, 169, 28, 185, 28, 201, 28, 13, 93, 176, 22, 16, 176, 38, 220, 0, 176, 0, 69, 88, 176, 16, 47, 27, 177, 16, 19, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 15, 62, 89, 176, 0, 69, 88, 176, 25, 47, 27, 177, 25, 15, 62, 89, 179, 19, 6, 31, 4, 43, 176, 16, 16, 177, 0, 6, 244, 176, 25, 16, 177, 33, 6, 244, 178, 10, 25, 33, 17, 18, 57, 48, 49, 19, 17, 20, 14, 2, 35, 34, 38, 39, 55, 22, 22, 51, 50, 53, 17, 33, 17, 51, 50, 22, 21, 20, 6, 35, 33, 17, 1, 52, 38, 35, 35, 17, 51, 50, 54, 186, 32, 58, 76, 43, 40, 54, 22, 24, 13, 32, 25, 94, 1, 205, 119, 153, 162, 162, 151, 254, 254, 1, 178, 92, 84, 121, 121, 84, 92, 3, 47, 253, 160, 55, 86, 58, 31, 9, 10, 115, 9, 8, 113, 2, 213, 254, 139, 133, 145, 146, 135, 3, 47, 253, 234, 77, 84, 254, 187, 86, 0, 2, 0, 49, 0, 0, 3, 176, 3, 164, 0, 18, 0, 27, 0, 159, 179, 18, 12, 0, 4, 43, 179, 7, 12, 4, 4, 43, 179, 11, 12, 19, 4, 43, 176, 18, 16, 176, 2, 208, 176, 4, 16, 176, 15, 208, 180, 218, 19, 234, 19, 2, 93, 64, 27, 9, 19, 25, 19, 41, 19, 57, 19, 73, 19, 89, 19, 105, 19, 121, 19, 137, 19, 153, 19, 169, 19, 185, 19, 201, 19, 13, 93, 176, 7, 16, 176, 23, 208, 176, 11, 16, 176, 29, 220, 0, 176, 0, 69, 88, 176, 1, 47, 27, 177, 1, 19, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 15, 62, 89, 179, 4, 6, 16, 4, 43, 176, 4, 16, 176, 7, 208, 176, 16, 16, 176, 22, 208, 176, 14, 16, 177, 24, 6, 244, 48, 49, 51, 17, 51, 17, 51, 17, 51, 17, 51, 50, 22, 21, 20, 6, 35, 33, 17, 35, 17, 1, 52, 38, 35, 35, 17, 51, 50, 54, 49, 137, 187, 137, 119, 153, 162, 162, 151, 254, 254, 187, 2, 109, 92, 84, 121, 121, 84, 92, 3, 164, 254, 139, 1, 117, 254, 139, 133, 145, 146, 135, 1, 186, 254, 70, 1, 25, 77, 84, 254, 187, 86, 0, 1, 255, 143, 0, 0, 3, 115, 5, 25, 0, 27, 0, 175, 176, 28, 47, 176, 29, 47, 176, 28, 16, 176, 1, 208, 176, 1, 47, 177, 4, 12, 244, 176, 7, 208, 176, 29, 16, 176, 13, 220, 178, 8, 1, 13, 17, 18, 57, 177, 14, 8, 244, 176, 4, 16, 176, 23, 208, 176, 1, 16, 176, 25, 208, 0, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 21, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 19, 62, 89, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 15, 62, 89, 176, 0, 69, 88, 176, 24, 47, 27, 177, 24, 15, 62, 89, 179, 5, 6, 6, 4, 43, 176, 5, 16, 176, 0, 208, 178, 8, 13, 2, 17, 18, 57, 176, 10, 16, 177, 18, 6, 244, 180, 217, 18, 233, 18, 2, 93, 64, 27, 8, 18, 24, 18, 40, 18, 56, 18, 72, 18, 88, 18, 104, 18, 120, 18, 136, 18, 152, 18, 168, 18, 184, 18, 200, 18, 13, 93, 176, 6, 16, 176, 26, 208, 48, 49, 3, 51, 53, 51, 21, 51, 21, 35, 17, 18, 51, 32, 17, 17, 35, 17, 52, 38, 35, 34, 14, 2, 21, 17, 35, 17, 35, 113, 162, 137, 187, 187, 99, 254, 1, 88, 138, 108, 121, 76, 123, 86, 45, 137, 162, 4, 94, 187, 187, 117, 254, 209, 1, 0, 254, 133, 253, 193, 2, 63, 125, 138, 70, 117, 151, 82, 254, 94, 3, 233, 0, 255, 255, 0, 49, 0, 0, 3, 162, 5, 84, 2, 38, 1, 244, 0, 0, 0, 6, 0, 139, 0, 0, 255, 255, 255, 225, 254, 117, 3, 193, 5, 6, 2, 38, 1, 253, 0, 0, 0, 6, 0, 217, 0, 0, 0, 1, 0, 49, 254, 193, 3, 115, 3, 164, 0, 11, 0, 83, 179, 8, 12, 5, 4, 43, 179, 2, 8, 3, 4, 43, 179, 0, 8, 9, 4, 43, 0, 176, 2, 47, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 19, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 177, 8, 6, 244, 176, 9, 208, 48, 49, 33, 33, 17, 35, 17, 33, 17, 51, 17, 33, 17, 51, 3, 115, 254, 164, 138, 254, 164, 137, 2, 47, 138, 254, 193, 1, 63, 3, 164, 252, 209, 3, 47, 0, 1, 0, 49, 0, 0, 3, 164, 5, 211, 0, 7, 0, 65, 176, 8, 47, 176, 9, 47, 176, 1, 220, 177, 0, 13, 244, 176, 8, 16, 176, 5, 208, 176, 5, 47, 177, 4, 12, 244, 0, 176, 0, 47, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 21, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 176, 6, 16, 177, 2, 6, 244, 48, 49, 1, 51, 17, 33, 17, 35, 17, 33, 3, 47, 117, 253, 22, 137, 2, 254, 5, 211, 254, 209, 251, 92, 5, 25, 0, 0, 1, 0, 49, 0, 0, 3, 164, 4, 94, 0, 7, 0, 65, 176, 8, 47, 176, 9, 47, 176, 1, 220, 177, 0, 13, 244, 176, 8, 16, 176, 5, 208, 176, 5, 47, 177, 4, 12, 244, 0, 176, 0, 47, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 19, 62, 89, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 15, 62, 89, 176, 6, 16, 177, 2, 6, 244, 48, 49, 1, 51, 17, 33, 17, 35, 17, 33, 3, 47, 117, 253, 22, 137, 2, 254, 4, 94, 254, 209, 252, 209, 3, 164, 0, 255, 255, 0, 49, 0, 0, 3, 162, 6, 142, 2, 38, 0, 35, 0, 0, 0, 7, 0, 218, 0, 0, 1, 117, 255, 255, 0, 49, 255, 233, 3, 164, 6, 142, 2, 38, 0, 67, 0, 0, 0, 7, 0, 218, 0, 0, 1, 117, 255, 255, 0, 49, 0, 0, 3, 207, 6, 142, 2, 38, 0, 37, 0, 0, 0, 7, 0, 218, 0, 0, 1, 117, 255, 255, 255, 254, 255, 233, 3, 115, 6, 142, 2, 38, 0, 69, 0, 0, 0, 7, 0, 218, 0, 0, 1, 117, 255, 255, 0, 49, 0, 0, 3, 115, 6, 142, 2, 38, 0, 39, 0, 0, 0, 7, 0, 218, 0, 0, 1, 117, 255, 255, 0, 186, 0, 0, 3, 164, 6, 142, 2, 38, 0, 71, 0, 0, 0, 7, 0, 218, 0, 0, 1, 117, 255, 255, 0, 49, 0, 0, 3, 115, 6, 142, 2, 38, 0, 46, 0, 0, 0, 7, 0, 218, 0, 0, 1, 117, 255, 255, 0, 0, 0, 0, 3, 164, 5, 25, 2, 38, 0, 78, 0, 0, 0, 6, 0, 218, 0, 0, 255, 255, 0, 49, 0, 0, 3, 162, 6, 142, 2, 38, 0, 49, 0, 0, 0, 7, 0, 218, 0, 0, 1, 117, 255, 255, 0, 49, 254, 139, 3, 164, 5, 25, 2, 38, 0, 81, 0, 0, 0, 6, 0, 218, 0, 0, 255, 255, 0, 25, 255, 233, 3, 131, 6, 142, 2, 38, 0, 52, 0, 0, 0, 7, 0, 218, 0, 0, 1, 117, 255, 255, 255, 246, 255, 233, 3, 139, 5, 25, 2, 38, 0, 84, 0, 0, 0, 6, 0, 218, 0, 0, 255, 255, 0, 0, 0, 0, 3, 164, 6, 142, 2, 38, 0, 53, 0, 0, 0, 7, 0, 218, 0, 0, 1, 117, 255, 255, 0, 0, 255, 233, 3, 174, 6, 142, 2, 38, 0, 85, 0, 0, 0, 7, 0, 218, 0, 0, 1, 117, 255, 255, 255, 193, 0, 0, 3, 227, 6, 205, 2, 38, 0, 56, 0, 0, 0, 7, 0, 65, 0, 0, 1, 121, 255, 255, 255, 229, 0, 0, 3, 195, 5, 88, 2, 38, 0, 88, 0, 0, 0, 6, 0, 65, 0, 4, 255, 255, 255, 193, 0, 0, 3, 227, 6, 201, 2, 38, 0, 56, 0, 0, 0, 7, 0, 139, 0, 0, 1, 117, 255, 255, 255, 229, 0, 0, 3, 195, 5, 84, 2, 38, 0, 88, 0, 0, 0, 6, 0, 139, 0, 0, 255, 255, 255, 193, 0, 0, 3, 227, 6, 142, 2, 38, 0, 56, 0, 0, 0, 7, 0, 140, 0, 0, 1, 117, 255, 255, 255, 229, 0, 0, 3, 195, 5, 25, 2, 38, 0, 88, 0, 0, 0, 6, 0, 140, 0, 0, 255, 255, 255, 236, 0, 0, 3, 184, 6, 205, 2, 38, 0, 58, 0, 0, 0, 7, 0, 65, 0, 0, 1, 121, 255, 255, 255, 225, 254, 117, 3, 193, 5, 88, 2, 38, 0, 90, 0, 0, 0, 6, 0, 65, 0, 4, 0, 1, 0, 0, 1, 164, 3, 164, 2, 25, 0, 3, 0, 9, 0, 179, 3, 6, 0, 4, 43, 48, 49, 1, 33, 53, 33, 3, 164, 252, 92, 3, 164, 1, 164, 117, 0, 4, 0, 0, 0, 0, 4, 70, 5, 25, 0, 9, 0, 17, 0, 25, 0, 29, 1, 18, 179, 3, 12, 4, 4, 43, 179, 0, 12, 7, 4, 43, 179, 16, 12, 20, 4, 43, 179, 24, 8, 12, 4, 43, 180, 218, 12, 234, 12, 2, 93, 64, 27, 9, 12, 25, 12, 41, 12, 57, 12, 73, 12, 89, 12, 105, 12, 121, 12, 137, 12, 153, 12, 169, 12, 185, 12, 201, 12, 13, 93, 180, 218, 20, 234, 20, 2, 93, 64, 27, 9, 20, 25, 20, 41, 20, 57, 20, 73, 20, 89, 20, 105, 20, 121, 20, 137, 20, 153, 20, 169, 20, 185, 20, 201, 20, 13, 93, 176, 20, 16, 176, 26, 208, 176, 26, 47, 176, 24, 16, 176, 27, 208, 176, 24, 16, 176, 31, 220, 0, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 21, 62, 89, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 21, 62, 89, 176, 0, 69, 88, 176, 22, 47, 27, 177, 22, 19, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 176, 0, 69, 88, 176, 28, 47, 27, 177, 28, 15, 62, 89, 179, 10, 1, 18, 4, 43, 178, 2, 0, 5, 17, 18, 57, 178, 7, 18, 10, 17, 18, 57, 176, 22, 16, 177, 14, 1, 244, 180, 217, 14, 233, 14, 2, 93, 64, 27, 8, 14, 24, 14, 40, 14, 56, 14, 72, 14, 88, 14, 104, 14, 120, 14, 136, 14, 152, 14, 168, 14, 184, 14, 200, 14, 13, 93, 176, 0, 16, 177, 26, 6, 244, 176, 27, 208, 48, 49, 33, 35, 3, 17, 35, 17, 51, 19, 17, 51, 1, 50, 53, 52, 35, 34, 21, 20, 23, 32, 17, 16, 33, 32, 17, 16, 5, 33, 21, 33, 1, 254, 170, 203, 137, 193, 180, 137, 1, 74, 116, 116, 121, 119, 255, 0, 1, 0, 1, 0, 254, 2, 1, 254, 254, 2, 3, 254, 252, 2, 5, 25, 252, 84, 3, 172, 252, 178, 192, 191, 191, 192, 111, 1, 47, 1, 47, 254, 209, 254, 209, 231, 117, 0, 0, 1, 0, 0, 1, 164, 3, 164, 2, 25, 0, 3, 0, 9, 0, 179, 3, 6, 0, 4, 43, 48, 49, 1, 33, 53, 33, 3, 164, 252, 92, 3, 164, 1, 164, 117, 0, 1, 255, 211, 0, 2, 3, 209, 2, 80, 0, 5, 0, 32, 0, 176, 5, 47, 176, 0, 69, 88, 176, 1, 47, 27, 177, 1, 15, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 48, 49, 37, 7, 1, 1, 39, 1, 3, 209, 80, 254, 82, 254, 78, 78, 2, 0, 80, 78, 1, 176, 254, 80, 78, 2, 0, 0, 0, 6, 0, 68, 0, 70, 4, 25, 4, 25, 0, 47, 0, 58, 0, 69, 0, 73, 0, 84, 0, 95, 1, 34, 179, 89, 10, 24, 4, 43, 179, 63, 10, 70, 4, 43, 179, 73, 10, 19, 4, 43, 179, 39, 10, 48, 4, 43, 176, 39, 16, 176, 0, 208, 176, 70, 16, 176, 6, 208, 176, 6, 47, 176, 73, 16, 176, 8, 208, 176, 24, 16, 176, 15, 208, 176, 15, 47, 176, 73, 16, 176, 30, 208, 176, 70, 16, 176, 32, 208, 176, 63, 16, 176, 43, 208, 176, 43, 47, 180, 218, 48, 234, 48, 2, 93, 64, 27, 9, 48, 25, 48, 41, 48, 57, 48, 73, 48, 89, 48, 105, 48, 121, 48, 137, 48, 153, 48, 169, 48, 185, 48, 201, 48, 13, 93, 176, 63, 16, 176, 54, 208, 176, 54, 47, 176, 48, 16, 176, 59, 208, 176, 19, 16, 176, 74, 208, 64, 27, 6, 89, 22, 89, 38, 89, 54, 89, 70, 89, 86, 89, 102, 89, 118, 89, 134, 89, 150, 89, 166, 89, 182, 89, 198, 89, 13, 93, 180, 213, 89, 229, 89, 2, 93, 176, 89, 16, 176, 80, 208, 176, 80, 47, 176, 19, 16, 176, 85, 208, 176, 39, 16, 176, 97, 220, 0, 179, 67, 2, 3, 4, 43, 179, 36, 2, 51, 4, 43, 179, 70, 2, 7, 4, 43, 179, 84, 2, 20, 4, 43, 176, 3, 16, 176, 12, 208, 176, 70, 16, 176, 18, 208, 176, 36, 16, 176, 27, 208, 176, 84, 16, 176, 31, 208, 176, 20, 16, 176, 42, 208, 176, 70, 16, 176, 44, 208, 176, 84, 16, 176, 55, 208, 176, 7, 16, 176, 62, 208, 176, 20, 16, 176, 71, 208, 176, 51, 16, 176, 77, 208, 176, 7, 16, 176, 85, 208, 176, 67, 16, 176, 92, 208, 48, 49, 1, 20, 6, 35, 34, 38, 53, 53, 35, 21, 20, 6, 35, 34, 38, 53, 52, 54, 51, 51, 53, 35, 34, 38, 53, 52, 54, 51, 50, 22, 21, 21, 51, 53, 52, 54, 51, 50, 22, 21, 20, 6, 35, 35, 21, 51, 50, 22, 3, 52, 38, 35, 34, 6, 21, 21, 51, 50, 54, 17, 52, 38, 35, 35, 21, 20, 22, 51, 50, 54, 37, 53, 35, 21, 3, 52, 38, 35, 34, 6, 21, 20, 22, 51, 51, 17, 35, 34, 6, 21, 20, 22, 51, 50, 54, 53, 4, 25, 111, 78, 78, 106, 232, 110, 78, 78, 110, 110, 78, 98, 96, 78, 110, 110, 78, 78, 108, 230, 108, 78, 78, 111, 111, 78, 96, 96, 78, 111, 91, 57, 41, 41, 55, 96, 41, 57, 57, 41, 94, 53, 41, 41, 57, 254, 228, 230, 90, 55, 41, 41, 57, 57, 41, 96, 98, 41, 57, 57, 41, 41, 57, 1, 2, 78, 110, 110, 78, 96, 96, 78, 110, 110, 78, 78, 108, 230, 108, 78, 78, 111, 111, 78, 96, 96, 78, 111, 111, 78, 78, 108, 230, 108, 2, 12, 41, 57, 57, 41, 96, 55, 253, 207, 41, 55, 96, 41, 57, 57, 227, 230, 230, 1, 160, 41, 57, 57, 41, 41, 55, 254, 102, 55, 41, 41, 57, 57, 41, 0, 0, 3, 255, 211, 0, 2, 3, 209, 2, 199, 0, 3, 0, 7, 0, 13, 0, 47, 0, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 15, 62, 89, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 15, 62, 89, 179, 3, 1, 0, 4, 43, 176, 0, 16, 176, 4, 208, 176, 3, 16, 176, 6, 208, 48, 49, 1, 33, 53, 33, 5, 33, 53, 33, 1, 7, 1, 1, 39, 1, 3, 162, 254, 213, 1, 43, 253, 139, 254, 213, 1, 43, 2, 164, 80, 254, 82, 254, 78, 78, 2, 0, 2, 86, 113, 113, 113, 253, 137, 78, 1, 176, 254, 80, 78, 2, 0, 0, 2, 0, 0, 0, 37, 4, 92, 2, 199, 0, 17, 0, 21, 0, 27, 0, 179, 17, 1, 0, 4, 43, 179, 9, 1, 6, 4, 43, 176, 6, 16, 176, 18, 208, 176, 9, 16, 176, 20, 208, 48, 49, 37, 35, 34, 39, 3, 38, 35, 35, 53, 51, 50, 23, 22, 22, 23, 22, 51, 51, 17, 33, 53, 33, 4, 92, 162, 215, 123, 170, 102, 180, 164, 164, 217, 123, 41, 86, 43, 100, 180, 162, 254, 144, 1, 112, 37, 145, 1, 15, 145, 113, 148, 67, 136, 67, 148, 1, 197, 113, 0, 0, 3, 0, 74, 0, 0, 4, 86, 5, 25, 0, 4, 0, 9, 0, 21, 0, 49, 179, 8, 9, 2, 4, 43, 0, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 21, 62, 89, 176, 0, 69, 88, 176, 1, 47, 27, 177, 1, 15, 62, 89, 176, 3, 16, 177, 6, 1, 244, 176, 1, 16, 177, 8, 1, 244, 48, 49, 1, 1, 33, 17, 33, 1, 1, 35, 17, 51, 1, 7, 39, 7, 39, 55, 39, 55, 23, 55, 23, 7, 4, 86, 253, 115, 254, 129, 1, 127, 1, 239, 253, 228, 228, 228, 1, 2, 80, 125, 125, 78, 125, 125, 78, 125, 125, 80, 125, 2, 139, 253, 117, 5, 25, 253, 114, 2, 31, 251, 197, 1, 159, 77, 126, 126, 77, 125, 125, 80, 125, 125, 80, 125, 0, 0, 1, 0, 0, 0, 0, 4, 92, 1, 47, 0, 11, 0, 70, 176, 12, 47, 176, 13, 47, 176, 1, 220, 176, 12, 16, 176, 4, 208, 176, 4, 47, 177, 8, 9, 244, 176, 1, 16, 177, 9, 9, 244, 0, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 15, 62, 89, 179, 11, 1, 0, 4, 43, 176, 0, 16, 176, 4, 208, 176, 11, 16, 176, 6, 208, 176, 2, 16, 177, 8, 1, 244, 48, 49, 37, 33, 21, 33, 53, 35, 53, 33, 21, 33, 53, 33, 4, 92, 255, 0, 253, 162, 254, 1, 109, 1, 129, 1, 110, 193, 193, 193, 110, 192, 192, 0, 0, 2, 0, 188, 255, 254, 4, 98, 3, 162, 0, 31, 0, 40, 0, 154, 176, 41, 47, 176, 42, 47, 176, 0, 220, 177, 21, 10, 244, 180, 218, 21, 234, 21, 2, 93, 64, 27, 9, 21, 25, 21, 41, 21, 57, 21, 73, 21, 89, 21, 105, 21, 121, 21, 137, 21, 153, 21, 169, 21, 185, 21, 201, 21, 13, 93, 176, 41, 16, 176, 36, 208, 176, 36, 47, 177, 35, 9, 244, 178, 40, 36, 0, 17, 18, 57, 0, 176, 0, 69, 88, 176, 37, 47, 27, 177, 37, 19, 62, 89, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 15, 62, 89, 177, 16, 2, 244, 64, 27, 7, 16, 23, 16, 39, 16, 55, 16, 71, 16, 87, 16, 103, 16, 119, 16, 135, 16, 151, 16, 167, 16, 183, 16, 199, 16, 13, 93, 180, 214, 16, 230, 16, 2, 93, 178, 34, 5, 37, 17, 18, 57, 176, 37, 16, 177, 39, 1, 244, 48, 49, 1, 20, 14, 2, 35, 34, 46, 2, 39, 55, 30, 3, 51, 50, 62, 2, 53, 52, 46, 2, 39, 55, 30, 3, 5, 7, 1, 21, 35, 17, 33, 21, 35, 4, 98, 73, 127, 172, 99, 80, 143, 117, 86, 22, 73, 19, 67, 99, 121, 69, 82, 144, 106, 61, 40, 76, 105, 63, 22, 74, 123, 92, 51, 254, 138, 80, 254, 143, 111, 1, 156, 221, 1, 211, 98, 172, 125, 74, 49, 88, 125, 76, 20, 59, 104, 76, 43, 61, 105, 143, 84, 63, 121, 101, 71, 19, 73, 20, 86, 117, 145, 96, 78, 1, 112, 227, 1, 160, 111, 0, 0, 1, 255, 227, 255, 217, 4, 84, 3, 125, 0, 21, 0, 30, 179, 0, 9, 18, 4, 43, 0, 176, 8, 47, 179, 21, 1, 0, 4, 43, 179, 13, 1, 5, 4, 43, 176, 0, 16, 176, 18, 208, 48, 49, 1, 20, 14, 2, 35, 33, 23, 7, 1, 1, 23, 7, 33, 50, 62, 2, 53, 33, 53, 33, 4, 84, 84, 150, 202, 117, 254, 139, 191, 78, 254, 188, 1, 68, 78, 191, 1, 117, 92, 160, 121, 69, 254, 74, 2, 37, 3, 14, 112, 201, 152, 88, 192, 76, 1, 66, 1, 69, 78, 190, 70, 120, 160, 92, 111, 0, 0, 1, 0, 72, 0, 0, 3, 92, 1, 47, 0, 7, 0, 64, 176, 8, 47, 176, 9, 47, 176, 0, 220, 176, 8, 16, 176, 1, 208, 176, 1, 47, 177, 4, 9, 244, 176, 0, 16, 177, 5, 9, 244, 0, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 176, 2, 220, 176, 0, 16, 177, 4, 1, 244, 176, 2, 16, 176, 6, 208, 176, 7, 208, 48, 49, 33, 33, 17, 51, 21, 33, 53, 51, 3, 92, 252, 236, 110, 2, 54, 112, 1, 47, 192, 192, 0, 1, 0, 0, 2, 72, 4, 94, 2, 209, 0, 3, 0, 9, 0, 179, 1, 7, 0, 4, 43, 48, 49, 17, 53, 33, 21, 4, 94, 2, 72, 137, 137, 0, 0, 1, 1, 141, 254, 139, 2, 23, 6, 139, 0, 3, 0, 25, 179, 1, 8, 0, 4, 43, 0, 176, 0, 47, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 17, 62, 89, 48, 49, 1, 51, 17, 35, 1, 141, 138, 138, 6, 139, 248, 0, 0, 0, 1, 1, 141, 254, 139, 4, 94, 2, 209, 0, 5, 0, 28, 179, 3, 8, 0, 4, 43, 0, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 17, 62, 89, 179, 1, 7, 2, 4, 43, 48, 49, 1, 33, 21, 33, 17, 35, 1, 141, 2, 209, 253, 185, 138, 2, 209, 137, 252, 67, 0, 1, 0, 0, 254, 139, 2, 23, 2, 209, 0, 5, 0, 28, 179, 3, 8, 4, 4, 43, 0, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 17, 62, 89, 179, 1, 7, 0, 4, 43, 48, 49, 17, 53, 33, 17, 35, 17, 2, 23, 138, 2, 72, 137, 251, 186, 3, 189, 0, 1, 1, 141, 2, 72, 4, 94, 6, 139, 0, 5, 0, 18, 179, 1, 8, 0, 4, 43, 0, 176, 0, 47, 179, 3, 7, 4, 4, 43, 48, 49, 1, 51, 17, 33, 21, 33, 1, 141, 138, 2, 71, 253, 47, 6, 139, 252, 70, 137, 0, 1, 0, 0, 2, 72, 2, 23, 6, 139, 0, 5, 0, 18, 179, 5, 8, 2, 4, 43, 0, 176, 3, 47, 179, 1, 7, 0, 4, 43, 48, 49, 17, 53, 33, 17, 51, 17, 1, 141, 138, 2, 72, 137, 3, 186, 251, 189, 0, 1, 1, 141, 254, 139, 4, 94, 6, 139, 0, 7, 0, 37, 179, 1, 8, 0, 4, 43, 176, 1, 16, 176, 5, 208, 0, 176, 0, 47, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 17, 62, 89, 179, 3, 7, 4, 4, 43, 48, 49, 1, 51, 17, 33, 21, 33, 17, 35, 1, 141, 138, 2, 71, 253, 185, 138, 6, 139, 252, 70, 137, 252, 67, 0, 1, 0, 0, 254, 139, 2, 23, 6, 139, 0, 7, 0, 37, 179, 0, 8, 1, 4, 43, 176, 1, 16, 176, 5, 208, 0, 176, 6, 47, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 17, 62, 89, 179, 5, 7, 2, 4, 43, 48, 49, 1, 35, 17, 33, 53, 33, 17, 51, 2, 23, 138, 254, 115, 1, 141, 138, 254, 139, 3, 189, 137, 3, 186, 0, 1, 0, 0, 254, 139, 4, 94, 2, 209, 0, 7, 0, 34, 179, 5, 8, 6, 4, 43, 0, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 17, 62, 89, 179, 1, 7, 0, 4, 43, 176, 0, 16, 176, 3, 208, 48, 49, 17, 53, 33, 21, 33, 17, 35, 17, 4, 94, 253, 185, 138, 2, 72, 137, 137, 252, 67, 3, 189, 0, 0, 1, 0, 0, 2, 72, 4, 94, 6, 139, 0, 7, 0, 24, 179, 5, 8, 2, 4, 43, 0, 176, 3, 47, 179, 1, 7, 0, 4, 43, 176, 1, 16, 176, 5, 208, 48, 49, 17, 53, 33, 17, 51, 17, 33, 21, 1, 141, 138, 2, 71, 2, 72, 137, 3, 186, 252, 70, 137, 0, 0, 1, 0, 0, 254, 139, 4, 94, 6, 139, 0, 11, 0, 55, 179, 5, 8, 2, 4, 43, 176, 5, 16, 176, 8, 208, 176, 2, 16, 176, 10, 208, 0, 176, 3, 47, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 17, 62, 89, 179, 1, 7, 0, 4, 43, 176, 1, 16, 176, 5, 208, 176, 0, 16, 176, 7, 208, 48, 49, 17, 53, 33, 17, 51, 17, 33, 21, 33, 17, 35, 17, 1, 141, 138, 2, 71, 253, 185, 138, 2, 72, 137, 3, 186, 252, 70, 137, 252, 67, 3, 189, 0, 0, 2, 0, 0, 1, 141, 4, 94, 3, 139, 0, 3, 0, 7, 0, 15, 0, 179, 4, 5, 5, 4, 43, 179, 0, 7, 1, 4, 43, 48, 49, 1, 21, 33, 53, 1, 21, 33, 53, 4, 94, 251, 162, 4, 94, 251, 162, 3, 139, 137, 137, 254, 140, 138, 138, 0, 0, 2, 0, 211, 254, 139, 2, 209, 6, 139, 0, 3, 0, 7, 0, 64, 176, 8, 47, 176, 9, 47, 176, 8, 16, 176, 1, 208, 176, 1, 47, 177, 0, 12, 244, 176, 9, 16, 176, 5, 220, 177, 4, 12, 244, 0, 176, 2, 47, 176, 4, 47, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 17, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 17, 62, 89, 48, 49, 1, 35, 17, 59, 2, 17, 35, 1, 92, 137, 137, 236, 137, 137, 254, 139, 8, 0, 248, 0, 0, 1, 1, 141, 254, 139, 4, 94, 3, 139, 0, 11, 0, 62, 179, 3, 8, 4, 4, 43, 179, 11, 12, 6, 4, 43, 176, 6, 16, 177, 0, 14, 244, 176, 8, 208, 176, 11, 16, 176, 13, 220, 0, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 17, 62, 89, 179, 8, 7, 9, 4, 43, 179, 0, 5, 1, 4, 43, 176, 0, 16, 176, 5, 208, 48, 49, 1, 21, 33, 17, 35, 17, 33, 17, 33, 21, 35, 21, 4, 94, 253, 185, 138, 1, 117, 1, 92, 211, 2, 23, 138, 252, 254, 3, 140, 1, 116, 137, 235, 0, 0, 1, 0, 211, 254, 139, 4, 94, 2, 209, 0, 11, 0, 73, 176, 12, 47, 176, 13, 47, 176, 3, 220, 177, 4, 12, 244, 176, 12, 16, 176, 8, 208, 176, 8, 47, 177, 7, 12, 244, 176, 4, 16, 176, 10, 208, 0, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 17, 62, 89, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 17, 62, 89, 179, 0, 7, 1, 4, 43, 179, 10, 7, 5, 4, 43, 48, 49, 1, 21, 33, 17, 35, 17, 35, 17, 35, 17, 33, 17, 4, 94, 254, 115, 137, 236, 137, 1, 117, 2, 209, 137, 252, 67, 2, 72, 253, 184, 2, 209, 1, 117, 0, 0, 2, 0, 211, 254, 139, 4, 94, 3, 139, 0, 5, 0, 11, 0, 70, 176, 12, 47, 176, 13, 47, 176, 12, 16, 176, 2, 208, 176, 2, 47, 177, 1, 12, 244, 176, 13, 16, 176, 9, 220, 177, 10, 12, 244, 0, 176, 0, 69, 88, 176, 1, 47, 27, 177, 1, 17, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 17, 62, 89, 179, 3, 7, 0, 4, 43, 179, 6, 5, 7, 4, 43, 48, 49, 1, 17, 35, 17, 33, 29, 2, 33, 17, 35, 17, 1, 92, 137, 3, 139, 254, 115, 137, 3, 2, 251, 137, 5, 0, 137, 235, 138, 252, 254, 3, 140, 0, 1, 0, 0, 254, 139, 2, 23, 3, 139, 0, 11, 0, 59, 179, 7, 14, 1, 4, 43, 179, 9, 8, 10, 4, 43, 176, 7, 16, 177, 2, 12, 244, 176, 1, 16, 176, 4, 208, 0, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 17, 62, 89, 179, 6, 7, 3, 4, 43, 179, 1, 5, 0, 4, 43, 176, 1, 16, 176, 7, 208, 48, 49, 17, 53, 51, 53, 35, 53, 33, 17, 51, 17, 35, 17, 211, 211, 1, 92, 187, 138, 1, 141, 138, 235, 137, 254, 140, 252, 116, 3, 2, 0, 1, 0, 0, 254, 139, 2, 209, 2, 209, 0, 11, 0, 73, 176, 12, 47, 176, 13, 47, 176, 12, 16, 176, 8, 208, 176, 8, 47, 177, 7, 12, 244, 176, 0, 208, 176, 13, 16, 176, 3, 220, 177, 4, 12, 244, 0, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 17, 62, 89, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 17, 62, 89, 179, 0, 7, 9, 4, 43, 179, 2, 7, 5, 4, 43, 48, 49, 1, 17, 33, 17, 35, 17, 35, 17, 35, 17, 35, 53, 1, 92, 1, 117, 137, 236, 137, 211, 2, 209, 254, 139, 253, 47, 2, 72, 253, 184, 3, 189, 137, 0, 2, 0, 0, 254, 139, 2, 209, 3, 139, 0, 5, 0, 11, 0, 66, 179, 6, 14, 11, 4, 43, 179, 3, 12, 0, 4, 43, 176, 11, 16, 176, 1, 208, 176, 6, 16, 177, 8, 12, 244, 0, 176, 0, 69, 88, 176, 4, 47, 27, 177, 4, 17, 62, 89, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 17, 62, 89, 179, 3, 7, 0, 4, 43, 179, 6, 5, 9, 4, 43, 48, 49, 1, 33, 53, 33, 17, 35, 3, 17, 35, 17, 35, 53, 2, 72, 253, 184, 2, 209, 137, 236, 137, 211, 3, 2, 137, 251, 0, 3, 140, 252, 116, 3, 2, 138, 0, 1, 1, 141, 1, 141, 4, 94, 6, 139, 0, 11, 0, 52, 179, 5, 8, 2, 4, 43, 179, 9, 12, 0, 4, 43, 176, 0, 16, 177, 11, 14, 244, 176, 6, 208, 176, 9, 16, 176, 13, 220, 0, 176, 3, 47, 179, 9, 5, 0, 4, 43, 179, 5, 7, 2, 4, 43, 176, 2, 16, 176, 7, 208, 48, 49, 1, 17, 33, 17, 51, 17, 33, 21, 35, 21, 51, 21, 3, 2, 254, 139, 138, 2, 71, 211, 211, 1, 141, 1, 117, 3, 137, 253, 0, 137, 233, 140, 0, 1, 0, 211, 2, 72, 4, 94, 6, 139, 0, 11, 0, 53, 176, 12, 47, 176, 13, 47, 176, 9, 220, 177, 0, 12, 244, 176, 12, 16, 176, 2, 208, 176, 2, 47, 177, 5, 12, 244, 176, 0, 16, 176, 6, 208, 0, 176, 3, 47, 176, 7, 47, 179, 9, 5, 0, 4, 43, 179, 6, 5, 1, 4, 43, 48, 49, 1, 17, 33, 17, 51, 17, 51, 17, 51, 17, 33, 21, 2, 72, 254, 139, 137, 236, 137, 1, 141, 2, 72, 1, 116, 2, 207, 253, 187, 2, 69, 252, 72, 139, 0, 0, 2, 0, 211, 1, 141, 4, 94, 6, 139, 0, 5, 0, 11, 0, 50, 176, 12, 47, 176, 13, 47, 176, 12, 16, 176, 0, 208, 176, 0, 47, 177, 3, 12, 244, 176, 13, 16, 176, 9, 220, 177, 6, 12, 244, 0, 176, 1, 47, 176, 7, 47, 179, 3, 5, 0, 4, 43, 179, 9, 7, 6, 4, 43, 48, 49, 19, 17, 51, 17, 33, 21, 1, 17, 51, 17, 33, 21, 211, 137, 3, 2, 253, 234, 137, 1, 141, 1, 141, 4, 254, 251, 140, 138, 1, 117, 3, 137, 253, 0, 137, 0, 0, 1, 0, 0, 1, 141, 2, 23, 6, 139, 0, 11, 0, 46, 179, 8, 8, 2, 4, 43, 179, 7, 8, 4, 4, 43, 176, 8, 16, 177, 0, 12, 244, 176, 2, 16, 176, 10, 208, 0, 176, 9, 47, 176, 5, 47, 179, 3, 7, 2, 4, 43, 176, 2, 16, 176, 7, 208, 48, 49, 19, 53, 35, 53, 33, 17, 51, 17, 33, 17, 35, 53, 25, 25, 1, 141, 138, 254, 139, 162, 2, 25, 233, 137, 3, 0, 252, 119, 254, 139, 140, 0, 0, 1, 0, 0, 2, 72, 2, 209, 6, 139, 0, 11, 0, 53, 176, 12, 47, 176, 13, 47, 176, 12, 16, 176, 2, 208, 176, 2, 47, 177, 11, 12, 244, 176, 4, 208, 176, 13, 16, 176, 9, 220, 177, 6, 12, 244, 0, 176, 3, 47, 176, 7, 47, 179, 1, 7, 0, 4, 43, 179, 6, 5, 9, 4, 43, 48, 49, 17, 53, 51, 17, 51, 17, 51, 17, 51, 17, 33, 17, 211, 137, 236, 137, 254, 139, 2, 72, 137, 3, 186, 253, 187, 2, 69, 253, 49, 254, 140, 0, 2, 0, 0, 1, 141, 2, 209, 6, 139, 0, 5, 0, 11, 0, 46, 179, 5, 14, 0, 4, 43, 179, 9, 12, 6, 4, 43, 176, 5, 16, 177, 2, 12, 244, 176, 0, 16, 176, 10, 208, 0, 176, 3, 47, 176, 7, 47, 179, 6, 5, 9, 4, 43, 179, 1, 7, 0, 4, 43, 48, 49, 17, 53, 51, 17, 51, 17, 23, 17, 51, 17, 33, 53, 211, 137, 236, 137, 253, 47, 3, 2, 137, 3, 0, 252, 119, 235, 4, 116, 251, 2, 138, 0, 0, 2, 1, 141, 254, 139, 4, 94, 6, 139, 0, 5, 0, 11, 0, 49, 179, 3, 8, 0, 4, 43, 176, 3, 16, 176, 8, 208, 176, 0, 16, 176, 10, 208, 0, 176, 1, 47, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 17, 62, 89, 179, 6, 5, 7, 4, 43, 179, 3, 7, 0, 4, 43, 48, 49, 1, 17, 51, 17, 33, 29, 2, 33, 17, 35, 17, 1, 141, 138, 2, 71, 253, 185, 138, 3, 2, 3, 137, 253, 0, 137, 235, 138, 252, 254, 3, 140, 0, 0, 2, 0, 211, 254, 139, 4, 94, 6, 139, 0, 3, 0, 11, 0, 76, 176, 12, 47, 176, 13, 47, 176, 12, 16, 176, 1, 208, 176, 1, 47, 177, 0, 12, 244, 176, 13, 16, 176, 5, 220, 177, 4, 12, 244, 176, 5, 16, 176, 9, 208, 0, 176, 2, 47, 176, 4, 47, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 17, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 17, 62, 89, 179, 7, 7, 8, 4, 43, 48, 49, 1, 35, 17, 59, 2, 17, 33, 21, 33, 17, 35, 1, 92, 137, 137, 236, 137, 1, 141, 254, 115, 137, 254, 139, 8, 0, 252, 70, 137, 252, 67, 0, 0, 3, 0, 211, 254, 139, 4, 94, 6, 139, 0, 3, 0, 9, 0, 15, 0, 88, 176, 16, 47, 176, 17, 47, 176, 16, 16, 176, 1, 208, 176, 1, 47, 177, 0, 12, 244, 176, 17, 16, 176, 7, 220, 177, 4, 12, 244, 176, 7, 16, 176, 12, 208, 176, 4, 16, 176, 14, 208, 0, 176, 2, 47, 176, 5, 47, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 17, 62, 89, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 17, 62, 89, 179, 10, 5, 11, 4, 43, 179, 7, 7, 4, 4, 43, 48, 49, 1, 35, 17, 51, 19, 17, 51, 17, 33, 29, 2, 33, 17, 35, 17, 1, 92, 137, 137, 236, 137, 1, 141, 254, 115, 137, 254, 139, 8, 0, 252, 119, 3, 137, 253, 0, 137, 235, 138, 252, 254, 3, 140, 0, 0, 2, 0, 0, 254, 139, 2, 23, 6, 139, 0, 5, 0, 11, 0, 49, 179, 5, 8, 2, 4, 43, 176, 5, 16, 176, 6, 208, 176, 2, 16, 176, 8, 208, 0, 176, 3, 47, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 17, 62, 89, 179, 6, 5, 9, 4, 43, 179, 1, 7, 0, 4, 43, 48, 49, 17, 53, 33, 17, 51, 17, 21, 17, 35, 17, 33, 53, 1, 141, 138, 138, 254, 115, 3, 2, 137, 3, 0, 252, 119, 235, 252, 116, 3, 2, 138, 0, 2, 0, 0, 254, 139, 2, 209, 6, 139, 0, 7, 0, 11, 0, 76, 176, 12, 47, 176, 13, 47, 176, 12, 16, 176, 1, 208, 176, 1, 47, 177, 0, 12, 244, 176, 1, 16, 176, 5, 208, 176, 13, 16, 176, 9, 220, 177, 8, 12, 244, 0, 176, 6, 47, 176, 8, 47, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 17, 62, 89, 176, 0, 69, 88, 176, 10, 47, 27, 177, 10, 17, 62, 89, 179, 5, 7, 2, 4, 43, 48, 49, 1, 35, 17, 35, 53, 51, 17, 59, 2, 17, 35, 1, 92, 137, 211, 211, 137, 236, 137, 137, 254, 139, 3, 189, 137, 3, 186, 248, 0, 0, 0, 3, 0, 0, 254, 139, 2, 209, 6, 139, 0, 5, 0, 11, 0, 15, 0, 84, 179, 5, 14, 0, 4, 43, 179, 13, 12, 12, 4, 43, 176, 5, 16, 177, 2, 12, 244, 176, 5, 16, 176, 6, 208, 176, 2, 16, 176, 8, 208, 176, 0, 16, 176, 10, 208, 0, 176, 3, 47, 176, 12, 47, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 17, 62, 89, 176, 0, 69, 88, 176, 14, 47, 27, 177, 14, 17, 62, 89, 179, 6, 5, 9, 4, 43, 179, 1, 7, 0, 4, 43, 48, 49, 17, 53, 51, 17, 51, 17, 21, 17, 35, 17, 35, 53, 1, 51, 17, 35, 211, 137, 137, 211, 2, 72, 137, 137, 3, 2, 137, 3, 0, 252, 119, 235, 252, 116, 3, 2, 138, 4, 116, 248, 0, 0, 0, 2, 0, 0, 254, 139, 4, 94, 3, 139, 0, 7, 0, 11, 0, 40, 179, 5, 8, 6, 4, 43, 0, 176, 0, 69, 88, 176, 5, 47, 27, 177, 5, 17, 62, 89, 179, 8, 7, 9, 4, 43, 179, 1, 5, 0, 4, 43, 176, 0, 16, 176, 3, 208, 48, 49, 17, 53, 33, 21, 33, 17, 35, 17, 1, 21, 33, 53, 4, 94, 253, 185, 138, 2, 209, 251, 162, 1, 141, 138, 138, 252, 254, 3, 2, 1, 254, 137, 137, 0, 0, 2, 0, 0, 254, 139, 4, 94, 2, 209, 0, 5, 0, 11, 0, 76, 176, 12, 47, 176, 13, 47, 176, 12, 16, 176, 2, 208, 176, 2, 47, 177, 1, 12, 244, 176, 13, 16, 176, 9, 220, 177, 10, 12, 244, 0, 176, 0, 69, 88, 176, 1, 47, 27, 177, 1, 17, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 17, 62, 89, 179, 0, 7, 3, 4, 43, 176, 0, 16, 176, 6, 208, 176, 3, 16, 176, 7, 208, 48, 49, 1, 17, 35, 17, 35, 53, 33, 21, 33, 17, 35, 17, 1, 92, 137, 211, 4, 94, 254, 115, 137, 2, 209, 251, 186, 3, 189, 137, 137, 252, 67, 4, 70, 0, 0, 3, 0, 0, 254, 139, 4, 94, 3, 139, 0, 5, 0, 9, 0, 15, 0, 78, 179, 0, 14, 5, 4, 43, 179, 13, 12, 14, 4, 43, 176, 0, 16, 177, 2, 12, 244, 176, 5, 16, 176, 8, 208, 0, 176, 0, 69, 88, 176, 1, 47, 27, 177, 1, 17, 62, 89, 176, 0, 69, 88, 176, 13, 47, 27, 177, 13, 17, 62, 89, 179, 6, 7, 7, 4, 43, 179, 0, 5, 3, 4, 43, 176, 0, 16, 176, 10, 208, 176, 3, 16, 176, 11, 208, 48, 49, 1, 17, 35, 17, 35, 53, 1, 21, 33, 53, 1, 21, 33, 17, 35, 17, 1, 92, 137, 211, 4, 94, 251, 162, 4, 94, 254, 115, 137, 2, 23, 252, 116, 3, 2, 138, 1, 116, 137, 137, 254, 140, 138, 252, 254, 3, 140, 0, 0, 2, 0, 0, 1, 141, 4, 94, 6, 139, 0, 7, 0, 11, 0, 30, 179, 5, 8, 2, 4, 43, 0, 176, 3, 47, 179, 8, 5, 9, 4, 43, 179, 1, 7, 0, 4, 43, 176, 1, 16, 176, 5, 208, 48, 49, 17, 53, 33, 17, 51, 17, 33, 29, 2, 33, 53, 1, 141, 138, 2, 71, 251, 162, 3, 2, 137, 3, 0, 253, 0, 137, 235, 138, 138, 0, 0, 2, 0, 0, 2, 72, 4, 94, 6, 139, 0, 5, 0, 11, 0, 56, 176, 12, 47, 176, 13, 47, 176, 12, 16, 176, 2, 208, 176, 2, 47, 177, 5, 12, 244, 176, 13, 16, 176, 9, 220, 177, 6, 12, 244, 0, 176, 3, 47, 176, 7, 47, 179, 1, 7, 0, 4, 43, 176, 0, 16, 176, 6, 208, 176, 1, 16, 176, 9, 208, 48, 49, 17, 53, 51, 17, 51, 17, 51, 17, 51, 17, 33, 21, 211, 137, 236, 137, 1, 141, 2, 72, 137, 3, 186, 251, 189, 4, 67, 252, 70, 137, 0, 3, 0, 0, 1, 141, 4, 94, 6, 139, 0, 5, 0, 11, 0, 15, 0, 58, 179, 5, 14, 0, 4, 43, 179, 9, 12, 6, 4, 43, 176, 5, 16, 177, 2, 12, 244, 176, 0, 16, 176, 14, 208, 0, 176, 3, 47, 176, 7, 47, 179, 12, 5, 13, 4, 43, 179, 1, 7, 0, 4, 43, 176, 0, 16, 176, 6, 208, 176, 1, 16, 176, 9, 208, 48, 49, 17, 53, 51, 17, 51, 17, 51, 17, 51, 17, 33, 29, 2, 33, 53, 211, 137, 236, 137, 1, 141, 251, 162, 3, 2, 137, 3, 0, 252, 119, 3, 137, 253, 0, 137, 235, 138, 138, 0, 2, 0, 0, 254, 139, 4, 94, 6, 139, 0, 7, 0, 15, 0, 61, 179, 5, 8, 2, 4, 43, 176, 5, 16, 176, 10, 208, 176, 2, 16, 176, 12, 208, 0, 176, 3, 47, 176, 0, 69, 88, 176, 11, 47, 27, 177, 11, 17, 62, 89, 179, 8, 5, 9, 4, 43, 179, 1, 7, 0, 4, 43, 176, 1, 16, 176, 5, 208, 176, 9, 16, 176, 13, 208, 48, 49, 17, 53, 33, 17, 51, 17, 33, 29, 2, 33, 17, 35, 17, 33, 53, 1, 141, 138, 2, 71, 253, 185, 138, 254, 115, 3, 2, 137, 3, 0, 253, 0, 137, 235, 138, 252, 254, 3, 2, 138, 0, 0, 2, 0, 0, 254, 139, 4, 94, 6, 139, 0, 7, 0, 15, 0, 91, 176, 16, 47, 176, 17, 47, 176, 3, 220, 177, 4, 12, 244, 176, 3, 16, 176, 6, 208, 176, 16, 16, 176, 10, 208, 176, 10, 47, 177, 9, 12, 244, 176, 10, 16, 176, 14, 208, 0, 176, 5, 47, 176, 8, 47, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 17, 62, 89, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 17, 62, 89, 179, 0, 7, 1, 4, 43, 176, 1, 16, 176, 11, 208, 176, 0, 16, 176, 13, 208, 48, 49, 1, 21, 33, 17, 35, 17, 51, 17, 1, 17, 35, 17, 35, 53, 51, 17, 4, 94, 254, 115, 137, 137, 254, 139, 137, 211, 211, 2, 209, 137, 252, 67, 8, 0, 252, 70, 3, 186, 248, 0, 3, 189, 137, 3, 186, 0, 4, 0, 0, 254, 139, 4, 94, 6, 139, 0, 5, 0, 11, 0, 17, 0, 23, 0, 120, 179, 5, 14, 0, 4, 43, 179, 15, 12, 12, 4, 43, 176, 5, 16, 177, 2, 12, 244, 176, 5, 16, 176, 6, 208, 176, 2, 16, 176, 8, 208, 176, 0, 16, 176, 10, 208, 176, 15, 16, 176, 20, 208, 176, 12, 16, 176, 22, 208, 0, 176, 3, 47, 176, 13, 47, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 17, 62, 89, 176, 0, 69, 88, 176, 21, 47, 27, 177, 21, 17, 62, 89, 179, 6, 5, 9, 4, 43, 179, 1, 7, 0, 4, 43, 176, 0, 16, 176, 12, 208, 176, 1, 16, 176, 15, 208, 176, 6, 16, 176, 18, 208, 176, 9, 16, 176, 19, 208, 48, 49, 17, 53, 51, 17, 51, 17, 21, 17, 35, 17, 35, 53, 37, 17, 51, 17, 33, 29, 2, 33, 17, 35, 17, 211, 137, 137, 211, 2, 70, 137, 1, 143, 254, 113, 137, 3, 2, 137, 3, 0, 252, 119, 235, 252, 116, 3, 2, 138, 235, 3, 137, 253, 0, 137, 235, 138, 252, 254, 3, 140, 0, 1, 255, 238, 255, 238, 3, 182, 3, 184, 0, 3, 0, 29, 0, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 19, 62, 89, 176, 0, 69, 88, 176, 1, 47, 27, 177, 1, 15, 62, 89, 48, 49, 9, 3, 3, 182, 254, 29, 254, 27, 1, 229, 1, 211, 254, 27, 1, 229, 1, 229, 0, 0, 1, 0, 8, 255, 207, 4, 86, 2, 236, 0, 5, 0, 9, 0, 176, 5, 47, 176, 1, 47, 48, 49, 9, 2, 55, 1, 1, 4, 86, 252, 252, 254, 182, 94, 1, 2, 2, 164, 2, 154, 253, 53, 1, 254, 59, 254, 113, 2, 115, 0, 2, 255, 242, 0, 0, 3, 180, 3, 170, 0, 8, 0, 15, 0, 83, 176, 16, 47, 176, 17, 47, 176, 3, 220, 176, 16, 16, 176, 4, 208, 176, 4, 47, 177, 13, 9, 244, 176, 3, 16, 177, 14, 9, 244, 0, 176, 0, 69, 88, 176, 8, 47, 27, 177, 8, 19, 62, 89, 176, 0, 69, 88, 176, 3, 47, 27, 177, 3, 15, 62, 89, 179, 9, 2, 2, 4, 43, 176, 2, 16, 176, 5, 208, 176, 9, 16, 176, 11, 208, 176, 3, 16, 177, 13, 1, 244, 48, 49, 1, 21, 35, 17, 33, 17, 35, 53, 9, 3, 51, 17, 33, 17, 3, 180, 235, 254, 16, 231, 1, 225, 1, 96, 254, 160, 254, 158, 217, 1, 16, 1, 199, 107, 254, 164, 1, 92, 107, 1, 227, 254, 0, 1, 98, 254, 158, 254, 197, 1, 59, 0, 2, 255, 242, 0, 0, 3, 180, 3, 170, 0, 8, 0, 12, 0, 29, 0, 176, 0, 69, 88, 176, 7, 47, 27, 177, 7, 19, 62, 89, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 15, 62, 89, 48, 49, 1, 35, 17, 33, 17, 35, 53, 1, 1, 5, 17, 33, 17, 3, 180, 235, 254, 16, 231, 1, 225, 1, 225, 254, 164, 254, 244, 1, 92, 254, 164, 1, 92, 107, 1, 227, 254, 29, 31, 1, 12, 254, 244, 0, 3, 0, 0, 255, 217, 4, 20, 3, 129, 0, 12, 0, 16, 0, 20, 0, 48, 179, 0, 9, 8, 4, 43, 0, 176, 3, 47, 179, 12, 1, 9, 4, 43, 179, 8, 1, 0, 4, 43, 176, 9, 16, 176, 13, 208, 176, 12, 16, 176, 15, 208, 176, 0, 16, 176, 17, 208, 176, 8, 16, 176, 19, 208, 48, 49, 37, 33, 23, 7, 1, 1, 23, 7, 33, 17, 35, 53, 33, 5, 33, 53, 33, 3, 35, 53, 51, 4, 20, 254, 23, 190, 79, 254, 188, 1, 68, 79, 190, 1, 121, 187, 1, 43, 253, 95, 254, 141, 1, 115, 185, 186, 186, 229, 192, 76, 1, 66, 1, 69, 78, 190, 1, 192, 109, 109, 109, 253, 100, 111, 0, 4, 0, 72, 0, 0, 4, 20, 5, 20, 0, 4, 0, 7, 0, 13, 0, 25, 0, 103, 179, 13, 9, 1, 4, 43, 179, 16, 9, 17, 4, 43, 179, 7, 10, 10, 4, 43, 179, 0, 9, 8, 4, 43, 176, 17, 16, 176, 21, 208, 176, 16, 16, 176, 23, 208, 0, 176, 0, 69, 88, 176, 2, 47, 27, 177, 2, 21, 62, 89, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 179, 25, 1, 14, 4, 43, 179, 5, 2, 9, 4, 43, 176, 0, 16, 177, 8, 1, 244, 176, 2, 16, 177, 11, 1, 244, 176, 14, 16, 176, 18, 208, 176, 25, 16, 176, 20, 208, 48, 49, 33, 33, 17, 33, 1, 35, 39, 21, 1, 17, 33, 17, 33, 17, 1, 35, 21, 35, 53, 35, 53, 51, 53, 51, 21, 51, 4, 20, 252, 52, 2, 55, 1, 149, 157, 248, 1, 37, 254, 129, 254, 145, 2, 0, 178, 108, 179, 179, 108, 178, 5, 20, 254, 109, 250, 250, 252, 238, 2, 184, 1, 127, 251, 201, 1, 43, 177, 177, 110, 178, 178, 0, 2, 0, 74, 255, 211, 4, 94, 3, 209, 0, 8, 0, 12, 0, 34, 179, 9, 9, 10, 4, 43, 0, 176, 3, 47, 176, 5, 47, 176, 0, 69, 88, 176, 9, 47, 27, 177, 9, 15, 62, 89, 179, 8, 1, 0, 4, 43, 48, 49, 1, 33, 1, 7, 1, 1, 23, 1, 33, 1, 35, 17, 51, 4, 94, 253, 209, 1, 121, 78, 254, 0, 2, 0, 78, 254, 135, 2, 47, 252, 90, 110, 110, 1, 154, 254, 135, 78, 2, 0, 1, 254, 78, 254, 133, 253, 248, 3, 162, 0, 0, 1, 0, 10, 255, 217, 4, 123, 3, 125, 0, 21, 0, 24, 179, 3, 9, 21, 4, 43, 0, 176, 13, 47, 179, 1, 1, 2, 4, 43, 179, 9, 1, 15, 4, 43, 48, 49, 19, 33, 21, 33, 20, 30, 2, 51, 33, 39, 55, 1, 1, 39, 55, 33, 34, 46, 2, 53, 10, 2, 37, 254, 74, 69, 121, 160, 92, 1, 117, 191, 78, 1, 68, 254, 188, 78, 191, 254, 139, 117, 202, 150, 84, 3, 125, 111, 92, 160, 120, 70, 190, 78, 254, 187, 254, 190, 76, 192, 88, 152, 201, 112, 0, 3, 0, 74, 255, 217, 4, 92, 3, 129, 0, 3, 0, 7, 0, 20, 0, 48, 179, 17, 9, 12, 4, 43, 0, 176, 9, 47, 179, 3, 1, 0, 4, 43, 179, 7, 1, 4, 4, 43, 176, 4, 16, 176, 11, 208, 176, 3, 16, 176, 13, 208, 176, 0, 16, 176, 15, 208, 176, 7, 16, 176, 17, 208, 48, 49, 1, 33, 53, 33, 17, 35, 53, 51, 5, 1, 39, 55, 33, 17, 33, 21, 35, 17, 33, 39, 55, 4, 92, 254, 144, 1, 112, 184, 184, 254, 172, 254, 187, 78, 190, 254, 23, 1, 43, 189, 1, 123, 190, 78, 3, 20, 109, 253, 100, 111, 57, 254, 190, 76, 192, 2, 156, 109, 254, 64, 190, 78, 0, 2, 0, 0, 255, 211, 4, 20, 3, 209, 0, 3, 0, 12, 0, 34, 179, 0, 9, 1, 4, 43, 0, 176, 12, 47, 176, 5, 47, 176, 0, 69, 88, 176, 0, 47, 27, 177, 0, 15, 62, 89, 179, 10, 1, 7, 4, 43, 48, 49, 33, 35, 17, 51, 1, 1, 39, 1, 33, 53, 33, 1, 55, 4, 20, 110, 110, 254, 240, 254, 2, 80, 1, 123, 253, 207, 2, 49, 254, 133, 80, 3, 162, 254, 49, 254, 0, 78, 1, 121, 110, 1, 123, 78, 0, 3, 0, 2, 0, 4, 4, 104, 5, 68, 0, 36, 0, 72, 0, 84, 0, 193, 176, 85, 47, 176, 86, 47, 176, 85, 16, 176, 16, 208, 176, 16, 47, 176, 86, 16, 176, 33, 220, 177, 39, 10, 244, 180, 218, 39, 234, 39, 2, 93, 64, 27, 9, 39, 25, 39, 41, 39, 57, 39, 73, 39, 89, 39, 105, 39, 121, 39, 137, 39, 153, 39, 169, 39, 185, 39, 201, 39, 13, 93, 176, 33, 16, 176, 45, 208, 176, 45, 47, 176, 16, 16, 177, 57, 10, 244, 64, 27, 6, 57, 22, 57, 38, 57, 54, 57, 70, 57, 86, 57, 102, 57, 118, 57, 134, 57, 150, 57, 166, 57, 182, 57, 198, 57, 13, 93, 180, 213, 57, 229, 57, 2, 93, 176, 33, 16, 176, 71, 208, 176, 71, 47, 0, 176, 82, 47, 176, 0, 69, 88, 176, 47, 47, 27, 177, 47, 19, 62, 89, 176, 0, 69, 88, 176, 53, 47, 27, 177, 53, 19, 62, 89, 179, 69, 2, 12, 4, 43, 176, 12, 16, 176, 4, 208, 176, 4, 47, 176, 53, 16, 177, 29, 2, 244, 176, 20, 208, 176, 20, 47, 176, 69, 16, 176, 61, 208, 176, 61, 47, 48, 49, 1, 6, 7, 6, 35, 34, 39, 38, 35, 34, 7, 6, 35, 34, 39, 38, 53, 52, 55, 54, 51, 50, 23, 22, 22, 51, 50, 55, 54, 51, 50, 23, 6, 21, 20, 23, 22, 7, 38, 53, 52, 55, 54, 54, 55, 55, 38, 35, 34, 7, 7, 39, 38, 35, 34, 7, 6, 21, 20, 23, 22, 51, 50, 55, 54, 51, 50, 23, 22, 51, 50, 55, 54, 3, 20, 7, 6, 7, 6, 6, 7, 18, 37, 22, 22, 4, 104, 36, 78, 99, 94, 45, 71, 74, 45, 41, 72, 74, 34, 123, 119, 121, 78, 90, 154, 57, 86, 43, 55, 13, 34, 86, 86, 50, 147, 109, 146, 49, 51, 38, 154, 49, 4, 10, 7, 36, 32, 92, 17, 94, 145, 136, 104, 14, 115, 62, 51, 107, 92, 70, 20, 49, 92, 60, 63, 90, 56, 26, 51, 78, 15, 142, 55, 53, 76, 12, 43, 29, 2, 1, 6, 2, 2, 1, 111, 117, 109, 135, 27, 26, 26, 29, 209, 211, 197, 165, 115, 137, 24, 13, 10, 25, 28, 133, 123, 139, 90, 80, 86, 65, 118, 203, 103, 90, 4, 14, 10, 39, 41, 20, 33, 29, 18, 108, 91, 124, 179, 182, 162, 19, 35, 31, 21, 117, 25, 4, 49, 86, 82, 88, 25, 4, 4, 4, 1, 10, 60, 9, 14, 0, 1, 255, 236, 0, 0, 3, 188, 5, 47, 0, 45, 0, 199, 179, 23, 12, 36, 4, 43, 179, 0, 12, 13, 4, 43, 180, 218, 13, 234, 13, 2, 93, 64, 27, 9, 13, 25, 13, 41, 13, 57, 13, 73, 13, 89, 13, 105, 13, 121, 13, 137, 13, 153, 13, 169, 13, 185, 13, 201, 13, 13, 93, 64, 15, 102, 23, 118, 23, 134, 23, 150, 23, 166, 23, 182, 23, 198, 23, 7, 93, 64, 13, 6, 23, 22, 23, 38, 23, 54, 23, 70, 23, 86, 23, 6, 93, 180, 213, 23, 229, 23, 2, 93, 176, 36, 16, 177, 28, 14, 244, 0, 176, 0, 69, 88, 176, 41, 47, 27, 177, 41, 21, 62, 89, 176, 0, 69, 88, 176, 6, 47, 27, 177, 6, 15, 62, 89, 176, 0, 69, 88, 176, 29, 47, 27, 177, 29, 15, 62, 89, 176, 6, 16, 177, 4, 6, 244, 176, 41, 16, 177, 18, 1, 244, 180, 217, 18, 233, 18, 2, 93, 64, 27, 8, 18, 24, 18, 40, 18, 56, 18, 72, 18, 88, 18, 104, 18, 120, 18, 136, 18, 152, 18, 168, 18, 184, 18, 200, 18, 13, 93, 176, 4, 16, 176, 31, 208, 176, 32, 208, 48, 49, 1, 20, 2, 7, 21, 51, 21, 33, 17, 62, 3, 53, 52, 46, 2, 35, 34, 14, 2, 21, 20, 30, 2, 23, 17, 33, 53, 51, 53, 38, 2, 53, 52, 62, 2, 51, 50, 30, 2, 3, 188, 110, 125, 211, 254, 164, 67, 90, 56, 22, 39, 86, 133, 94, 90, 133, 86, 41, 22, 54, 88, 67, 254, 164, 211, 121, 110, 63, 123, 182, 119, 119, 182, 125, 63, 2, 229, 145, 254, 240, 93, 114, 117, 1, 35, 26, 103, 123, 135, 63, 82, 168, 137, 86, 86, 137, 168, 82, 63, 135, 123, 103, 26, 254, 221, 117, 114, 86, 1, 19, 149, 113, 213, 162, 98, 98, 162, 213, 0, 0, 1, 0, 0, 2, 112, 0, 97, 0, 7, 0, 88, 0, 4, 0, 1, 0, 0, 0, 0, 0, 10, 0, 0, 2, 0, 2, 166, 0, 2, 0, 1, 0, 0, 0, 56, 0, 56, 0, 56, 0, 56, 0, 196, 1, 119, 2, 127, 3, 86, 3, 110, 3, 179, 3, 249, 4, 69, 4, 121, 4, 145, 4, 163, 4, 184, 4, 205, 5, 135, 5, 194, 6, 47, 6, 229, 7, 48, 7, 194, 8, 126, 8, 198, 9, 194, 10, 130, 10, 172, 10, 214, 10, 238, 11, 10, 11, 35, 11, 157, 12, 188, 12, 239, 13, 110, 14, 23, 14, 119, 14, 174, 14, 223, 15, 135, 15, 206, 16, 2, 16, 72, 16, 135, 16, 170, 16, 251, 17, 66, 17, 237, 18, 74, 19, 32, 19, 145, 20, 86, 20, 169, 21, 9, 21, 55, 21, 129, 21, 238, 22, 71, 22, 142, 22, 184, 22, 203, 22, 246, 23, 25, 23, 43, 23, 62, 24, 3, 24, 177, 25, 87, 26, 4, 26, 119, 26, 239, 27, 179, 28, 27, 28, 101, 28, 171, 28, 238, 29, 36, 29, 194, 30, 42, 30, 213, 31, 131, 32, 51, 32, 155, 33, 84, 33, 194, 34, 42, 34, 88, 34, 162, 35, 11, 35, 67, 35, 139, 35, 228, 35, 248, 36, 81, 36, 134, 36, 146, 37, 6, 37, 189, 37, 201, 37, 213, 37, 225, 37, 237, 37, 248, 38, 3, 38, 14, 38, 25, 38, 36, 38, 47, 38, 233, 38, 244, 38, 255, 39, 10, 39, 21, 39, 32, 39, 43, 39, 54, 39, 65, 39, 76, 39, 87, 39, 98, 39, 109, 39, 120, 39, 131, 39, 142, 39, 153, 39, 164, 39, 175, 39, 210, 40, 73, 40, 203, 41, 77, 42, 12, 42, 54, 42, 168, 43, 124, 44, 53, 44, 251, 45, 89, 45, 109, 45, 152, 45, 221, 46, 46, 47, 11, 47, 128, 47, 182, 47, 215, 47, 249, 48, 93, 48, 207, 49, 106, 49, 173, 49, 240, 50, 102, 50, 164, 51, 89, 51, 241, 52, 151, 53, 142, 54, 87, 54, 210, 55, 5, 55, 28, 55, 63, 55, 188, 55, 248, 56, 30, 56, 68, 56, 105, 56, 161, 56, 161, 56, 173, 56, 185, 56, 197, 57, 87, 58, 23, 58, 40, 58, 58, 58, 156, 58, 248, 59, 45, 59, 92, 59, 144, 59, 184, 59, 195, 59, 207, 59, 233, 60, 129, 60, 152, 60, 175, 61, 58, 61, 190, 62, 7, 62, 24, 62, 79, 62, 178, 63, 229, 63, 241, 63, 253, 64, 9, 64, 21, 64, 33, 64, 45, 64, 57, 64, 69, 64, 81, 64, 93, 64, 105, 64, 192, 64, 204, 64, 216, 64, 228, 64, 240, 65, 38, 65, 62, 65, 103, 65, 121, 65, 150, 65, 175, 65, 252, 66, 33, 66, 62, 66, 113, 66, 138, 66, 173, 66, 212, 66, 236, 67, 128, 67, 160, 67, 178, 68, 13, 68, 135, 68, 184, 69, 77, 69, 220, 70, 182, 71, 43, 71, 84, 71, 96, 71, 188, 72, 104, 72, 115, 73, 29, 73, 41, 73, 52, 73, 64, 73, 75, 73, 183, 74, 144, 74, 156, 74, 167, 74, 179, 74, 190, 74, 202, 74, 213, 74, 225, 74, 236, 74, 248, 75, 166, 75, 174, 76, 115, 76, 127, 76, 138, 76, 150, 76, 161, 76, 173, 76, 184, 77, 31, 77, 197, 77, 209, 77, 220, 77, 232, 77, 243, 77, 255, 78, 10, 78, 22, 78, 33, 78, 44, 79, 6, 79, 18, 79, 30, 79, 146, 80, 19, 80, 31, 80, 42, 80, 54, 80, 65, 80, 77, 80, 88, 80, 190, 81, 58, 81, 70, 81, 168, 82, 61, 82, 73, 82, 140, 82, 151, 82, 162, 82, 225, 82, 237, 82, 249, 83, 4, 83, 15, 83, 27, 83, 39, 83, 51, 83, 63, 83, 129, 83, 229, 83, 241, 83, 252, 84, 7, 84, 18, 84, 30, 84, 41, 84, 53, 84, 140, 85, 14, 85, 26, 85, 37, 85, 49, 85, 60, 85, 72, 85, 83, 85, 95, 85, 106, 85, 117, 85, 128, 85, 140, 85, 151, 85, 163, 85, 174, 85, 186, 85, 197, 86, 127, 87, 38, 87, 50, 87, 61, 87, 72, 87, 83, 87, 95, 87, 107, 87, 213, 88, 91, 88, 103, 88, 114, 88, 126, 88, 137, 88, 149, 88, 160, 88, 172, 88, 183, 88, 195, 88, 206, 89, 91, 89, 216, 89, 228, 89, 239, 89, 251, 90, 6, 90, 18, 90, 29, 90, 41, 90, 52, 90, 64, 90, 75, 90, 189, 90, 201, 90, 212, 90, 224, 90, 235, 90, 246, 91, 1, 91, 12, 91, 23, 91, 42, 91, 97, 91, 109, 91, 121, 91, 133, 91, 145, 91, 157, 91, 169, 91, 181, 91, 192, 91, 243, 92, 114, 92, 151, 92, 189, 92, 244, 93, 59, 93, 130, 94, 55, 94, 107, 94, 170, 94, 215, 95, 40, 95, 111, 95, 211, 96, 126, 96, 182, 97, 19, 97, 86, 97, 169, 98, 2, 98, 141, 98, 250, 99, 82, 99, 94, 99, 106, 99, 117, 99, 128, 99, 139, 99, 150, 99, 161, 100, 71, 101, 24, 101, 86, 102, 47, 102, 212, 103, 83, 103, 202, 104, 93, 104, 170, 104, 233, 105, 61, 105, 198, 105, 249, 106, 173, 107, 88, 107, 249, 108, 145, 109, 52, 109, 132, 109, 252, 110, 156, 110, 219, 111, 46, 111, 227, 111, 238, 111, 249, 112, 4, 112, 15, 112, 26, 112, 38, 112, 208, 112, 220, 113, 123, 114, 59, 114, 111, 114, 123, 114, 193, 115, 86, 115, 210, 116, 73, 116, 85, 116, 97, 116, 162, 116, 213, 117, 54, 117, 181, 117, 218, 118, 47, 118, 102, 118, 208, 119, 153, 119, 225, 119, 237, 120, 44, 120, 148, 120, 229, 121, 44, 121, 215, 122, 15, 122, 108, 123, 21, 123, 104, 123, 187, 124, 70, 124, 179, 124, 243, 125, 68, 125, 155, 125, 238, 126, 78, 126, 186, 127, 20, 127, 182, 128, 92, 128, 209, 129, 150, 130, 109, 131, 0, 131, 37, 131, 119, 131, 234, 132, 83, 132, 249, 133, 65, 133, 76, 133, 139, 133, 243, 134, 68, 134, 139, 135, 54, 135, 110, 136, 28, 136, 194, 137, 21, 137, 77, 138, 43, 138, 148, 138, 212, 139, 36, 139, 123, 139, 209, 140, 49, 140, 158, 140, 249, 141, 106, 142, 2, 142, 115, 142, 126, 143, 15, 143, 26, 143, 138, 144, 64, 144, 138, 144, 149, 144, 219, 145, 94, 145, 217, 146, 91, 146, 102, 146, 113, 146, 178, 146, 230, 147, 26, 147, 38, 147, 50, 147, 62, 147, 74, 147, 86, 147, 98, 147, 110, 147, 121, 147, 133, 147, 144, 147, 156, 147, 167, 147, 179, 147, 191, 147, 203, 147, 214, 147, 226, 147, 237, 147, 249, 148, 4, 148, 16, 148, 27, 148, 45, 148, 234, 148, 252, 149, 32, 150, 47, 150, 105, 150, 156, 150, 227, 151, 29, 151, 169, 151, 224, 152, 17, 152, 34, 152, 60, 152, 90, 152, 119, 152, 144, 152, 168, 152, 205, 152, 242, 153, 21, 153, 51, 153, 102, 153, 130, 153, 180, 153, 235, 154, 40, 154, 99, 154, 150, 154, 210, 155, 12, 155, 61, 155, 112, 155, 163, 155, 209, 156, 2, 156, 49, 156, 98, 156, 160, 156, 235, 157, 27, 157, 88, 157, 160, 157, 205, 158, 12, 158, 84, 158, 122, 158, 173, 158, 230, 159, 33, 159, 109, 159, 209, 159, 240, 160, 9, 160, 84, 160, 128, 160, 193, 161, 34, 161, 84, 161, 135, 161, 199, 161, 246, 162, 210, 163, 120, 0, 0, 0, 1, 0, 0, 0, 1, 0, 197, 254, 73, 160, 132, 95, 15, 60, 245, 0, 27, 8, 0, 0, 0, 0, 0, 198, 245, 69, 208, 0, 0, 0, 0, 213, 49, 9, 126, 255, 91, 254, 117, 4, 123, 7, 62, 0, 0, 0, 9, 0, 2, 0, 0, 0, 0, 0, 0, 4, 94, 0, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 236, 255, 231, 1, 117, 0, 188, 0, 229, 0, 35, 0, 0, 0, 240, 0, 0, 1, 117, 0, 41, 255, 223, 0, 0, 0, 10, 0, 27, 0, 0, 0, 4, 255, 248, 0, 49, 255, 248, 255, 233, 1, 117, 0, 240, 0, 199, 0, 0, 0, 143, 0, 168, 255, 223, 255, 197, 0, 49, 255, 236, 0, 49, 0, 49, 0, 49, 255, 236, 0, 49, 0, 186, 255, 254, 0, 49, 0, 49, 0, 49, 0, 49, 255, 223, 0, 49, 255, 223, 0, 49, 0, 25, 0, 0, 0, 49, 255, 197, 255, 193, 255, 233, 255, 236, 0, 49, 1, 117, 0, 133, 0, 186, 0, 2, 0, 0, 0, 229, 255, 254, 0, 49, 0, 0, 255, 254, 255, 252, 0, 186, 255, 254, 0, 49, 0, 186, 0, 4, 0, 49, 0, 186, 0, 0, 0, 49, 255, 236, 0, 49, 0, 0, 0, 0, 255, 246, 0, 0, 0, 49, 255, 225, 255, 229, 255, 236, 255, 225, 0, 47, 0, 186, 1, 141, 0, 186, 255, 252, 255, 197, 255, 197, 255, 236, 0, 49, 0, 49, 255, 223, 0, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 252, 255, 252, 255, 252, 255, 252, 0, 186, 0, 186, 0, 170, 0, 186, 0, 49, 255, 236, 255, 236, 255, 236, 255, 236, 255, 236, 0, 49, 0, 49, 0, 49, 0, 49, 0, 186, 0, 0, 0, 8, 0, 49, 0, 20, 0, 186, 0, 31, 0, 49, 0, 0, 0, 2, 0, 0, 0, 242, 0, 186, 0, 0, 255, 193, 255, 211, 255, 248, 0, 0, 0, 186, 0, 186, 0, 0, 0, 49, 255, 236, 0, 43, 0, 0, 0, 0, 0, 4, 255, 248, 255, 238, 255, 236, 255, 219, 255, 213, 0, 209, 2, 47, 0, 0, 0, 23, 0, 4, 255, 236, 255, 197, 0, 14, 0, 141, 0, 0, 0, 0, 255, 197, 255, 197, 255, 223, 255, 242, 255, 219, 0, 0, 255, 164, 0, 55, 0, 0, 1, 170, 0, 186, 0, 0, 255, 238, 255, 225, 255, 236, 0, 2, 0, 0, 0, 199, 1, 72, 0, 0, 0, 0, 0, 186, 1, 117, 2, 46, 0, 0, 255, 236, 255, 197, 0, 49, 255, 197, 0, 49, 0, 49, 0, 186, 0, 170, 0, 186, 0, 186, 255, 223, 255, 223, 0, 2, 255, 223, 0, 49, 0, 49, 0, 49, 0, 186, 0, 170, 0, 78, 0, 186, 0, 182, 1, 117, 0, 242, 0, 242, 0, 170, 2, 240, 0, 170, 1, 117, 0, 186, 1, 55, 255, 217, 1, 141, 0, 0, 0, 27, 255, 254, 0, 0, 0, 0, 0, 0, 255, 254, 255, 139, 0, 98, 255, 236, 0, 49, 255, 236, 255, 225, 0, 49, 255, 197, 0, 0, 255, 197, 0, 0, 255, 197, 255, 254, 255, 236, 0, 0, 255, 236, 0, 0, 255, 236, 0, 0, 255, 236, 0, 0, 0, 49, 0, 0, 255, 139, 255, 254, 0, 49, 255, 252, 0, 49, 255, 252, 0, 49, 255, 252, 0, 49, 255, 252, 0, 49, 255, 252, 255, 236, 255, 254, 255, 236, 255, 254, 255, 236, 255, 254, 255, 236, 255, 254, 0, 49, 0, 49, 255, 119, 255, 119, 0, 78, 0, 78, 0, 186, 0, 186, 0, 182, 0, 182, 0, 186, 0, 186, 0, 186, 0, 0, 0, 0, 255, 254, 0, 4, 0, 49, 0, 49, 0, 49, 0, 49, 0, 186, 0, 49, 0, 186, 0, 49, 0, 186, 0, 49, 0, 186, 255, 94, 0, 186, 0, 49, 0, 49, 0, 49, 0, 49, 0, 49, 0, 49, 0, 1, 0, 49, 0, 49, 255, 223, 255, 236, 255, 223, 255, 236, 255, 223, 255, 236, 0, 49, 0, 0, 0, 49, 0, 0, 0, 49, 0, 0, 0, 25, 255, 246, 0, 25, 255, 246, 0, 25, 255, 246, 0, 25, 255, 246, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 49, 0, 49, 0, 49, 0, 49, 0, 49, 0, 49, 0, 49, 0, 49, 0, 49, 0, 49, 0, 49, 0, 49, 255, 193, 255, 229, 255, 236, 255, 225, 0, 49, 0, 47, 0, 49, 0, 47, 0, 49, 0, 47, 0, 186, 255, 193, 255, 219, 255, 211, 255, 213, 0, 25, 255, 246, 0, 0, 0, 0, 1, 141, 0, 0, 255, 197, 255, 95, 255, 95, 0, 23, 255, 91, 255, 91, 255, 91, 0, 0, 255, 197, 0, 49, 0, 49, 255, 197, 0, 49, 0, 49, 0, 49, 255, 223, 0, 186, 0, 49, 255, 197, 0, 49, 0, 49, 0, 0, 255, 223, 0, 49, 0, 49, 0, 43, 0, 0, 255, 236, 255, 236, 255, 233, 0, 49, 0, 186, 255, 236, 0, 2, 0, 0, 0, 12, 0, 186, 0, 0, 0, 2, 0, 49, 0, 0, 0, 39, 0, 0, 0, 2, 0, 12, 0, 41, 0, 186, 0, 49, 255, 225, 0, 49, 0, 0, 0, 2, 255, 236, 0, 49, 0, 2, 255, 236, 0, 0, 0, 49, 255, 236, 255, 248, 0, 49, 255, 242, 0, 186, 0, 49, 255, 236, 0, 49, 255, 242, 0, 49, 255, 119, 0, 49, 255, 236, 0, 25, 0, 186, 0, 186, 255, 254, 255, 117, 0, 49, 255, 119, 0, 49, 255, 225, 0, 49, 255, 197, 0, 49, 0, 49, 0, 49, 0, 0, 0, 49, 255, 193, 0, 27, 0, 49, 0, 49, 0, 49, 255, 231, 0, 49, 0, 49, 255, 223, 0, 49, 0, 49, 255, 236, 0, 0, 255, 225, 255, 236, 255, 233, 0, 49, 0, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 49, 255, 248, 0, 49, 255, 244, 255, 254, 0, 0, 0, 49, 0, 49, 0, 0, 255, 252, 255, 240, 255, 254, 0, 49, 0, 49, 0, 49, 255, 231, 0, 49, 0, 49, 255, 236, 0, 49, 0, 49, 0, 0, 0, 0, 255, 225, 255, 227, 255, 236, 0, 49, 0, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 49, 0, 35, 0, 49, 255, 244, 255, 252, 255, 143, 0, 49, 0, 0, 255, 246, 0, 186, 0, 186, 0, 4, 255, 117, 0, 49, 255, 143, 0, 49, 255, 225, 0, 49, 0, 49, 0, 49, 0, 49, 0, 49, 0, 49, 255, 254, 0, 49, 0, 186, 0, 49, 0, 0, 0, 49, 0, 49, 0, 25, 255, 246, 0, 0, 0, 0, 255, 193, 255, 229, 255, 193, 255, 229, 255, 193, 255, 229, 255, 236, 255, 225, 0, 0, 0, 0, 0, 0, 255, 211, 0, 68, 255, 211, 0, 0, 0, 74, 0, 0, 0, 188, 255, 227, 0, 72, 0, 0, 1, 141, 1, 141, 0, 0, 1, 141, 0, 0, 1, 141, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 211, 1, 141, 0, 211, 0, 211, 0, 0, 0, 0, 0, 0, 1, 141, 0, 211, 0, 211, 0, 0, 0, 0, 0, 0, 1, 141, 0, 211, 0, 211, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 238, 0, 8, 255, 242, 255, 242, 0, 0, 0, 72, 0, 74, 0, 10, 0, 74, 0, 0, 0, 2, 255, 236, 0, 0, 0, 1, 0, 0, 6, 139, 254, 139, 0, 0, 4, 94, 255, 94, 255, 227, 4, 123, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 3, 4, 94, 1, 144, 0, 5, 0, 0, 5, 154, 5, 51, 0, 0, 1, 37, 5, 154, 5, 51, 0, 0, 3, 160, 0, 123, 1, 209, 5, 1, 2, 6, 6, 9, 3, 2, 2, 0, 5, 4, 160, 0, 2, 175, 112, 0, 169, 202, 0, 0, 0, 0, 0, 0, 0, 0, 109, 108, 115, 115, 0, 64, 0, 0, 251, 2, 6, 139, 254, 139, 0, 0, 6, 139, 1, 117, 32, 0, 0, 159, 0, 0, 0, 0, 3, 164, 5, 25, 0, 0, 0, 32, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 12, 0, 248, 8, 255, 0, 8, 0, 7, 255, 254, 0, 9, 0, 8, 255, 254, 0, 10, 0, 9, 255, 254, 0, 11, 0, 9, 255, 253, 0, 12, 0, 10, 255, 253, 0, 13, 0, 11, 255, 253, 0, 14, 0, 12, 255, 253, 0, 15, 0, 13, 255, 253, 0, 16, 0, 14, 255, 253, 0, 17, 0, 14, 255, 252, 0, 18, 0, 15, 255, 252, 0, 19, 0, 16, 255, 252, 0, 20, 0, 17, 255, 252, 0, 21, 0, 18, 255, 252, 0, 22, 0, 18, 255, 251, 0, 23, 0, 19, 255, 251, 0, 24, 0, 20, 255, 251, 0, 25, 0, 21, 255, 251, 0, 26, 0, 22, 255, 251, 0, 27, 0, 23, 255, 251, 0, 28, 0, 23, 255, 250, 0, 29, 0, 24, 255, 250, 0, 30, 0, 25, 255, 250, 0, 31, 0, 26, 255, 250, 0, 32, 0, 27, 255, 250, 0, 33, 0, 27, 255, 249, 0, 34, 0, 28, 255, 249, 0, 35, 0, 29, 255, 249, 0, 36, 0, 30, 255, 249, 0, 37, 0, 31, 255, 249, 0, 38, 0, 32, 255, 249, 0, 39, 0, 32, 255, 248, 0, 40, 0, 33, 255, 248, 0, 41, 0, 34, 255, 248, 0, 42, 0, 35, 255, 248, 0, 43, 0, 36, 255, 248, 0, 44, 0, 36, 255, 247, 0, 45, 0, 37, 255, 247, 0, 46, 0, 38, 255, 247, 0, 47, 0, 39, 255, 247, 0, 48, 0, 40, 255, 247, 0, 49, 0, 41, 255, 247, 0, 50, 0, 41, 255, 246, 0, 51, 0, 42, 255, 246, 0, 52, 0, 43, 255, 246, 0, 53, 0, 44, 255, 246, 0, 54, 0, 45, 255, 246, 0, 55, 0, 45, 255, 245, 0, 56, 0, 46, 255, 245, 0, 57, 0, 47, 255, 245, 0, 58, 0, 48, 255, 245, 0, 59, 0, 49, 255, 245, 0, 60, 0, 50, 255, 245, 0, 61, 0, 50, 255, 244, 0, 62, 0, 51, 255, 244, 0, 63, 0, 52, 255, 244, 0, 64, 0, 53, 255, 244, 0, 65, 0, 54, 255, 244, 0, 66, 0, 54, 255, 243, 0, 67, 0, 55, 255, 243, 0, 68, 0, 56, 255, 243, 0, 69, 0, 57, 255, 243, 0, 70, 0, 58, 255, 243, 0, 71, 0, 59, 255, 243, 0, 72, 0, 59, 255, 242, 0, 73, 0, 60, 255, 242, 0, 74, 0, 61, 255, 242, 0, 75, 0, 62, 255, 242, 0, 76, 0, 63, 255, 242, 0, 77, 0, 63, 255, 241, 0, 78, 0, 64, 255, 241, 0, 79, 0, 65, 255, 241, 0, 80, 0, 66, 255, 241, 0, 81, 0, 67, 255, 241, 0, 82, 0, 68, 255, 241, 0, 83, 0, 68, 255, 240, 0, 84, 0, 69, 255, 240, 0, 85, 0, 70, 255, 240, 0, 86, 0, 71, 255, 240, 0, 87, 0, 72, 255, 240, 0, 88, 0, 72, 255, 239, 0, 89, 0, 73, 255, 239, 0, 90, 0, 74, 255, 239, 0, 91, 0, 75, 255, 239, 0, 92, 0, 76, 255, 239, 0, 93, 0, 77, 255, 239, 0, 94, 0, 77, 255, 238, 0, 95, 0, 78, 255, 238, 0, 96, 0, 79, 255, 238, 0, 97, 0, 80, 255, 238, 0, 98, 0, 81, 255, 238, 0, 99, 0, 81, 255, 237, 0, 100, 0, 82, 255, 237, 0, 101, 0, 83, 255, 237, 0, 102, 0, 84, 255, 237, 0, 103, 0, 85, 255, 237, 0, 104, 0, 86, 255, 237, 0, 105, 0, 86, 255, 236, 0, 106, 0, 87, 255, 236, 0, 107, 0, 88, 255, 236, 0, 108, 0, 89, 255, 236, 0, 109, 0, 90, 255, 236, 0, 110, 0, 90, 255, 235, 0, 111, 0, 91, 255, 235, 0, 112, 0, 92, 255, 235, 0, 113, 0, 93, 255, 235, 0, 114, 0, 94, 255, 235, 0, 115, 0, 95, 255, 235, 0, 116, 0, 95, 255, 234, 0, 117, 0, 96, 255, 234, 0, 118, 0, 97, 255, 234, 0, 119, 0, 98, 255, 234, 0, 120, 0, 99, 255, 234, 0, 121, 0, 99, 255, 233, 0, 122, 0, 100, 255, 233, 0, 123, 0, 101, 255, 233, 0, 124, 0, 102, 255, 233, 0, 125, 0, 103, 255, 233, 0, 126, 0, 104, 255, 233, 0, 127, 0, 104, 255, 232, 0, 128, 0, 105, 255, 232, 0, 129, 0, 106, 255, 232, 0, 130, 0, 107, 255, 232, 0, 131, 0, 108, 255, 232, 0, 132, 0, 108, 255, 231, 0, 133, 0, 109, 255, 231, 0, 134, 0, 110, 255, 231, 0, 135, 0, 111, 255, 231, 0, 136, 0, 112, 255, 231, 0, 137, 0, 113, 255, 231, 0, 138, 0, 113, 255, 230, 0, 139, 0, 114, 255, 230, 0, 140, 0, 115, 255, 230, 0, 141, 0, 116, 255, 230, 0, 142, 0, 117, 255, 230, 0, 143, 0, 117, 255, 229, 0, 144, 0, 118, 255, 229, 0, 145, 0, 119, 255, 229, 0, 146, 0, 120, 255, 229, 0, 147, 0, 121, 255, 229, 0, 148, 0, 122, 255, 229, 0, 149, 0, 122, 255, 228, 0, 150, 0, 123, 255, 228, 0, 151, 0, 124, 255, 228, 0, 152, 0, 125, 255, 228, 0, 153, 0, 126, 255, 228, 0, 154, 0, 126, 255, 227, 0, 155, 0, 127, 255, 227, 0, 156, 0, 128, 255, 227, 0, 157, 0, 129, 255, 227, 0, 158, 0, 130, 255, 227, 0, 159, 0, 131, 255, 227, 0, 160, 0, 131, 255, 226, 0, 161, 0, 132, 255, 226, 0, 162, 0, 133, 255, 226, 0, 163, 0, 134, 255, 226, 0, 164, 0, 135, 255, 226, 0, 165, 0, 135, 255, 225, 0, 166, 0, 136, 255, 225, 0, 167, 0, 137, 255, 225, 0, 168, 0, 138, 255, 225, 0, 169, 0, 139, 255, 225, 0, 170, 0, 140, 255, 225, 0, 171, 0, 140, 255, 224, 0, 172, 0, 141, 255, 224, 0, 173, 0, 142, 255, 224, 0, 174, 0, 143, 255, 224, 0, 175, 0, 144, 255, 224, 0, 176, 0, 144, 255, 223, 0, 177, 0, 145, 255, 223, 0, 178, 0, 146, 255, 223, 0, 179, 0, 147, 255, 223, 0, 180, 0, 148, 255, 223, 0, 181, 0, 149, 255, 223, 0, 182, 0, 149, 255, 222, 0, 183, 0, 150, 255, 222, 0, 184, 0, 151, 255, 222, 0, 185, 0, 152, 255, 222, 0, 186, 0, 153, 255, 222, 0, 187, 0, 153, 255, 221, 0, 188, 0, 154, 255, 221, 0, 189, 0, 155, 255, 221, 0, 190, 0, 156, 255, 221, 0, 191, 0, 157, 255, 221, 0, 192, 0, 158, 255, 221, 0, 193, 0, 158, 255, 220, 0, 194, 0, 159, 255, 220, 0, 195, 0, 160, 255, 220, 0, 196, 0, 161, 255, 220, 0, 197, 0, 162, 255, 220, 0, 198, 0, 162, 255, 219, 0, 199, 0, 163, 255, 219, 0, 200, 0, 164, 255, 219, 0, 201, 0, 165, 255, 219, 0, 202, 0, 166, 255, 219, 0, 203, 0, 167, 255, 219, 0, 204, 0, 167, 255, 218, 0, 205, 0, 168, 255, 218, 0, 206, 0, 169, 255, 218, 0, 207, 0, 170, 255, 218, 0, 208, 0, 171, 255, 218, 0, 209, 0, 171, 255, 217, 0, 210, 0, 172, 255, 217, 0, 211, 0, 173, 255, 217, 0, 212, 0, 174, 255, 217, 0, 213, 0, 175, 255, 217, 0, 214, 0, 176, 255, 217, 0, 215, 0, 176, 255, 216, 0, 216, 0, 177, 255, 216, 0, 217, 0, 178, 255, 216, 0, 218, 0, 179, 255, 216, 0, 219, 0, 180, 255, 216, 0, 220, 0, 180, 255, 215, 0, 221, 0, 181, 255, 215, 0, 222, 0, 182, 255, 215, 0, 223, 0, 183, 255, 215, 0, 224, 0, 184, 255, 215, 0, 225, 0, 185, 255, 215, 0, 226, 0, 185, 255, 214, 0, 227, 0, 186, 255, 214, 0, 228, 0, 187, 255, 214, 0, 229, 0, 188, 255, 214, 0, 230, 0, 189, 255, 214, 0, 231, 0, 189, 255, 213, 0, 232, 0, 190, 255, 213, 0, 233, 0, 191, 255, 213, 0, 234, 0, 192, 255, 213, 0, 235, 0, 193, 255, 213, 0, 236, 0, 194, 255, 213, 0, 237, 0, 194, 255, 212, 0, 238, 0, 195, 255, 212, 0, 239, 0, 196, 255, 212, 0, 240, 0, 197, 255, 212, 0, 241, 0, 198, 255, 212, 0, 242, 0, 198, 255, 211, 0, 243, 0, 199, 255, 211, 0, 244, 0, 200, 255, 211, 0, 245, 0, 201, 255, 211, 0, 246, 0, 202, 255, 211, 0, 247, 0, 203, 255, 211, 0, 248, 0, 203, 255, 210, 0, 249, 0, 204, 255, 210, 0, 250, 0, 205, 255, 210, 0, 251, 0, 206, 255, 210, 0, 252, 0, 207, 255, 210, 0, 253, 0, 207, 255, 209, 0, 254, 0, 208, 255, 209, 0, 255, 0, 209, 255, 209, 0, 0, 0, 4, 0, 0, 2, 116, 10, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 11, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 12, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 13, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 20, 0, 3, 0, 1, 0, 0, 0, 20, 0, 4, 3, 206, 0, 0, 0, 178, 0, 128, 0, 6, 0, 50, 0, 0, 0, 13, 0, 34, 0, 126, 0, 255, 1, 48, 1, 49, 1, 81, 1, 83, 1, 119, 1, 120, 1, 127, 1, 146, 1, 255, 2, 27, 2, 199, 2, 221, 3, 134, 3, 138, 3, 140, 3, 161, 3, 168, 3, 169, 3, 191, 3, 192, 3, 206, 4, 12, 4, 79, 4, 92, 4, 95, 4, 145, 30, 3, 30, 11, 30, 31, 30, 65, 30, 87, 30, 97, 30, 107, 30, 133, 30, 243, 32, 21, 32, 26, 32, 30, 32, 34, 32, 38, 32, 48, 32, 58, 32, 68, 32, 172, 33, 22, 33, 34, 33, 38, 34, 2, 34, 6, 34, 15, 34, 18, 34, 26, 34, 30, 34, 43, 34, 72, 34, 96, 34, 101, 35, 3, 35, 24, 35, 38, 35, 125, 35, 136, 35, 206, 36, 35, 37, 0, 37, 2, 37, 12, 37, 16, 37, 20, 37, 24, 37, 28, 37, 36, 37, 44, 37, 52, 37, 60, 37, 108, 37, 198, 37, 202, 39, 19, 224, 7, 246, 195, 249, 0, 251, 2, 255, 255, 0, 0, 0, 0, 0, 13, 0, 32, 0, 35, 0, 160, 1, 0, 1, 49, 1, 50, 1, 82, 1, 84, 1, 120, 1, 121, 1, 146, 1, 252, 2, 24, 2, 198, 2, 216, 3, 132, 3, 136, 3, 140, 3, 142, 3, 163, 3, 169, 3, 170, 3, 192, 3, 193, 4, 1, 4, 14, 4, 81, 4, 94, 4, 144, 30, 2, 30, 10, 30, 30, 30, 64, 30, 86, 30, 96, 30, 106, 30, 128, 30, 242, 32, 19, 32, 24, 32, 28, 32, 32, 32, 38, 32, 48, 32, 57, 32, 68, 32, 172, 33, 22, 33, 34, 33, 38, 34, 2, 34, 6, 34, 15, 34, 17, 34, 26, 34, 30, 34, 43, 34, 72, 34, 96, 34, 100, 35, 3, 35, 24, 35, 36, 35, 125, 35, 136, 35, 206, 36, 35, 37, 0, 37, 2, 37, 12, 37, 16, 37, 20, 37, 24, 37, 28, 37, 36, 37, 44, 37, 52, 37, 60, 37, 80, 37, 198, 37, 202, 39, 19, 224, 0, 246, 195, 248, 255, 251, 1, 255, 255, 0, 1, 255, 245, 0, 0, 255, 225, 0, 0, 255, 243, 255, 164, 255, 242, 255, 92, 255, 240, 255, 65, 255, 239, 255, 18, 255, 115, 255, 91, 0, 0, 0, 0, 253, 243, 253, 242, 253, 241, 253, 240, 253, 239, 254, 198, 253, 238, 252, 217, 253, 237, 253, 187, 253, 186, 253, 185, 253, 184, 253, 136, 228, 24, 228, 18, 228, 0, 227, 224, 227, 204, 227, 196, 227, 188, 227, 168, 227, 60, 0, 0, 0, 0, 0, 0, 0, 0, 224, 131, 224, 148, 224, 131, 224, 118, 224, 15, 225, 27, 223, 104, 223, 119, 222, 148, 222, 160, 222, 137, 0, 0, 222, 137, 222, 114, 222, 111, 222, 93, 222, 45, 222, 46, 223, 48, 223, 28, 223, 17, 222, 187, 222, 177, 222, 108, 222, 24, 221, 60, 221, 59, 221, 50, 221, 47, 221, 44, 221, 41, 221, 38, 221, 31, 221, 24, 221, 17, 221, 10, 220, 247, 220, 158, 218, 237, 219, 82, 34, 102, 10, 31, 0, 0, 5, 189, 0, 1, 0, 0, 0, 0, 0, 174, 0, 0, 0, 176, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 90, 1, 92, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 56, 1, 60, 1, 64, 1, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 248, 0, 0, 0, 0, 0, 3, 0, 224, 0, 225, 0, 170, 0, 161, 0, 130, 0, 131, 0, 227, 0, 148, 0, 228, 0, 132, 0, 140, 0, 137, 0, 155, 0, 167, 0, 162, 0, 229, 0, 136, 0, 216, 0, 129, 0, 145, 0, 230, 0, 231, 0, 139, 0, 149, 0, 134, 0, 193, 0, 220, 0, 232, 0, 156, 0, 168, 0, 233, 0, 234, 0, 235, 0, 160, 0, 171, 0, 199, 0, 197, 0, 172, 0, 96, 0, 97, 0, 142, 0, 98, 0, 201, 0, 99, 0, 198, 0, 200, 0, 205, 0, 202, 0, 203, 0, 204, 0, 236, 0, 100, 0, 209, 0, 206, 0, 207, 0, 173, 0, 101, 0, 237, 0, 143, 0, 212, 0, 210, 0, 211, 0, 102, 0, 238, 0, 239, 0, 135, 0, 104, 0, 103, 0, 105, 0, 107, 0, 106, 0, 108, 0, 158, 0, 109, 0, 111, 0, 110, 0, 112, 0, 113, 0, 115, 0, 114, 0, 116, 0, 117, 0, 240, 0, 118, 0, 120, 0, 119, 0, 121, 0, 123, 0, 122, 0, 182, 0, 159, 0, 125, 0, 124, 0, 126, 0, 127, 0, 241, 0, 242, 0, 184, 0, 214, 0, 223, 0, 217, 0, 218, 0, 219, 0, 222, 0, 215, 0, 221, 0, 176, 0, 177, 2, 48, 0, 180, 0, 181, 0, 194, 0, 178, 0, 179, 0, 195, 0, 128, 0, 192, 0, 133, 0, 151, 2, 50, 0, 208, 2, 110, 0, 0, 176, 0, 44, 75, 176, 9, 80, 88, 177, 1, 1, 142, 89, 184, 1, 255, 133, 176, 68, 29, 177, 9, 3, 95, 94, 45, 176, 1, 44, 32, 32, 69, 105, 68, 176, 1, 96, 45, 176, 2, 44, 176, 1, 42, 33, 45, 176, 3, 44, 32, 70, 176, 3, 37, 70, 82, 88, 35, 89, 32, 138, 32, 138, 73, 100, 138, 32, 70, 32, 104, 97, 100, 176, 4, 37, 70, 32, 104, 97, 100, 82, 88, 35, 101, 138, 89, 47, 32, 176, 0, 83, 88, 105, 32, 176, 0, 84, 88, 33, 176, 64, 89, 27, 105, 32, 176, 0, 84, 88, 33, 176, 64, 101, 89, 89, 58, 45, 176, 4, 44, 32, 70, 176, 4, 37, 70, 82, 88, 35, 138, 89, 32, 70, 32, 106, 97, 100, 176, 4, 37, 70, 32, 106, 97, 100, 82, 88, 35, 138, 89, 47, 253, 45, 176, 5, 44, 75, 32, 176, 3, 38, 80, 88, 81, 88, 176, 128, 68, 27, 176, 64, 68, 89, 27, 33, 33, 32, 69, 176, 192, 80, 88, 176, 192, 68, 27, 33, 89, 89, 45, 176, 6, 44, 32, 32, 69, 105, 68, 176, 1, 96, 32, 32, 69, 125, 105, 24, 68, 176, 1, 96, 45, 176, 7, 44, 176, 6, 42, 45, 176, 8, 44, 75, 32, 176, 3, 38, 83, 88, 176, 64, 27, 176, 0, 89, 138, 138, 32, 176, 3, 38, 83, 88, 35, 33, 176, 128, 138, 138, 27, 138, 35, 89, 32, 176, 3, 38, 83, 88, 35, 33, 176, 192, 138, 138, 27, 138, 35, 89, 32, 176, 3, 38, 83, 88, 35, 33, 184, 1, 0, 138, 138, 27, 138, 35, 89, 32, 176, 3, 38, 83, 88, 35, 33, 184, 1, 64, 138, 138, 27, 138, 35, 89, 32, 176, 3, 38, 83, 88, 176, 3, 37, 69, 184, 1, 128, 80, 88, 35, 33, 184, 1, 128, 35, 33, 27, 176, 3, 37, 69, 35, 33, 35, 33, 89, 27, 33, 89, 68, 45, 176, 9, 44, 75, 83, 88, 69, 68, 27, 33, 33, 89, 45, 0, 0, 0, 176, 0, 43, 0, 178, 1, 7, 2, 43, 1, 178, 8, 7, 2, 43, 1, 183, 8, 66, 63, 48, 37, 24, 0, 8, 43, 183, 9, 83, 63, 61, 37, 24, 0, 8, 43, 183, 10, 103, 82, 61, 47, 24, 0, 8, 43, 183, 11, 76, 63, 48, 37, 24, 0, 8, 43, 183, 12, 83, 63, 48, 37, 24, 0, 8, 43, 183, 13, 97, 82, 61, 37, 24, 0, 8, 43, 183, 14, 33, 27, 21, 15, 9, 0, 8, 43, 0, 183, 1, 83, 63, 61, 37, 24, 0, 8, 43, 183, 2, 103, 82, 61, 47, 24, 0, 8, 43, 183, 3, 77, 63, 48, 37, 24, 0, 8, 43, 183, 4, 76, 63, 48, 37, 24, 0, 8, 43, 183, 5, 66, 63, 48, 37, 24, 0, 8, 43, 183, 6, 97, 82, 61, 37, 24, 0, 8, 43, 183, 7, 83, 63, 48, 37, 24, 0, 8, 43, 0, 178, 15, 4, 7, 43, 176, 0, 32, 69, 125, 105, 24, 68, 0, 0, 42, 0, 111, 0, 90, 0, 121, 0, 123, 0, 139, 0, 117, 0, 137, 0, 139, 0, 111, 0, 90, 0, 123, 0, 137, 0, 117, 1, 92, 0, 0, 0, 25, 254, 141, 0, 0, 3, 162, 0, 25, 5, 20, 0, 25, 0, 0, 0, 0, 0, 12, 0, 150, 0, 3, 0, 1, 4, 9, 0, 0, 0, 118, 0, 0, 0, 3, 0, 1, 4, 9, 0, 1, 0, 26, 0, 118, 0, 3, 0, 1, 4, 9, 0, 2, 0, 14, 0, 144, 0, 3, 0, 1, 4, 9, 0, 3, 0, 62, 0, 158, 0, 3, 0, 1, 4, 9, 0, 4, 0, 42, 0, 220, 0, 3, 0, 1, 4, 9, 0, 5, 0, 26, 1, 6, 0, 3, 0, 1, 4, 9, 0, 6, 0, 40, 1, 32, 0, 3, 0, 1, 4, 9, 0, 7, 0, 92, 1, 72, 0, 3, 0, 1, 4, 9, 0, 9, 0, 26, 1, 164, 0, 3, 0, 1, 4, 9, 0, 11, 0, 48, 1, 190, 0, 3, 0, 1, 4, 9, 0, 12, 0, 48, 1, 190, 0, 3, 0, 1, 4, 9, 0, 13, 56, 230, 1, 238, 0, 67, 0, 111, 0, 112, 0, 121, 0, 114, 0, 105, 0, 103, 0, 104, 0, 116, 0, 32, 0, 40, 0, 99, 0, 41, 0, 32, 0, 77, 0, 97, 0, 114, 0, 107, 0, 32, 0, 83, 0, 105, 0, 109, 0, 111, 0, 110, 0, 115, 0, 111, 0, 110, 0, 32, 0, 50, 0, 48, 0, 48, 0, 57, 0, 45, 0, 50, 0, 48, 0, 49, 0, 48, 0, 46, 0, 32, 0, 65, 0, 108, 0, 108, 0, 32, 0, 114, 0, 105, 0, 103, 0, 104, 0, 116, 0, 115, 0, 32, 0, 114, 0, 101, 0, 115, 0, 101, 0, 114, 0, 118, 0, 101, 0, 100, 0, 46, 0, 65, 0, 110, 0, 111, 0, 110, 0, 121, 0, 109, 0, 111, 0, 117, 0, 115, 0, 32, 0, 80, 0, 114, 0, 111, 0, 82, 0, 101, 0, 103, 0, 117, 0, 108, 0, 97, 0, 114, 0, 49, 0, 46, 0, 48, 0, 48, 0, 51, 0, 59, 0, 85, 0, 75, 0, 87, 0, 78, 0, 59, 0, 65, 0, 110, 0, 111, 0, 110, 0, 121, 0, 109, 0, 111, 0, 117, 0, 115, 0, 80, 0, 114, 0, 111, 0, 45, 0, 82, 0, 101, 0, 103, 0, 117, 0, 108, 0, 97, 0, 114, 0, 65, 0, 110, 0, 111, 0, 110, 0, 121, 0, 109, 0, 111, 0, 117, 0, 115, 0, 32, 0, 80, 0, 114, 0, 111, 0, 32, 0, 82, 0, 101, 0, 103, 0, 117, 0, 108, 0, 97, 0, 114, 0, 86, 0, 101, 0, 114, 0, 115, 0, 105, 0, 111, 0, 110, 0, 32, 0, 49, 0, 46, 0, 48, 0, 48, 0, 51, 0, 65, 0, 110, 0, 111, 0, 110, 0, 121, 0, 109, 0, 111, 0, 117, 0, 115, 0, 80, 0, 114, 0, 111, 0, 45, 0, 82, 0, 101, 0, 103, 0, 117, 0, 108, 0, 97, 0, 114, 0, 65, 0, 110, 0, 111, 0, 110, 0, 121, 0, 109, 0, 111, 0, 117, 0, 115, 0, 32, 0, 80, 0, 114, 0, 111, 0, 32, 0, 105, 0, 115, 0, 32, 0, 97, 0, 32, 0, 116, 0, 114, 0, 97, 0, 100, 0, 101, 0, 109, 0, 97, 0, 114, 0, 107, 0, 32, 0, 111, 0, 102, 0, 32, 0, 77, 0, 97, 0, 114, 0, 107, 0, 32, 0, 83, 0, 105, 0, 109, 0, 111, 0, 110, 0, 115, 0, 111, 0, 110, 0, 46, 0, 77, 0, 97, 0, 114, 0, 107, 0, 32, 0, 83, 0, 105, 0, 109, 0, 111, 0, 110, 0, 115, 0, 111, 0, 110, 0, 104, 0, 116, 0, 116, 0, 112, 0, 58, 0, 47, 0, 47, 0, 119, 0, 119, 0, 119, 0, 46, 0, 109, 0, 115, 0, 45, 0, 115, 0, 116, 0, 117, 0, 100, 0, 105, 0, 111, 0, 46, 0, 99, 0, 111, 0, 109, 0, 67, 0, 111, 0, 112, 0, 121, 0, 114, 0, 105, 0, 103, 0, 104, 0, 116, 0, 32, 0, 40, 0, 99, 0, 41, 0, 32, 0, 50, 0, 48, 0, 48, 0, 57, 0, 44, 0, 32, 0, 77, 0, 97, 0, 114, 0, 107, 0, 32, 0, 83, 0, 105, 0, 109, 0, 111, 0, 110, 0, 115, 0, 111, 0, 110, 0, 32, 0, 40, 0, 104, 0, 116, 0, 116, 0, 112, 0, 58, 0, 47, 0, 47, 0, 119, 0, 119, 0, 119, 0, 46, 0, 109, 0, 115, 0, 45, 0, 115, 0, 116, 0, 117, 0, 100, 0, 105, 0, 111, 0, 46, 0, 99, 0, 111, 0, 109, 0, 44, 0, 32, 0, 109, 0, 97, 0, 114, 0, 107, 0, 64, 0, 109, 0, 97, 0, 114, 0, 107, 0, 115, 0, 105, 0, 109, 0, 111, 0, 110, 0, 115, 0, 111, 0, 110, 0, 46, 0, 99, 0, 111, 0, 109, 0, 41, 0, 44, 0, 32, 0, 119, 0, 105, 0, 116, 0, 104, 0, 32, 0, 82, 0, 101, 0, 115, 0, 101, 0, 114, 0, 118, 0, 101, 0, 100, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 78, 0, 97, 0, 109, 0, 101, 0, 32, 0, 65, 0, 110, 0, 111, 0, 110, 0, 121, 0, 109, 0, 111, 0, 117, 0, 115, 0, 32, 0, 80, 0, 114, 0, 111, 0, 46, 0, 13, 0, 13, 0, 84, 0, 104, 0, 105, 0, 115, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 32, 0, 105, 0, 115, 0, 32, 0, 108, 0, 105, 0, 99, 0, 101, 0, 110, 0, 115, 0, 101, 0, 100, 0, 32, 0, 117, 0, 110, 0, 100, 0, 101, 0, 114, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 83, 0, 73, 0, 76, 0, 32, 0, 79, 0, 112, 0, 101, 0, 110, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 76, 0, 105, 0, 99, 0, 101, 0, 110, 0, 115, 0, 101, 0, 44, 0, 32, 0, 86, 0, 101, 0, 114, 0, 115, 0, 105, 0, 111, 0, 110, 0, 32, 0, 49, 0, 46, 0, 49, 0, 46, 0, 13, 0, 67, 0, 111, 0, 112, 0, 121, 0, 114, 0, 105, 0, 103, 0, 104, 0, 116, 0, 32, 0, 40, 0, 99, 0, 41, 0, 32, 0, 50, 0, 48, 0, 48, 0, 57, 0, 44, 0, 32, 0, 77, 0, 97, 0, 114, 0, 107, 0, 32, 0, 83, 0, 105, 0, 109, 0, 111, 0, 110, 0, 115, 0, 111, 0, 110, 0, 32, 0, 40, 0, 104, 0, 116, 0, 116, 0, 112, 0, 58, 0, 47, 0, 47, 0, 119, 0, 119, 0, 119, 0, 46, 0, 109, 0, 115, 0, 45, 0, 115, 0, 116, 0, 117, 0, 100, 0, 105, 0, 111, 0, 46, 0, 99, 0, 111, 0, 109, 0, 44, 0, 32, 0, 109, 0, 97, 0, 114, 0, 107, 0, 64, 0, 109, 0, 97, 0, 114, 0, 107, 0, 115, 0, 105, 0, 109, 0, 111, 0, 110, 0, 115, 0, 111, 0, 110, 0, 46, 0, 99, 0, 111, 0, 109, 0, 41, 0, 44, 0, 32, 0, 119, 0, 105, 0, 116, 0, 104, 0, 32, 0, 82, 0, 101, 0, 115, 0, 101, 0, 114, 0, 118, 0, 101, 0, 100, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 78, 0, 97, 0, 109, 0, 101, 0, 32, 0, 65, 0, 110, 0, 111, 0, 110, 0, 121, 0, 109, 0, 111, 0, 117, 0, 115, 0, 32, 0, 80, 0, 114, 0, 111, 0, 46, 0, 13, 0, 13, 0, 84, 0, 104, 0, 105, 0, 115, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 32, 0, 105, 0, 115, 0, 32, 0, 108, 0, 105, 0, 99, 0, 101, 0, 110, 0, 115, 0, 101, 0, 100, 0, 32, 0, 117, 0, 110, 0, 100, 0, 101, 0, 114, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 83, 0, 73, 0, 76, 0, 32, 0, 79, 0, 112, 0, 101, 0, 110, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 76, 0, 105, 0, 99, 0, 101, 0, 110, 0, 115, 0, 101, 0, 44, 0, 32, 0, 86, 0, 101, 0, 114, 0, 115, 0, 105, 0, 111, 0, 110, 0, 32, 0, 49, 0, 46, 0, 49, 0, 46, 0, 32, 0, 84, 0, 104, 0, 105, 0, 115, 0, 32, 0, 108, 0, 105, 0, 99, 0, 101, 0, 110, 0, 115, 0, 101, 0, 32, 0, 105, 0, 115, 0, 32, 0, 99, 0, 111, 0, 112, 0, 105, 0, 101, 0, 100, 0, 32, 0, 98, 0, 101, 0, 108, 0, 111, 0, 119, 0, 44, 0, 32, 0, 97, 0, 110, 0, 100, 0, 32, 0, 105, 0, 115, 0, 32, 0, 97, 0, 108, 0, 115, 0, 111, 0, 32, 0, 97, 0, 118, 0, 97, 0, 105, 0, 108, 0, 97, 0, 98, 0, 108, 0, 101, 0, 32, 0, 119, 0, 105, 0, 116, 0, 104, 0, 32, 0, 97, 0, 32, 0, 70, 0, 65, 0, 81, 0, 32, 0, 97, 0, 116, 0, 58, 0, 32, 0, 104, 0, 116, 0, 116, 0, 112, 0, 58, 0, 47, 0, 47, 0, 115, 0, 99, 0, 114, 0, 105, 0, 112, 0, 116, 0, 115, 0, 46, 0, 115, 0, 105, 0, 108, 0, 46, 0, 111, 0, 114, 0, 103, 0, 47, 0, 79, 0, 70, 0, 76, 0, 13, 0, 13, 0, 13, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 32, 0, 83, 0, 73, 0, 76, 0, 32, 0, 79, 0, 80, 0, 69, 0, 78, 0, 32, 0, 70, 0, 79, 0, 78, 0, 84, 0, 32, 0, 76, 0, 73, 0, 67, 0, 69, 0, 78, 0, 83, 0, 69, 0, 32, 0, 86, 0, 101, 0, 114, 0, 115, 0, 105, 0, 111, 0, 110, 0, 32, 0, 49, 0, 46, 0, 49, 0, 32, 0, 45, 0, 32, 0, 50, 0, 54, 0, 32, 0, 70, 0, 101, 0, 98, 0, 114, 0, 117, 0, 97, 0, 114, 0, 121, 0, 32, 0, 50, 0, 48, 0, 48, 0, 55, 0, 32, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 45, 0, 13, 0, 13, 0, 80, 0, 82, 0, 69, 0, 65, 0, 77, 0, 66, 0, 76, 0, 69, 0, 32, 0, 84, 0, 104, 0, 101, 0, 32, 0, 103, 0, 111, 0, 97, 0, 108, 0, 115, 0, 32, 0, 111, 0, 102, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 79, 0, 112, 0, 101, 0, 110, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 76, 0, 105, 0, 99, 0, 101, 0, 110, 0, 115, 0, 101, 0, 32, 0, 40, 0, 79, 0, 70, 0, 76, 0, 41, 0, 32, 0, 97, 0, 114, 0, 101, 0, 32, 0, 116, 0, 111, 0, 32, 0, 115, 0, 116, 0, 105, 0, 109, 0, 117, 0, 108, 0, 97, 0, 116, 0, 101, 0, 32, 0, 119, 0, 111, 0, 114, 0, 108, 0, 100, 0, 119, 0, 105, 0, 100, 0, 101, 0, 32, 0, 100, 0, 101, 0, 118, 0, 101, 0, 108, 0, 111, 0, 112, 0, 109, 0, 101, 0, 110, 0, 116, 0, 32, 0, 111, 0, 102, 0, 32, 0, 99, 0, 111, 0, 108, 0, 108, 0, 97, 0, 98, 0, 111, 0, 114, 0, 97, 0, 116, 0, 105, 0, 118, 0, 101, 0, 32, 0, 102, 0, 111, 0, 110, 0, 116, 0, 32, 0, 112, 0, 114, 0, 111, 0, 106, 0, 101, 0, 99, 0, 116, 0, 115, 0, 44, 0, 32, 0, 116, 0, 111, 0, 32, 0, 115, 0, 117, 0, 112, 0, 112, 0, 111, 0, 114, 0, 116, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 102, 0, 111, 0, 110, 0, 116, 0, 32, 0, 99, 0, 114, 0, 101, 0, 97, 0, 116, 0, 105, 0, 111, 0, 110, 0, 32, 0, 101, 0, 102, 0, 102, 0, 111, 0, 114, 0, 116, 0, 115, 0, 32, 0, 111, 0, 102, 0, 32, 0, 97, 0, 99, 0, 97, 0, 100, 0, 101, 0, 109, 0, 105, 0, 99, 0, 32, 0, 97, 0, 110, 0, 100, 0, 32, 0, 108, 0, 105, 0, 110, 0, 103, 0, 117, 0, 105, 0, 115, 0, 116, 0, 105, 0, 99, 0, 32, 0, 99, 0, 111, 0, 109, 0, 109, 0, 117, 0, 110, 0, 105, 0, 116, 0, 105, 0, 101, 0, 115, 0, 44, 0, 32, 0, 97, 0, 110, 0, 100, 0, 32, 0, 116, 0, 111, 0, 32, 0, 112, 0, 114, 0, 111, 0, 118, 0, 105, 0, 100, 0, 101, 0, 32, 0, 97, 0, 32, 0, 102, 0, 114, 0, 101, 0, 101, 0, 32, 0, 97, 0, 110, 0, 100, 0, 32, 0, 111, 0, 112, 0, 101, 0, 110, 0, 32, 0, 102, 0, 114, 0, 97, 0, 109, 0, 101, 0, 119, 0, 111, 0, 114, 0, 107, 0, 32, 0, 105, 0, 110, 0, 32, 0, 119, 0, 104, 0, 105, 0, 99, 0, 104, 0, 32, 0, 102, 0, 111, 0, 110, 0, 116, 0, 115, 0, 32, 0, 109, 0, 97, 0, 121, 0, 32, 0, 98, 0, 101, 0, 32, 0, 115, 0, 104, 0, 97, 0, 114, 0, 101, 0, 100, 0, 32, 0, 97, 0, 110, 0, 100, 0, 32, 0, 105, 0, 109, 0, 112, 0, 114, 0, 111, 0, 118, 0, 101, 0, 100, 0, 32, 0, 105, 0, 110, 0, 32, 0, 112, 0, 97, 0, 114, 0, 116, 0, 110, 0, 101, 0, 114, 0, 115, 0, 104, 0, 105, 0, 112, 0, 32, 0, 119, 0, 105, 0, 116, 0, 104, 0, 32, 0, 111, 0, 116, 0, 104, 0, 101, 0, 114, 0, 115, 0, 46, 0, 13, 0, 13, 0, 84, 0, 104, 0, 101, 0, 32, 0, 79, 0, 70, 0, 76, 0, 32, 0, 97, 0, 108, 0, 108, 0, 111, 0, 119, 0, 115, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 108, 0, 105, 0, 99, 0, 101, 0, 110, 0, 115, 0, 101, 0, 100, 0, 32, 0, 102, 0, 111, 0, 110, 0, 116, 0, 115, 0, 32, 0, 116, 0, 111, 0, 32, 0, 98, 0, 101, 0, 32, 0, 117, 0, 115, 0, 101, 0, 100, 0, 44, 0, 32, 0, 115, 0, 116, 0, 117, 0, 100, 0, 105, 0, 101, 0, 100, 0, 44, 0, 32, 0, 109, 0, 111, 0, 100, 0, 105, 0, 102, 0, 105, 0, 101, 0, 100, 0, 32, 0, 97, 0, 110, 0, 100, 0, 32, 0, 114, 0, 101, 0, 100, 0, 105, 0, 115, 0, 116, 0, 114, 0, 105, 0, 98, 0, 117, 0, 116, 0, 101, 0, 100, 0, 32, 0, 102, 0, 114, 0, 101, 0, 101, 0, 108, 0, 121, 0, 32, 0, 97, 0, 115, 0, 32, 0, 108, 0, 111, 0, 110, 0, 103, 0, 32, 0, 97, 0, 115, 0, 32, 0, 116, 0, 104, 0, 101, 0, 121, 0, 32, 0, 97, 0, 114, 0, 101, 0, 32, 0, 110, 0, 111, 0, 116, 0, 32, 0, 115, 0, 111, 0, 108, 0, 100, 0, 32, 0, 98, 0, 121, 0, 32, 0, 116, 0, 104, 0, 101, 0, 109, 0, 115, 0, 101, 0, 108, 0, 118, 0, 101, 0, 115, 0, 46, 0, 32, 0, 84, 0, 104, 0, 101, 0, 32, 0, 102, 0, 111, 0, 110, 0, 116, 0, 115, 0, 44, 0, 32, 0, 105, 0, 110, 0, 99, 0, 108, 0, 117, 0, 100, 0, 105, 0, 110, 0, 103, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 100, 0, 101, 0, 114, 0, 105, 0, 118, 0, 97, 0, 116, 0, 105, 0, 118, 0, 101, 0, 32, 0, 119, 0, 111, 0, 114, 0, 107, 0, 115, 0, 44, 0, 32, 0, 99, 0, 97, 0, 110, 0, 32, 0, 98, 0, 101, 0, 32, 0, 98, 0, 117, 0, 110, 0, 100, 0, 108, 0, 101, 0, 100, 0, 44, 0, 32, 0, 101, 0, 109, 0, 98, 0, 101, 0, 100, 0, 100, 0, 101, 0, 100, 0, 44, 0, 32, 0, 114, 0, 101, 0, 100, 0, 105, 0, 115, 0, 116, 0, 114, 0, 105, 0, 98, 0, 117, 0, 116, 0, 101, 0, 100, 0, 32, 0, 97, 0, 110, 0, 100, 0, 47, 0, 111, 0, 114, 0, 32, 0, 115, 0, 111, 0, 108, 0, 100, 0, 32, 0, 119, 0, 105, 0, 116, 0, 104, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 115, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 32, 0, 112, 0, 114, 0, 111, 0, 118, 0, 105, 0, 100, 0, 101, 0, 100, 0, 32, 0, 116, 0, 104, 0, 97, 0, 116, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 114, 0, 101, 0, 115, 0, 101, 0, 114, 0, 118, 0, 101, 0, 100, 0, 32, 0, 110, 0, 97, 0, 109, 0, 101, 0, 115, 0, 32, 0, 97, 0, 114, 0, 101, 0, 32, 0, 110, 0, 111, 0, 116, 0, 32, 0, 117, 0, 115, 0, 101, 0, 100, 0, 32, 0, 98, 0, 121, 0, 32, 0, 100, 0, 101, 0, 114, 0, 105, 0, 118, 0, 97, 0, 116, 0, 105, 0, 118, 0, 101, 0, 32, 0, 119, 0, 111, 0, 114, 0, 107, 0, 115, 0, 46, 0, 32, 0, 84, 0, 104, 0, 101, 0, 32, 0, 102, 0, 111, 0, 110, 0, 116, 0, 115, 0, 32, 0, 97, 0, 110, 0, 100, 0, 32, 0, 100, 0, 101, 0, 114, 0, 105, 0, 118, 0, 97, 0, 116, 0, 105, 0, 118, 0, 101, 0, 115, 0, 44, 0, 32, 0, 104, 0, 111, 0, 119, 0, 101, 0, 118, 0, 101, 0, 114, 0, 44, 0, 32, 0, 99, 0, 97, 0, 110, 0, 110, 0, 111, 0, 116, 0, 32, 0, 98, 0, 101, 0, 32, 0, 114, 0, 101, 0, 108, 0, 101, 0, 97, 0, 115, 0, 101, 0, 100, 0, 32, 0, 117, 0, 110, 0, 100, 0, 101, 0, 114, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 111, 0, 116, 0, 104, 0, 101, 0, 114, 0, 32, 0, 116, 0, 121, 0, 112, 0, 101, 0, 32, 0, 111, 0, 102, 0, 32, 0, 108, 0, 105, 0, 99, 0, 101, 0, 110, 0, 115, 0, 101, 0, 46, 0, 32, 0, 84, 0, 104, 0, 101, 0, 32, 0, 114, 0, 101, 0, 113, 0, 117, 0, 105, 0, 114, 0, 101, 0, 109, 0, 101, 0, 110, 0, 116, 0, 32, 0, 102, 0, 111, 0, 114, 0, 32, 0, 102, 0, 111, 0, 110, 0, 116, 0, 115, 0, 32, 0, 116, 0, 111, 0, 32, 0, 114, 0, 101, 0, 109, 0, 97, 0, 105, 0, 110, 0, 32, 0, 117, 0, 110, 0, 100, 0, 101, 0, 114, 0, 32, 0, 116, 0, 104, 0, 105, 0, 115, 0, 32, 0, 108, 0, 105, 0, 99, 0, 101, 0, 110, 0, 115, 0, 101, 0, 32, 0, 100, 0, 111, 0, 101, 0, 115, 0, 32, 0, 110, 0, 111, 0, 116, 0, 32, 0, 97, 0, 112, 0, 112, 0, 108, 0, 121, 0, 32, 0, 116, 0, 111, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 100, 0, 111, 0, 99, 0, 117, 0, 109, 0, 101, 0, 110, 0, 116, 0, 32, 0, 99, 0, 114, 0, 101, 0, 97, 0, 116, 0, 101, 0, 100, 0, 32, 0, 117, 0, 115, 0, 105, 0, 110, 0, 103, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 102, 0, 111, 0, 110, 0, 116, 0, 115, 0, 32, 0, 111, 0, 114, 0, 32, 0, 116, 0, 104, 0, 101, 0, 105, 0, 114, 0, 32, 0, 100, 0, 101, 0, 114, 0, 105, 0, 118, 0, 97, 0, 116, 0, 105, 0, 118, 0, 101, 0, 115, 0, 46, 0, 13, 0, 13, 0, 68, 0, 69, 0, 70, 0, 73, 0, 78, 0, 73, 0, 84, 0, 73, 0, 79, 0, 78, 0, 83, 0, 32, 0, 34, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 34, 0, 32, 0, 114, 0, 101, 0, 102, 0, 101, 0, 114, 0, 115, 0, 32, 0, 116, 0, 111, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 115, 0, 101, 0, 116, 0, 32, 0, 111, 0, 102, 0, 32, 0, 102, 0, 105, 0, 108, 0, 101, 0, 115, 0, 32, 0, 114, 0, 101, 0, 108, 0, 101, 0, 97, 0, 115, 0, 101, 0, 100, 0, 32, 0, 98, 0, 121, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 67, 0, 111, 0, 112, 0, 121, 0, 114, 0, 105, 0, 103, 0, 104, 0, 116, 0, 32, 0, 72, 0, 111, 0, 108, 0, 100, 0, 101, 0, 114, 0, 40, 0, 115, 0, 41, 0, 32, 0, 117, 0, 110, 0, 100, 0, 101, 0, 114, 0, 32, 0, 116, 0, 104, 0, 105, 0, 115, 0, 32, 0, 108, 0, 105, 0, 99, 0, 101, 0, 110, 0, 115, 0, 101, 0, 32, 0, 97, 0, 110, 0, 100, 0, 32, 0, 99, 0, 108, 0, 101, 0, 97, 0, 114, 0, 108, 0, 121, 0, 32, 0, 109, 0, 97, 0, 114, 0, 107, 0, 101, 0, 100, 0, 32, 0, 97, 0, 115, 0, 32, 0, 115, 0, 117, 0, 99, 0, 104, 0, 46, 0, 32, 0, 84, 0, 104, 0, 105, 0, 115, 0, 32, 0, 109, 0, 97, 0, 121, 0, 32, 0, 105, 0, 110, 0, 99, 0, 108, 0, 117, 0, 100, 0, 101, 0, 32, 0, 115, 0, 111, 0, 117, 0, 114, 0, 99, 0, 101, 0, 32, 0, 102, 0, 105, 0, 108, 0, 101, 0, 115, 0, 44, 0, 32, 0, 98, 0, 117, 0, 105, 0, 108, 0, 100, 0, 32, 0, 115, 0, 99, 0, 114, 0, 105, 0, 112, 0, 116, 0, 115, 0, 32, 0, 97, 0, 110, 0, 100, 0, 32, 0, 100, 0, 111, 0, 99, 0, 117, 0, 109, 0, 101, 0, 110, 0, 116, 0, 97, 0, 116, 0, 105, 0, 111, 0, 110, 0, 46, 0, 13, 0, 13, 0, 34, 0, 82, 0, 101, 0, 115, 0, 101, 0, 114, 0, 118, 0, 101, 0, 100, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 78, 0, 97, 0, 109, 0, 101, 0, 34, 0, 32, 0, 114, 0, 101, 0, 102, 0, 101, 0, 114, 0, 115, 0, 32, 0, 116, 0, 111, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 110, 0, 97, 0, 109, 0, 101, 0, 115, 0, 32, 0, 115, 0, 112, 0, 101, 0, 99, 0, 105, 0, 102, 0, 105, 0, 101, 0, 100, 0, 32, 0, 97, 0, 115, 0, 32, 0, 115, 0, 117, 0, 99, 0, 104, 0, 32, 0, 97, 0, 102, 0, 116, 0, 101, 0, 114, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 99, 0, 111, 0, 112, 0, 121, 0, 114, 0, 105, 0, 103, 0, 104, 0, 116, 0, 32, 0, 115, 0, 116, 0, 97, 0, 116, 0, 101, 0, 109, 0, 101, 0, 110, 0, 116, 0, 40, 0, 115, 0, 41, 0, 46, 0, 13, 0, 13, 0, 34, 0, 79, 0, 114, 0, 105, 0, 103, 0, 105, 0, 110, 0, 97, 0, 108, 0, 32, 0, 86, 0, 101, 0, 114, 0, 115, 0, 105, 0, 111, 0, 110, 0, 34, 0, 32, 0, 114, 0, 101, 0, 102, 0, 101, 0, 114, 0, 115, 0, 32, 0, 116, 0, 111, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 99, 0, 111, 0, 108, 0, 108, 0, 101, 0, 99, 0, 116, 0, 105, 0, 111, 0, 110, 0, 32, 0, 111, 0, 102, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 32, 0, 99, 0, 111, 0, 109, 0, 112, 0, 111, 0, 110, 0, 101, 0, 110, 0, 116, 0, 115, 0, 32, 0, 97, 0, 115, 0, 32, 0, 100, 0, 105, 0, 115, 0, 116, 0, 114, 0, 105, 0, 98, 0, 117, 0, 116, 0, 101, 0, 100, 0, 32, 0, 98, 0, 121, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 67, 0, 111, 0, 112, 0, 121, 0, 114, 0, 105, 0, 103, 0, 104, 0, 116, 0, 32, 0, 72, 0, 111, 0, 108, 0, 100, 0, 101, 0, 114, 0, 40, 0, 115, 0, 41, 0, 46, 0, 13, 0, 13, 0, 34, 0, 77, 0, 111, 0, 100, 0, 105, 0, 102, 0, 105, 0, 101, 0, 100, 0, 32, 0, 86, 0, 101, 0, 114, 0, 115, 0, 105, 0, 111, 0, 110, 0, 34, 0, 32, 0, 114, 0, 101, 0, 102, 0, 101, 0, 114, 0, 115, 0, 32, 0, 116, 0, 111, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 100, 0, 101, 0, 114, 0, 105, 0, 118, 0, 97, 0, 116, 0, 105, 0, 118, 0, 101, 0, 32, 0, 109, 0, 97, 0, 100, 0, 101, 0, 32, 0, 98, 0, 121, 0, 32, 0, 97, 0, 100, 0, 100, 0, 105, 0, 110, 0, 103, 0, 32, 0, 116, 0, 111, 0, 44, 0, 32, 0, 100, 0, 101, 0, 108, 0, 101, 0, 116, 0, 105, 0, 110, 0, 103, 0, 44, 0, 32, 0, 111, 0, 114, 0, 32, 0, 115, 0, 117, 0, 98, 0, 115, 0, 116, 0, 105, 0, 116, 0, 117, 0, 116, 0, 105, 0, 110, 0, 103, 0, 32, 0, 45, 0, 45, 0, 32, 0, 105, 0, 110, 0, 32, 0, 112, 0, 97, 0, 114, 0, 116, 0, 32, 0, 111, 0, 114, 0, 32, 0, 105, 0, 110, 0, 32, 0, 119, 0, 104, 0, 111, 0, 108, 0, 101, 0, 32, 0, 45, 0, 45, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 111, 0, 102, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 99, 0, 111, 0, 109, 0, 112, 0, 111, 0, 110, 0, 101, 0, 110, 0, 116, 0, 115, 0, 32, 0, 111, 0, 102, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 79, 0, 114, 0, 105, 0, 103, 0, 105, 0, 110, 0, 97, 0, 108, 0, 32, 0, 86, 0, 101, 0, 114, 0, 115, 0, 105, 0, 111, 0, 110, 0, 44, 0, 32, 0, 98, 0, 121, 0, 32, 0, 99, 0, 104, 0, 97, 0, 110, 0, 103, 0, 105, 0, 110, 0, 103, 0, 32, 0, 102, 0, 111, 0, 114, 0, 109, 0, 97, 0, 116, 0, 115, 0, 32, 0, 111, 0, 114, 0, 32, 0, 98, 0, 121, 0, 32, 0, 112, 0, 111, 0, 114, 0, 116, 0, 105, 0, 110, 0, 103, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 32, 0, 116, 0, 111, 0, 32, 0, 97, 0, 32, 0, 110, 0, 101, 0, 119, 0, 32, 0, 101, 0, 110, 0, 118, 0, 105, 0, 114, 0, 111, 0, 110, 0, 109, 0, 101, 0, 110, 0, 116, 0, 46, 0, 13, 0, 13, 0, 34, 0, 65, 0, 117, 0, 116, 0, 104, 0, 111, 0, 114, 0, 34, 0, 32, 0, 114, 0, 101, 0, 102, 0, 101, 0, 114, 0, 115, 0, 32, 0, 116, 0, 111, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 100, 0, 101, 0, 115, 0, 105, 0, 103, 0, 110, 0, 101, 0, 114, 0, 44, 0, 32, 0, 101, 0, 110, 0, 103, 0, 105, 0, 110, 0, 101, 0, 101, 0, 114, 0, 44, 0, 32, 0, 112, 0, 114, 0, 111, 0, 103, 0, 114, 0, 97, 0, 109, 0, 109, 0, 101, 0, 114, 0, 44, 0, 32, 0, 116, 0, 101, 0, 99, 0, 104, 0, 110, 0, 105, 0, 99, 0, 97, 0, 108, 0, 32, 0, 119, 0, 114, 0, 105, 0, 116, 0, 101, 0, 114, 0, 32, 0, 111, 0, 114, 0, 32, 0, 111, 0, 116, 0, 104, 0, 101, 0, 114, 0, 32, 0, 112, 0, 101, 0, 114, 0, 115, 0, 111, 0, 110, 0, 32, 0, 119, 0, 104, 0, 111, 0, 32, 0, 99, 0, 111, 0, 110, 0, 116, 0, 114, 0, 105, 0, 98, 0, 117, 0, 116, 0, 101, 0, 100, 0, 32, 0, 116, 0, 111, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 46, 0, 13, 0, 13, 0, 80, 0, 69, 0, 82, 0, 77, 0, 73, 0, 83, 0, 83, 0, 73, 0, 79, 0, 78, 0, 32, 0, 38, 0, 32, 0, 67, 0, 79, 0, 78, 0, 68, 0, 73, 0, 84, 0, 73, 0, 79, 0, 78, 0, 83, 0, 32, 0, 80, 0, 101, 0, 114, 0, 109, 0, 105, 0, 115, 0, 115, 0, 105, 0, 111, 0, 110, 0, 32, 0, 105, 0, 115, 0, 32, 0, 104, 0, 101, 0, 114, 0, 101, 0, 98, 0, 121, 0, 32, 0, 103, 0, 114, 0, 97, 0, 110, 0, 116, 0, 101, 0, 100, 0, 44, 0, 32, 0, 102, 0, 114, 0, 101, 0, 101, 0, 32, 0, 111, 0, 102, 0, 32, 0, 99, 0, 104, 0, 97, 0, 114, 0, 103, 0, 101, 0, 44, 0, 32, 0, 116, 0, 111, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 112, 0, 101, 0, 114, 0, 115, 0, 111, 0, 110, 0, 32, 0, 111, 0, 98, 0, 116, 0, 97, 0, 105, 0, 110, 0, 105, 0, 110, 0, 103, 0, 32, 0, 97, 0, 32, 0, 99, 0, 111, 0, 112, 0, 121, 0, 32, 0, 111, 0, 102, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 44, 0, 32, 0, 116, 0, 111, 0, 32, 0, 117, 0, 115, 0, 101, 0, 44, 0, 32, 0, 115, 0, 116, 0, 117, 0, 100, 0, 121, 0, 44, 0, 32, 0, 99, 0, 111, 0, 112, 0, 121, 0, 44, 0, 32, 0, 109, 0, 101, 0, 114, 0, 103, 0, 101, 0, 44, 0, 32, 0, 101, 0, 109, 0, 98, 0, 101, 0, 100, 0, 44, 0, 32, 0, 109, 0, 111, 0, 100, 0, 105, 0, 102, 0, 121, 0, 44, 0, 32, 0, 114, 0, 101, 0, 100, 0, 105, 0, 115, 0, 116, 0, 114, 0, 105, 0, 98, 0, 117, 0, 116, 0, 101, 0, 44, 0, 32, 0, 97, 0, 110, 0, 100, 0, 32, 0, 115, 0, 101, 0, 108, 0, 108, 0, 32, 0, 109, 0, 111, 0, 100, 0, 105, 0, 102, 0, 105, 0, 101, 0, 100, 0, 32, 0, 97, 0, 110, 0, 100, 0, 32, 0, 117, 0, 110, 0, 109, 0, 111, 0, 100, 0, 105, 0, 102, 0, 105, 0, 101, 0, 100, 0, 32, 0, 99, 0, 111, 0, 112, 0, 105, 0, 101, 0, 115, 0, 32, 0, 111, 0, 102, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 44, 0, 32, 0, 115, 0, 117, 0, 98, 0, 106, 0, 101, 0, 99, 0, 116, 0, 32, 0, 116, 0, 111, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 102, 0, 111, 0, 108, 0, 108, 0, 111, 0, 119, 0, 105, 0, 110, 0, 103, 0, 32, 0, 99, 0, 111, 0, 110, 0, 100, 0, 105, 0, 116, 0, 105, 0, 111, 0, 110, 0, 115, 0, 58, 0, 13, 0, 13, 0, 49, 0, 41, 0, 32, 0, 78, 0, 101, 0, 105, 0, 116, 0, 104, 0, 101, 0, 114, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 32, 0, 110, 0, 111, 0, 114, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 111, 0, 102, 0, 32, 0, 105, 0, 116, 0, 115, 0, 32, 0, 105, 0, 110, 0, 100, 0, 105, 0, 118, 0, 105, 0, 100, 0, 117, 0, 97, 0, 108, 0, 32, 0, 99, 0, 111, 0, 109, 0, 112, 0, 111, 0, 110, 0, 101, 0, 110, 0, 116, 0, 115, 0, 44, 0, 32, 0, 105, 0, 110, 0, 32, 0, 79, 0, 114, 0, 105, 0, 103, 0, 105, 0, 110, 0, 97, 0, 108, 0, 32, 0, 111, 0, 114, 0, 32, 0, 77, 0, 111, 0, 100, 0, 105, 0, 102, 0, 105, 0, 101, 0, 100, 0, 32, 0, 86, 0, 101, 0, 114, 0, 115, 0, 105, 0, 111, 0, 110, 0, 115, 0, 44, 0, 32, 0, 109, 0, 97, 0, 121, 0, 32, 0, 98, 0, 101, 0, 32, 0, 115, 0, 111, 0, 108, 0, 100, 0, 32, 0, 98, 0, 121, 0, 32, 0, 105, 0, 116, 0, 115, 0, 101, 0, 108, 0, 102, 0, 46, 0, 13, 0, 13, 0, 50, 0, 41, 0, 32, 0, 79, 0, 114, 0, 105, 0, 103, 0, 105, 0, 110, 0, 97, 0, 108, 0, 32, 0, 111, 0, 114, 0, 32, 0, 77, 0, 111, 0, 100, 0, 105, 0, 102, 0, 105, 0, 101, 0, 100, 0, 32, 0, 86, 0, 101, 0, 114, 0, 115, 0, 105, 0, 111, 0, 110, 0, 115, 0, 32, 0, 111, 0, 102, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 32, 0, 109, 0, 97, 0, 121, 0, 32, 0, 98, 0, 101, 0, 32, 0, 98, 0, 117, 0, 110, 0, 100, 0, 108, 0, 101, 0, 100, 0, 44, 0, 32, 0, 114, 0, 101, 0, 100, 0, 105, 0, 115, 0, 116, 0, 114, 0, 105, 0, 98, 0, 117, 0, 116, 0, 101, 0, 100, 0, 32, 0, 97, 0, 110, 0, 100, 0, 47, 0, 111, 0, 114, 0, 32, 0, 115, 0, 111, 0, 108, 0, 100, 0, 32, 0, 119, 0, 105, 0, 116, 0, 104, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 115, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 44, 0, 32, 0, 112, 0, 114, 0, 111, 0, 118, 0, 105, 0, 100, 0, 101, 0, 100, 0, 32, 0, 116, 0, 104, 0, 97, 0, 116, 0, 32, 0, 101, 0, 97, 0, 99, 0, 104, 0, 32, 0, 99, 0, 111, 0, 112, 0, 121, 0, 32, 0, 99, 0, 111, 0, 110, 0, 116, 0, 97, 0, 105, 0, 110, 0, 115, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 97, 0, 98, 0, 111, 0, 118, 0, 101, 0, 32, 0, 99, 0, 111, 0, 112, 0, 121, 0, 114, 0, 105, 0, 103, 0, 104, 0, 116, 0, 32, 0, 110, 0, 111, 0, 116, 0, 105, 0, 99, 0, 101, 0, 32, 0, 97, 0, 110, 0, 100, 0, 32, 0, 116, 0, 104, 0, 105, 0, 115, 0, 32, 0, 108, 0, 105, 0, 99, 0, 101, 0, 110, 0, 115, 0, 101, 0, 46, 0, 32, 0, 84, 0, 104, 0, 101, 0, 115, 0, 101, 0, 32, 0, 99, 0, 97, 0, 110, 0, 32, 0, 98, 0, 101, 0, 32, 0, 105, 0, 110, 0, 99, 0, 108, 0, 117, 0, 100, 0, 101, 0, 100, 0, 32, 0, 101, 0, 105, 0, 116, 0, 104, 0, 101, 0, 114, 0, 32, 0, 97, 0, 115, 0, 32, 0, 115, 0, 116, 0, 97, 0, 110, 0, 100, 0, 45, 0, 97, 0, 108, 0, 111, 0, 110, 0, 101, 0, 32, 0, 116, 0, 101, 0, 120, 0, 116, 0, 32, 0, 102, 0, 105, 0, 108, 0, 101, 0, 115, 0, 44, 0, 32, 0, 104, 0, 117, 0, 109, 0, 97, 0, 110, 0, 45, 0, 114, 0, 101, 0, 97, 0, 100, 0, 97, 0, 98, 0, 108, 0, 101, 0, 32, 0, 104, 0, 101, 0, 97, 0, 100, 0, 101, 0, 114, 0, 115, 0, 32, 0, 111, 0, 114, 0, 32, 0, 105, 0, 110, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 97, 0, 112, 0, 112, 0, 114, 0, 111, 0, 112, 0, 114, 0, 105, 0, 97, 0, 116, 0, 101, 0, 32, 0, 109, 0, 97, 0, 99, 0, 104, 0, 105, 0, 110, 0, 101, 0, 45, 0, 114, 0, 101, 0, 97, 0, 100, 0, 97, 0, 98, 0, 108, 0, 101, 0, 32, 0, 109, 0, 101, 0, 116, 0, 97, 0, 100, 0, 97, 0, 116, 0, 97, 0, 32, 0, 102, 0, 105, 0, 101, 0, 108, 0, 100, 0, 115, 0, 32, 0, 119, 0, 105, 0, 116, 0, 104, 0, 105, 0, 110, 0, 32, 0, 116, 0, 101, 0, 120, 0, 116, 0, 32, 0, 111, 0, 114, 0, 32, 0, 98, 0, 105, 0, 110, 0, 97, 0, 114, 0, 121, 0, 32, 0, 102, 0, 105, 0, 108, 0, 101, 0, 115, 0, 32, 0, 97, 0, 115, 0, 32, 0, 108, 0, 111, 0, 110, 0, 103, 0, 32, 0, 97, 0, 115, 0, 32, 0, 116, 0, 104, 0, 111, 0, 115, 0, 101, 0, 32, 0, 102, 0, 105, 0, 101, 0, 108, 0, 100, 0, 115, 0, 32, 0, 99, 0, 97, 0, 110, 0, 32, 0, 98, 0, 101, 0, 32, 0, 101, 0, 97, 0, 115, 0, 105, 0, 108, 0, 121, 0, 32, 0, 118, 0, 105, 0, 101, 0, 119, 0, 101, 0, 100, 0, 32, 0, 98, 0, 121, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 117, 0, 115, 0, 101, 0, 114, 0, 46, 0, 13, 0, 13, 0, 51, 0, 41, 0, 32, 0, 78, 0, 111, 0, 32, 0, 77, 0, 111, 0, 100, 0, 105, 0, 102, 0, 105, 0, 101, 0, 100, 0, 32, 0, 86, 0, 101, 0, 114, 0, 115, 0, 105, 0, 111, 0, 110, 0, 32, 0, 111, 0, 102, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 32, 0, 109, 0, 97, 0, 121, 0, 32, 0, 117, 0, 115, 0, 101, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 82, 0, 101, 0, 115, 0, 101, 0, 114, 0, 118, 0, 101, 0, 100, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 78, 0, 97, 0, 109, 0, 101, 0, 40, 0, 115, 0, 41, 0, 32, 0, 117, 0, 110, 0, 108, 0, 101, 0, 115, 0, 115, 0, 32, 0, 101, 0, 120, 0, 112, 0, 108, 0, 105, 0, 99, 0, 105, 0, 116, 0, 32, 0, 119, 0, 114, 0, 105, 0, 116, 0, 116, 0, 101, 0, 110, 0, 32, 0, 112, 0, 101, 0, 114, 0, 109, 0, 105, 0, 115, 0, 115, 0, 105, 0, 111, 0, 110, 0, 32, 0, 105, 0, 115, 0, 32, 0, 103, 0, 114, 0, 97, 0, 110, 0, 116, 0, 101, 0, 100, 0, 32, 0, 98, 0, 121, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 99, 0, 111, 0, 114, 0, 114, 0, 101, 0, 115, 0, 112, 0, 111, 0, 110, 0, 100, 0, 105, 0, 110, 0, 103, 0, 32, 0, 67, 0, 111, 0, 112, 0, 121, 0, 114, 0, 105, 0, 103, 0, 104, 0, 116, 0, 32, 0, 72, 0, 111, 0, 108, 0, 100, 0, 101, 0, 114, 0, 46, 0, 32, 0, 84, 0, 104, 0, 105, 0, 115, 0, 32, 0, 114, 0, 101, 0, 115, 0, 116, 0, 114, 0, 105, 0, 99, 0, 116, 0, 105, 0, 111, 0, 110, 0, 32, 0, 111, 0, 110, 0, 108, 0, 121, 0, 32, 0, 97, 0, 112, 0, 112, 0, 108, 0, 105, 0, 101, 0, 115, 0, 32, 0, 116, 0, 111, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 112, 0, 114, 0, 105, 0, 109, 0, 97, 0, 114, 0, 121, 0, 32, 0, 102, 0, 111, 0, 110, 0, 116, 0, 32, 0, 110, 0, 97, 0, 109, 0, 101, 0, 32, 0, 97, 0, 115, 0, 32, 0, 112, 0, 114, 0, 101, 0, 115, 0, 101, 0, 110, 0, 116, 0, 101, 0, 100, 0, 32, 0, 116, 0, 111, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 117, 0, 115, 0, 101, 0, 114, 0, 115, 0, 46, 0, 13, 0, 13, 0, 52, 0, 41, 0, 32, 0, 84, 0, 104, 0, 101, 0, 32, 0, 110, 0, 97, 0, 109, 0, 101, 0, 40, 0, 115, 0, 41, 0, 32, 0, 111, 0, 102, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 67, 0, 111, 0, 112, 0, 121, 0, 114, 0, 105, 0, 103, 0, 104, 0, 116, 0, 32, 0, 72, 0, 111, 0, 108, 0, 100, 0, 101, 0, 114, 0, 40, 0, 115, 0, 41, 0, 32, 0, 111, 0, 114, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 65, 0, 117, 0, 116, 0, 104, 0, 111, 0, 114, 0, 40, 0, 115, 0, 41, 0, 32, 0, 111, 0, 102, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 32, 0, 115, 0, 104, 0, 97, 0, 108, 0, 108, 0, 32, 0, 110, 0, 111, 0, 116, 0, 32, 0, 98, 0, 101, 0, 32, 0, 117, 0, 115, 0, 101, 0, 100, 0, 32, 0, 116, 0, 111, 0, 32, 0, 112, 0, 114, 0, 111, 0, 109, 0, 111, 0, 116, 0, 101, 0, 44, 0, 32, 0, 101, 0, 110, 0, 100, 0, 111, 0, 114, 0, 115, 0, 101, 0, 32, 0, 111, 0, 114, 0, 32, 0, 97, 0, 100, 0, 118, 0, 101, 0, 114, 0, 116, 0, 105, 0, 115, 0, 101, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 77, 0, 111, 0, 100, 0, 105, 0, 102, 0, 105, 0, 101, 0, 100, 0, 32, 0, 86, 0, 101, 0, 114, 0, 115, 0, 105, 0, 111, 0, 110, 0, 44, 0, 32, 0, 101, 0, 120, 0, 99, 0, 101, 0, 112, 0, 116, 0, 32, 0, 116, 0, 111, 0, 32, 0, 97, 0, 99, 0, 107, 0, 110, 0, 111, 0, 119, 0, 108, 0, 101, 0, 100, 0, 103, 0, 101, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 99, 0, 111, 0, 110, 0, 116, 0, 114, 0, 105, 0, 98, 0, 117, 0, 116, 0, 105, 0, 111, 0, 110, 0, 40, 0, 115, 0, 41, 0, 32, 0, 111, 0, 102, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 67, 0, 111, 0, 112, 0, 121, 0, 114, 0, 105, 0, 103, 0, 104, 0, 116, 0, 32, 0, 72, 0, 111, 0, 108, 0, 100, 0, 101, 0, 114, 0, 40, 0, 115, 0, 41, 0, 32, 0, 97, 0, 110, 0, 100, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 65, 0, 117, 0, 116, 0, 104, 0, 111, 0, 114, 0, 40, 0, 115, 0, 41, 0, 32, 0, 111, 0, 114, 0, 32, 0, 119, 0, 105, 0, 116, 0, 104, 0, 32, 0, 116, 0, 104, 0, 101, 0, 105, 0, 114, 0, 32, 0, 101, 0, 120, 0, 112, 0, 108, 0, 105, 0, 99, 0, 105, 0, 116, 0, 32, 0, 119, 0, 114, 0, 105, 0, 116, 0, 116, 0, 101, 0, 110, 0, 32, 0, 112, 0, 101, 0, 114, 0, 109, 0, 105, 0, 115, 0, 115, 0, 105, 0, 111, 0, 110, 0, 46, 0, 13, 0, 13, 0, 53, 0, 41, 0, 32, 0, 84, 0, 104, 0, 101, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 44, 0, 32, 0, 109, 0, 111, 0, 100, 0, 105, 0, 102, 0, 105, 0, 101, 0, 100, 0, 32, 0, 111, 0, 114, 0, 32, 0, 117, 0, 110, 0, 109, 0, 111, 0, 100, 0, 105, 0, 102, 0, 105, 0, 101, 0, 100, 0, 44, 0, 32, 0, 105, 0, 110, 0, 32, 0, 112, 0, 97, 0, 114, 0, 116, 0, 32, 0, 111, 0, 114, 0, 32, 0, 105, 0, 110, 0, 32, 0, 119, 0, 104, 0, 111, 0, 108, 0, 101, 0, 44, 0, 32, 0, 109, 0, 117, 0, 115, 0, 116, 0, 32, 0, 98, 0, 101, 0, 32, 0, 100, 0, 105, 0, 115, 0, 116, 0, 114, 0, 105, 0, 98, 0, 117, 0, 116, 0, 101, 0, 100, 0, 32, 0, 101, 0, 110, 0, 116, 0, 105, 0, 114, 0, 101, 0, 108, 0, 121, 0, 32, 0, 117, 0, 110, 0, 100, 0, 101, 0, 114, 0, 32, 0, 116, 0, 104, 0, 105, 0, 115, 0, 32, 0, 108, 0, 105, 0, 99, 0, 101, 0, 110, 0, 115, 0, 101, 0, 44, 0, 32, 0, 97, 0, 110, 0, 100, 0, 32, 0, 109, 0, 117, 0, 115, 0, 116, 0, 32, 0, 110, 0, 111, 0, 116, 0, 32, 0, 98, 0, 101, 0, 32, 0, 100, 0, 105, 0, 115, 0, 116, 0, 114, 0, 105, 0, 98, 0, 117, 0, 116, 0, 101, 0, 100, 0, 32, 0, 117, 0, 110, 0, 100, 0, 101, 0, 114, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 111, 0, 116, 0, 104, 0, 101, 0, 114, 0, 32, 0, 108, 0, 105, 0, 99, 0, 101, 0, 110, 0, 115, 0, 101, 0, 46, 0, 32, 0, 84, 0, 104, 0, 101, 0, 32, 0, 114, 0, 101, 0, 113, 0, 117, 0, 105, 0, 114, 0, 101, 0, 109, 0, 101, 0, 110, 0, 116, 0, 32, 0, 102, 0, 111, 0, 114, 0, 32, 0, 102, 0, 111, 0, 110, 0, 116, 0, 115, 0, 32, 0, 116, 0, 111, 0, 32, 0, 114, 0, 101, 0, 109, 0, 97, 0, 105, 0, 110, 0, 32, 0, 117, 0, 110, 0, 100, 0, 101, 0, 114, 0, 32, 0, 116, 0, 104, 0, 105, 0, 115, 0, 32, 0, 108, 0, 105, 0, 99, 0, 101, 0, 110, 0, 115, 0, 101, 0, 32, 0, 100, 0, 111, 0, 101, 0, 115, 0, 32, 0, 110, 0, 111, 0, 116, 0, 32, 0, 97, 0, 112, 0, 112, 0, 108, 0, 121, 0, 32, 0, 116, 0, 111, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 100, 0, 111, 0, 99, 0, 117, 0, 109, 0, 101, 0, 110, 0, 116, 0, 32, 0, 99, 0, 114, 0, 101, 0, 97, 0, 116, 0, 101, 0, 100, 0, 32, 0, 117, 0, 115, 0, 105, 0, 110, 0, 103, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 46, 0, 13, 0, 13, 0, 84, 0, 69, 0, 82, 0, 77, 0, 73, 0, 78, 0, 65, 0, 84, 0, 73, 0, 79, 0, 78, 0, 32, 0, 84, 0, 104, 0, 105, 0, 115, 0, 32, 0, 108, 0, 105, 0, 99, 0, 101, 0, 110, 0, 115, 0, 101, 0, 32, 0, 98, 0, 101, 0, 99, 0, 111, 0, 109, 0, 101, 0, 115, 0, 32, 0, 110, 0, 117, 0, 108, 0, 108, 0, 32, 0, 97, 0, 110, 0, 100, 0, 32, 0, 118, 0, 111, 0, 105, 0, 100, 0, 32, 0, 105, 0, 102, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 111, 0, 102, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 97, 0, 98, 0, 111, 0, 118, 0, 101, 0, 32, 0, 99, 0, 111, 0, 110, 0, 100, 0, 105, 0, 116, 0, 105, 0, 111, 0, 110, 0, 115, 0, 32, 0, 97, 0, 114, 0, 101, 0, 32, 0, 110, 0, 111, 0, 116, 0, 32, 0, 109, 0, 101, 0, 116, 0, 46, 0, 13, 0, 13, 0, 68, 0, 73, 0, 83, 0, 67, 0, 76, 0, 65, 0, 73, 0, 77, 0, 69, 0, 82, 0, 32, 0, 84, 0, 72, 0, 69, 0, 32, 0, 70, 0, 79, 0, 78, 0, 84, 0, 32, 0, 83, 0, 79, 0, 70, 0, 84, 0, 87, 0, 65, 0, 82, 0, 69, 0, 32, 0, 73, 0, 83, 0, 32, 0, 80, 0, 82, 0, 79, 0, 86, 0, 73, 0, 68, 0, 69, 0, 68, 0, 32, 0, 34, 0, 65, 0, 83, 0, 32, 0, 73, 0, 83, 0, 34, 0, 44, 0, 32, 0, 87, 0, 73, 0, 84, 0, 72, 0, 79, 0, 85, 0, 84, 0, 32, 0, 87, 0, 65, 0, 82, 0, 82, 0, 65, 0, 78, 0, 84, 0, 89, 0, 32, 0, 79, 0, 70, 0, 32, 0, 65, 0, 78, 0, 89, 0, 32, 0, 75, 0, 73, 0, 78, 0, 68, 0, 44, 0, 32, 0, 69, 0, 88, 0, 80, 0, 82, 0, 69, 0, 83, 0, 83, 0, 32, 0, 79, 0, 82, 0, 32, 0, 73, 0, 77, 0, 80, 0, 76, 0, 73, 0, 69, 0, 68, 0, 44, 0, 32, 0, 73, 0, 78, 0, 67, 0, 76, 0, 85, 0, 68, 0, 73, 0, 78, 0, 71, 0, 32, 0, 66, 0, 85, 0, 84, 0, 32, 0, 78, 0, 79, 0, 84, 0, 32, 0, 76, 0, 73, 0, 77, 0, 73, 0, 84, 0, 69, 0, 68, 0, 32, 0, 84, 0, 79, 0, 32, 0, 65, 0, 78, 0, 89, 0, 32, 0, 87, 0, 65, 0, 82, 0, 82, 0, 65, 0, 78, 0, 84, 0, 73, 0, 69, 0, 83, 0, 32, 0, 79, 0, 70, 0, 32, 0, 77, 0, 69, 0, 82, 0, 67, 0, 72, 0, 65, 0, 78, 0, 84, 0, 65, 0, 66, 0, 73, 0, 76, 0, 73, 0, 84, 0, 89, 0, 44, 0, 32, 0, 70, 0, 73, 0, 84, 0, 78, 0, 69, 0, 83, 0, 83, 0, 32, 0, 70, 0, 79, 0, 82, 0, 32, 0, 65, 0, 32, 0, 80, 0, 65, 0, 82, 0, 84, 0, 73, 0, 67, 0, 85, 0, 76, 0, 65, 0, 82, 0, 32, 0, 80, 0, 85, 0, 82, 0, 80, 0, 79, 0, 83, 0, 69, 0, 32, 0, 65, 0, 78, 0, 68, 0, 32, 0, 78, 0, 79, 0, 78, 0, 73, 0, 78, 0, 70, 0, 82, 0, 73, 0, 78, 0, 71, 0, 69, 0, 77, 0, 69, 0, 78, 0, 84, 0, 32, 0, 79, 0, 70, 0, 32, 0, 67, 0, 79, 0, 80, 0, 89, 0, 82, 0, 73, 0, 71, 0, 72, 0, 84, 0, 44, 0, 32, 0, 80, 0, 65, 0, 84, 0, 69, 0, 78, 0, 84, 0, 44, 0, 32, 0, 84, 0, 82, 0, 65, 0, 68, 0, 69, 0, 77, 0, 65, 0, 82, 0, 75, 0, 44, 0, 32, 0, 79, 0, 82, 0, 32, 0, 79, 0, 84, 0, 72, 0, 69, 0, 82, 0, 32, 0, 82, 0, 73, 0, 71, 0, 72, 0, 84, 0, 46, 0, 32, 0, 73, 0, 78, 0, 32, 0, 78, 0, 79, 0, 32, 0, 69, 0, 86, 0, 69, 0, 78, 0, 84, 0, 32, 0, 83, 0, 72, 0, 65, 0, 76, 0, 76, 0, 32, 0, 84, 0, 72, 0, 69, 0, 32, 0, 67, 0, 79, 0, 80, 0, 89, 0, 82, 0, 73, 0, 71, 0, 72, 0, 84, 0, 32, 0, 72, 0, 79, 0, 76, 0, 68, 0, 69, 0, 82, 0, 32, 0, 66, 0, 69, 0, 32, 0, 76, 0, 73, 0, 65, 0, 66, 0, 76, 0, 69, 0, 32, 0, 70, 0, 79, 0, 82, 0, 32, 0, 65, 0, 78, 0, 89, 0, 32, 0, 67, 0, 76, 0, 65, 0, 73, 0, 77, 0, 44, 0, 32, 0, 68, 0, 65, 0, 77, 0, 65, 0, 71, 0, 69, 0, 83, 0, 32, 0, 79, 0, 82, 0, 32, 0, 79, 0, 84, 0, 72, 0, 69, 0, 82, 0, 32, 0, 76, 0, 73, 0, 65, 0, 66, 0, 73, 0, 76, 0, 73, 0, 84, 0, 89, 0, 44, 0, 32, 0, 73, 0, 78, 0, 67, 0, 76, 0, 85, 0, 68, 0, 73, 0, 78, 0, 71, 0, 32, 0, 65, 0, 78, 0, 89, 0, 32, 0, 71, 0, 69, 0, 78, 0, 69, 0, 82, 0, 65, 0, 76, 0, 44, 0, 32, 0, 83, 0, 80, 0, 69, 0, 67, 0, 73, 0, 65, 0, 76, 0, 44, 0, 32, 0, 73, 0, 78, 0, 68, 0, 73, 0, 82, 0, 69, 0, 67, 0, 84, 0, 44, 0, 32, 0, 73, 0, 78, 0, 67, 0, 73, 0, 68, 0, 69, 0, 78, 0, 84, 0, 65, 0, 76, 0, 44, 0, 32, 0, 79, 0, 82, 0, 32, 0, 67, 0, 79, 0, 78, 0, 83, 0, 69, 0, 81, 0, 85, 0, 69, 0, 78, 0, 84, 0, 73, 0, 65, 0, 76, 0, 32, 0, 68, 0, 65, 0, 77, 0, 65, 0, 71, 0, 69, 0, 83, 0, 44, 0, 32, 0, 87, 0, 72, 0, 69, 0, 84, 0, 72, 0, 69, 0, 82, 0, 32, 0, 73, 0, 78, 0, 32, 0, 65, 0, 78, 0, 32, 0, 65, 0, 67, 0, 84, 0, 73, 0, 79, 0, 78, 0, 32, 0, 79, 0, 70, 0, 32, 0, 67, 0, 79, 0, 78, 0, 84, 0, 82, 0, 65, 0, 67, 0, 84, 0, 44, 0, 32, 0, 84, 0, 79, 0, 82, 0, 84, 0, 32, 0, 79, 0, 82, 0, 32, 0, 79, 0, 84, 0, 72, 0, 69, 0, 82, 0, 87, 0, 73, 0, 83, 0, 69, 0, 44, 0, 32, 0, 65, 0, 82, 0, 73, 0, 83, 0, 73, 0, 78, 0, 71, 0, 32, 0, 70, 0, 82, 0, 79, 0, 77, 0, 44, 0, 32, 0, 79, 0, 85, 0, 84, 0, 32, 0, 79, 0, 70, 0, 32, 0, 84, 0, 72, 0, 69, 0, 32, 0, 85, 0, 83, 0, 69, 0, 32, 0, 79, 0, 82, 0, 32, 0, 73, 0, 78, 0, 65, 0, 66, 0, 73, 0, 76, 0, 73, 0, 84, 0, 89, 0, 32, 0, 84, 0, 79, 0, 32, 0, 85, 0, 83, 0, 69, 0, 32, 0, 84, 0, 72, 0, 69, 0, 32, 0, 70, 0, 79, 0, 78, 0, 84, 0, 32, 0, 83, 0, 79, 0, 70, 0, 84, 0, 87, 0, 65, 0, 82, 0, 69, 0, 32, 0, 79, 0, 82, 0, 32, 0, 70, 0, 82, 0, 79, 0, 77, 0, 32, 0, 79, 0, 84, 0, 72, 0, 69, 0, 82, 0, 32, 0, 68, 0, 69, 0, 65, 0, 76, 0, 73, 0, 78, 0, 71, 0, 83, 0, 32, 0, 73, 0, 78, 0, 32, 0, 84, 0, 72, 0, 69, 0, 32, 0, 70, 0, 79, 0, 78, 0, 84, 0, 32, 0, 83, 0, 79, 0, 70, 0, 84, 0, 87, 0, 65, 0, 82, 0, 69, 0, 46, 0, 13, 0, 32, 0, 112, 0, 97, 0, 114, 0, 116, 0, 32, 0, 111, 0, 114, 0, 32, 0, 105, 0, 110, 0, 32, 0, 119, 0, 104, 0, 111, 0, 108, 0, 101, 0, 32, 0, 45, 0, 45, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 111, 0, 102, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 99, 0, 111, 0, 109, 0, 112, 0, 111, 0, 110, 0, 101, 0, 110, 0, 116, 0, 115, 0, 32, 0, 111, 0, 102, 0, 32, 0, 116, 0, 104, 0, 101, 0, 13, 0, 13, 0, 79, 0, 114, 0, 105, 0, 103, 0, 105, 0, 110, 0, 97, 0, 108, 0, 32, 0, 86, 0, 101, 0, 114, 0, 115, 0, 105, 0, 111, 0, 110, 0, 44, 0, 32, 0, 98, 0, 121, 0, 32, 0, 99, 0, 104, 0, 97, 0, 110, 0, 103, 0, 105, 0, 110, 0, 103, 0, 32, 0, 102, 0, 111, 0, 114, 0, 109, 0, 97, 0, 116, 0, 115, 0, 32, 0, 111, 0, 114, 0, 32, 0, 98, 0, 121, 0, 32, 0, 112, 0, 111, 0, 114, 0, 116, 0, 105, 0, 110, 0, 103, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 32, 0, 116, 0, 111, 0, 32, 0, 97, 0, 13, 0, 13, 0, 110, 0, 101, 0, 119, 0, 32, 0, 101, 0, 110, 0, 118, 0, 105, 0, 114, 0, 111, 0, 110, 0, 109, 0, 101, 0, 110, 0, 116, 0, 46, 0, 13, 0, 13, 0, 13, 0, 13, 0, 34, 0, 65, 0, 117, 0, 116, 0, 104, 0, 111, 0, 114, 0, 34, 0, 32, 0, 114, 0, 101, 0, 102, 0, 101, 0, 114, 0, 115, 0, 32, 0, 116, 0, 111, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 100, 0, 101, 0, 115, 0, 105, 0, 103, 0, 110, 0, 101, 0, 114, 0, 44, 0, 32, 0, 101, 0, 110, 0, 103, 0, 105, 0, 110, 0, 101, 0, 101, 0, 114, 0, 44, 0, 32, 0, 112, 0, 114, 0, 111, 0, 103, 0, 114, 0, 97, 0, 109, 0, 109, 0, 101, 0, 114, 0, 44, 0, 32, 0, 116, 0, 101, 0, 99, 0, 104, 0, 110, 0, 105, 0, 99, 0, 97, 0, 108, 0, 13, 0, 13, 0, 119, 0, 114, 0, 105, 0, 116, 0, 101, 0, 114, 0, 32, 0, 111, 0, 114, 0, 32, 0, 111, 0, 116, 0, 104, 0, 101, 0, 114, 0, 32, 0, 112, 0, 101, 0, 114, 0, 115, 0, 111, 0, 110, 0, 32, 0, 119, 0, 104, 0, 111, 0, 32, 0, 99, 0, 111, 0, 110, 0, 116, 0, 114, 0, 105, 0, 98, 0, 117, 0, 116, 0, 101, 0, 100, 0, 32, 0, 116, 0, 111, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 46, 0, 13, 0, 13, 0, 13, 0, 13, 0, 80, 0, 69, 0, 82, 0, 77, 0, 73, 0, 83, 0, 83, 0, 73, 0, 79, 0, 78, 0, 32, 0, 38, 0, 32, 0, 67, 0, 79, 0, 78, 0, 68, 0, 73, 0, 84, 0, 73, 0, 79, 0, 78, 0, 83, 0, 13, 0, 13, 0, 80, 0, 101, 0, 114, 0, 109, 0, 105, 0, 115, 0, 115, 0, 105, 0, 111, 0, 110, 0, 32, 0, 105, 0, 115, 0, 32, 0, 104, 0, 101, 0, 114, 0, 101, 0, 98, 0, 121, 0, 32, 0, 103, 0, 114, 0, 97, 0, 110, 0, 116, 0, 101, 0, 100, 0, 44, 0, 32, 0, 102, 0, 114, 0, 101, 0, 101, 0, 32, 0, 111, 0, 102, 0, 32, 0, 99, 0, 104, 0, 97, 0, 114, 0, 103, 0, 101, 0, 44, 0, 32, 0, 116, 0, 111, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 112, 0, 101, 0, 114, 0, 115, 0, 111, 0, 110, 0, 32, 0, 111, 0, 98, 0, 116, 0, 97, 0, 105, 0, 110, 0, 105, 0, 110, 0, 103, 0, 13, 0, 13, 0, 97, 0, 32, 0, 99, 0, 111, 0, 112, 0, 121, 0, 32, 0, 111, 0, 102, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 44, 0, 32, 0, 116, 0, 111, 0, 32, 0, 117, 0, 115, 0, 101, 0, 44, 0, 32, 0, 115, 0, 116, 0, 117, 0, 100, 0, 121, 0, 44, 0, 32, 0, 99, 0, 111, 0, 112, 0, 121, 0, 44, 0, 32, 0, 109, 0, 101, 0, 114, 0, 103, 0, 101, 0, 44, 0, 32, 0, 101, 0, 109, 0, 98, 0, 101, 0, 100, 0, 44, 0, 32, 0, 109, 0, 111, 0, 100, 0, 105, 0, 102, 0, 121, 0, 44, 0, 13, 0, 13, 0, 114, 0, 101, 0, 100, 0, 105, 0, 115, 0, 116, 0, 114, 0, 105, 0, 98, 0, 117, 0, 116, 0, 101, 0, 44, 0, 32, 0, 97, 0, 110, 0, 100, 0, 32, 0, 115, 0, 101, 0, 108, 0, 108, 0, 32, 0, 109, 0, 111, 0, 100, 0, 105, 0, 102, 0, 105, 0, 101, 0, 100, 0, 32, 0, 97, 0, 110, 0, 100, 0, 32, 0, 117, 0, 110, 0, 109, 0, 111, 0, 100, 0, 105, 0, 102, 0, 105, 0, 101, 0, 100, 0, 32, 0, 99, 0, 111, 0, 112, 0, 105, 0, 101, 0, 115, 0, 32, 0, 111, 0, 102, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 13, 0, 13, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 44, 0, 32, 0, 115, 0, 117, 0, 98, 0, 106, 0, 101, 0, 99, 0, 116, 0, 32, 0, 116, 0, 111, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 102, 0, 111, 0, 108, 0, 108, 0, 111, 0, 119, 0, 105, 0, 110, 0, 103, 0, 32, 0, 99, 0, 111, 0, 110, 0, 100, 0, 105, 0, 116, 0, 105, 0, 111, 0, 110, 0, 115, 0, 58, 0, 13, 0, 13, 0, 13, 0, 13, 0, 49, 0, 41, 0, 32, 0, 78, 0, 101, 0, 105, 0, 116, 0, 104, 0, 101, 0, 114, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 32, 0, 110, 0, 111, 0, 114, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 111, 0, 102, 0, 32, 0, 105, 0, 116, 0, 115, 0, 32, 0, 105, 0, 110, 0, 100, 0, 105, 0, 118, 0, 105, 0, 100, 0, 117, 0, 97, 0, 108, 0, 32, 0, 99, 0, 111, 0, 109, 0, 112, 0, 111, 0, 110, 0, 101, 0, 110, 0, 116, 0, 115, 0, 44, 0, 13, 0, 13, 0, 105, 0, 110, 0, 32, 0, 79, 0, 114, 0, 105, 0, 103, 0, 105, 0, 110, 0, 97, 0, 108, 0, 32, 0, 111, 0, 114, 0, 32, 0, 77, 0, 111, 0, 100, 0, 105, 0, 102, 0, 105, 0, 101, 0, 100, 0, 32, 0, 86, 0, 101, 0, 114, 0, 115, 0, 105, 0, 111, 0, 110, 0, 115, 0, 44, 0, 32, 0, 109, 0, 97, 0, 121, 0, 32, 0, 98, 0, 101, 0, 32, 0, 115, 0, 111, 0, 108, 0, 100, 0, 32, 0, 98, 0, 121, 0, 32, 0, 105, 0, 116, 0, 115, 0, 101, 0, 108, 0, 102, 0, 46, 0, 13, 0, 13, 0, 13, 0, 13, 0, 50, 0, 41, 0, 32, 0, 79, 0, 114, 0, 105, 0, 103, 0, 105, 0, 110, 0, 97, 0, 108, 0, 32, 0, 111, 0, 114, 0, 32, 0, 77, 0, 111, 0, 100, 0, 105, 0, 102, 0, 105, 0, 101, 0, 100, 0, 32, 0, 86, 0, 101, 0, 114, 0, 115, 0, 105, 0, 111, 0, 110, 0, 115, 0, 32, 0, 111, 0, 102, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 32, 0, 109, 0, 97, 0, 121, 0, 32, 0, 98, 0, 101, 0, 32, 0, 98, 0, 117, 0, 110, 0, 100, 0, 108, 0, 101, 0, 100, 0, 44, 0, 13, 0, 13, 0, 114, 0, 101, 0, 100, 0, 105, 0, 115, 0, 116, 0, 114, 0, 105, 0, 98, 0, 117, 0, 116, 0, 101, 0, 100, 0, 32, 0, 97, 0, 110, 0, 100, 0, 47, 0, 111, 0, 114, 0, 32, 0, 115, 0, 111, 0, 108, 0, 100, 0, 32, 0, 119, 0, 105, 0, 116, 0, 104, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 115, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 44, 0, 32, 0, 112, 0, 114, 0, 111, 0, 118, 0, 105, 0, 100, 0, 101, 0, 100, 0, 32, 0, 116, 0, 104, 0, 97, 0, 116, 0, 32, 0, 101, 0, 97, 0, 99, 0, 104, 0, 32, 0, 99, 0, 111, 0, 112, 0, 121, 0, 13, 0, 13, 0, 99, 0, 111, 0, 110, 0, 116, 0, 97, 0, 105, 0, 110, 0, 115, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 97, 0, 98, 0, 111, 0, 118, 0, 101, 0, 32, 0, 99, 0, 111, 0, 112, 0, 121, 0, 114, 0, 105, 0, 103, 0, 104, 0, 116, 0, 32, 0, 110, 0, 111, 0, 116, 0, 105, 0, 99, 0, 101, 0, 32, 0, 97, 0, 110, 0, 100, 0, 32, 0, 116, 0, 104, 0, 105, 0, 115, 0, 32, 0, 108, 0, 105, 0, 99, 0, 101, 0, 110, 0, 115, 0, 101, 0, 46, 0, 32, 0, 84, 0, 104, 0, 101, 0, 115, 0, 101, 0, 32, 0, 99, 0, 97, 0, 110, 0, 32, 0, 98, 0, 101, 0, 13, 0, 13, 0, 105, 0, 110, 0, 99, 0, 108, 0, 117, 0, 100, 0, 101, 0, 100, 0, 32, 0, 101, 0, 105, 0, 116, 0, 104, 0, 101, 0, 114, 0, 32, 0, 97, 0, 115, 0, 32, 0, 115, 0, 116, 0, 97, 0, 110, 0, 100, 0, 45, 0, 97, 0, 108, 0, 111, 0, 110, 0, 101, 0, 32, 0, 116, 0, 101, 0, 120, 0, 116, 0, 32, 0, 102, 0, 105, 0, 108, 0, 101, 0, 115, 0, 44, 0, 32, 0, 104, 0, 117, 0, 109, 0, 97, 0, 110, 0, 45, 0, 114, 0, 101, 0, 97, 0, 100, 0, 97, 0, 98, 0, 108, 0, 101, 0, 32, 0, 104, 0, 101, 0, 97, 0, 100, 0, 101, 0, 114, 0, 115, 0, 32, 0, 111, 0, 114, 0, 13, 0, 13, 0, 105, 0, 110, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 97, 0, 112, 0, 112, 0, 114, 0, 111, 0, 112, 0, 114, 0, 105, 0, 97, 0, 116, 0, 101, 0, 32, 0, 109, 0, 97, 0, 99, 0, 104, 0, 105, 0, 110, 0, 101, 0, 45, 0, 114, 0, 101, 0, 97, 0, 100, 0, 97, 0, 98, 0, 108, 0, 101, 0, 32, 0, 109, 0, 101, 0, 116, 0, 97, 0, 100, 0, 97, 0, 116, 0, 97, 0, 32, 0, 102, 0, 105, 0, 101, 0, 108, 0, 100, 0, 115, 0, 32, 0, 119, 0, 105, 0, 116, 0, 104, 0, 105, 0, 110, 0, 32, 0, 116, 0, 101, 0, 120, 0, 116, 0, 32, 0, 111, 0, 114, 0, 13, 0, 13, 0, 98, 0, 105, 0, 110, 0, 97, 0, 114, 0, 121, 0, 32, 0, 102, 0, 105, 0, 108, 0, 101, 0, 115, 0, 32, 0, 97, 0, 115, 0, 32, 0, 108, 0, 111, 0, 110, 0, 103, 0, 32, 0, 97, 0, 115, 0, 32, 0, 116, 0, 104, 0, 111, 0, 115, 0, 101, 0, 32, 0, 102, 0, 105, 0, 101, 0, 108, 0, 100, 0, 115, 0, 32, 0, 99, 0, 97, 0, 110, 0, 32, 0, 98, 0, 101, 0, 32, 0, 101, 0, 97, 0, 115, 0, 105, 0, 108, 0, 121, 0, 32, 0, 118, 0, 105, 0, 101, 0, 119, 0, 101, 0, 100, 0, 32, 0, 98, 0, 121, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 117, 0, 115, 0, 101, 0, 114, 0, 46, 0, 13, 0, 13, 0, 13, 0, 13, 0, 51, 0, 41, 0, 32, 0, 78, 0, 111, 0, 32, 0, 77, 0, 111, 0, 100, 0, 105, 0, 102, 0, 105, 0, 101, 0, 100, 0, 32, 0, 86, 0, 101, 0, 114, 0, 115, 0, 105, 0, 111, 0, 110, 0, 32, 0, 111, 0, 102, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 32, 0, 109, 0, 97, 0, 121, 0, 32, 0, 117, 0, 115, 0, 101, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 82, 0, 101, 0, 115, 0, 101, 0, 114, 0, 118, 0, 101, 0, 100, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 13, 0, 13, 0, 78, 0, 97, 0, 109, 0, 101, 0, 40, 0, 115, 0, 41, 0, 32, 0, 117, 0, 110, 0, 108, 0, 101, 0, 115, 0, 115, 0, 32, 0, 101, 0, 120, 0, 112, 0, 108, 0, 105, 0, 99, 0, 105, 0, 116, 0, 32, 0, 119, 0, 114, 0, 105, 0, 116, 0, 116, 0, 101, 0, 110, 0, 32, 0, 112, 0, 101, 0, 114, 0, 109, 0, 105, 0, 115, 0, 115, 0, 105, 0, 111, 0, 110, 0, 32, 0, 105, 0, 115, 0, 32, 0, 103, 0, 114, 0, 97, 0, 110, 0, 116, 0, 101, 0, 100, 0, 32, 0, 98, 0, 121, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 99, 0, 111, 0, 114, 0, 114, 0, 101, 0, 115, 0, 112, 0, 111, 0, 110, 0, 100, 0, 105, 0, 110, 0, 103, 0, 13, 0, 13, 0, 67, 0, 111, 0, 112, 0, 121, 0, 114, 0, 105, 0, 103, 0, 104, 0, 116, 0, 32, 0, 72, 0, 111, 0, 108, 0, 100, 0, 101, 0, 114, 0, 46, 0, 32, 0, 84, 0, 104, 0, 105, 0, 115, 0, 32, 0, 114, 0, 101, 0, 115, 0, 116, 0, 114, 0, 105, 0, 99, 0, 116, 0, 105, 0, 111, 0, 110, 0, 32, 0, 111, 0, 110, 0, 108, 0, 121, 0, 32, 0, 97, 0, 112, 0, 112, 0, 108, 0, 105, 0, 101, 0, 115, 0, 32, 0, 116, 0, 111, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 112, 0, 114, 0, 105, 0, 109, 0, 97, 0, 114, 0, 121, 0, 32, 0, 102, 0, 111, 0, 110, 0, 116, 0, 32, 0, 110, 0, 97, 0, 109, 0, 101, 0, 32, 0, 97, 0, 115, 0, 13, 0, 13, 0, 112, 0, 114, 0, 101, 0, 115, 0, 101, 0, 110, 0, 116, 0, 101, 0, 100, 0, 32, 0, 116, 0, 111, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 117, 0, 115, 0, 101, 0, 114, 0, 115, 0, 46, 0, 13, 0, 13, 0, 13, 0, 13, 0, 52, 0, 41, 0, 32, 0, 84, 0, 104, 0, 101, 0, 32, 0, 110, 0, 97, 0, 109, 0, 101, 0, 40, 0, 115, 0, 41, 0, 32, 0, 111, 0, 102, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 67, 0, 111, 0, 112, 0, 121, 0, 114, 0, 105, 0, 103, 0, 104, 0, 116, 0, 32, 0, 72, 0, 111, 0, 108, 0, 100, 0, 101, 0, 114, 0, 40, 0, 115, 0, 41, 0, 32, 0, 111, 0, 114, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 65, 0, 117, 0, 116, 0, 104, 0, 111, 0, 114, 0, 40, 0, 115, 0, 41, 0, 32, 0, 111, 0, 102, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 13, 0, 13, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 32, 0, 115, 0, 104, 0, 97, 0, 108, 0, 108, 0, 32, 0, 110, 0, 111, 0, 116, 0, 32, 0, 98, 0, 101, 0, 32, 0, 117, 0, 115, 0, 101, 0, 100, 0, 32, 0, 116, 0, 111, 0, 32, 0, 112, 0, 114, 0, 111, 0, 109, 0, 111, 0, 116, 0, 101, 0, 44, 0, 32, 0, 101, 0, 110, 0, 100, 0, 111, 0, 114, 0, 115, 0, 101, 0, 32, 0, 111, 0, 114, 0, 32, 0, 97, 0, 100, 0, 118, 0, 101, 0, 114, 0, 116, 0, 105, 0, 115, 0, 101, 0, 32, 0, 97, 0, 110, 0, 121, 0, 13, 0, 13, 0, 77, 0, 111, 0, 100, 0, 105, 0, 102, 0, 105, 0, 101, 0, 100, 0, 32, 0, 86, 0, 101, 0, 114, 0, 115, 0, 105, 0, 111, 0, 110, 0, 44, 0, 32, 0, 101, 0, 120, 0, 99, 0, 101, 0, 112, 0, 116, 0, 32, 0, 116, 0, 111, 0, 32, 0, 97, 0, 99, 0, 107, 0, 110, 0, 111, 0, 119, 0, 108, 0, 101, 0, 100, 0, 103, 0, 101, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 99, 0, 111, 0, 110, 0, 116, 0, 114, 0, 105, 0, 98, 0, 117, 0, 116, 0, 105, 0, 111, 0, 110, 0, 40, 0, 115, 0, 41, 0, 32, 0, 111, 0, 102, 0, 32, 0, 116, 0, 104, 0, 101, 0, 13, 0, 13, 0, 67, 0, 111, 0, 112, 0, 121, 0, 114, 0, 105, 0, 103, 0, 104, 0, 116, 0, 32, 0, 72, 0, 111, 0, 108, 0, 100, 0, 101, 0, 114, 0, 40, 0, 115, 0, 41, 0, 32, 0, 97, 0, 110, 0, 100, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 65, 0, 117, 0, 116, 0, 104, 0, 111, 0, 114, 0, 40, 0, 115, 0, 41, 0, 32, 0, 111, 0, 114, 0, 32, 0, 119, 0, 105, 0, 116, 0, 104, 0, 32, 0, 116, 0, 104, 0, 101, 0, 105, 0, 114, 0, 32, 0, 101, 0, 120, 0, 112, 0, 108, 0, 105, 0, 99, 0, 105, 0, 116, 0, 32, 0, 119, 0, 114, 0, 105, 0, 116, 0, 116, 0, 101, 0, 110, 0, 13, 0, 13, 0, 112, 0, 101, 0, 114, 0, 109, 0, 105, 0, 115, 0, 115, 0, 105, 0, 111, 0, 110, 0, 46, 0, 13, 0, 13, 0, 13, 0, 13, 0, 53, 0, 41, 0, 32, 0, 84, 0, 104, 0, 101, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 44, 0, 32, 0, 109, 0, 111, 0, 100, 0, 105, 0, 102, 0, 105, 0, 101, 0, 100, 0, 32, 0, 111, 0, 114, 0, 32, 0, 117, 0, 110, 0, 109, 0, 111, 0, 100, 0, 105, 0, 102, 0, 105, 0, 101, 0, 100, 0, 44, 0, 32, 0, 105, 0, 110, 0, 32, 0, 112, 0, 97, 0, 114, 0, 116, 0, 32, 0, 111, 0, 114, 0, 32, 0, 105, 0, 110, 0, 32, 0, 119, 0, 104, 0, 111, 0, 108, 0, 101, 0, 44, 0, 13, 0, 13, 0, 109, 0, 117, 0, 115, 0, 116, 0, 32, 0, 98, 0, 101, 0, 32, 0, 100, 0, 105, 0, 115, 0, 116, 0, 114, 0, 105, 0, 98, 0, 117, 0, 116, 0, 101, 0, 100, 0, 32, 0, 101, 0, 110, 0, 116, 0, 105, 0, 114, 0, 101, 0, 108, 0, 121, 0, 32, 0, 117, 0, 110, 0, 100, 0, 101, 0, 114, 0, 32, 0, 116, 0, 104, 0, 105, 0, 115, 0, 32, 0, 108, 0, 105, 0, 99, 0, 101, 0, 110, 0, 115, 0, 101, 0, 44, 0, 32, 0, 97, 0, 110, 0, 100, 0, 32, 0, 109, 0, 117, 0, 115, 0, 116, 0, 32, 0, 110, 0, 111, 0, 116, 0, 32, 0, 98, 0, 101, 0, 13, 0, 13, 0, 100, 0, 105, 0, 115, 0, 116, 0, 114, 0, 105, 0, 98, 0, 117, 0, 116, 0, 101, 0, 100, 0, 32, 0, 117, 0, 110, 0, 100, 0, 101, 0, 114, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 111, 0, 116, 0, 104, 0, 101, 0, 114, 0, 32, 0, 108, 0, 105, 0, 99, 0, 101, 0, 110, 0, 115, 0, 101, 0, 46, 0, 32, 0, 84, 0, 104, 0, 101, 0, 32, 0, 114, 0, 101, 0, 113, 0, 117, 0, 105, 0, 114, 0, 101, 0, 109, 0, 101, 0, 110, 0, 116, 0, 32, 0, 102, 0, 111, 0, 114, 0, 32, 0, 102, 0, 111, 0, 110, 0, 116, 0, 115, 0, 32, 0, 116, 0, 111, 0, 13, 0, 13, 0, 114, 0, 101, 0, 109, 0, 97, 0, 105, 0, 110, 0, 32, 0, 117, 0, 110, 0, 100, 0, 101, 0, 114, 0, 32, 0, 116, 0, 104, 0, 105, 0, 115, 0, 32, 0, 108, 0, 105, 0, 99, 0, 101, 0, 110, 0, 115, 0, 101, 0, 32, 0, 100, 0, 111, 0, 101, 0, 115, 0, 32, 0, 110, 0, 111, 0, 116, 0, 32, 0, 97, 0, 112, 0, 112, 0, 108, 0, 121, 0, 32, 0, 116, 0, 111, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 100, 0, 111, 0, 99, 0, 117, 0, 109, 0, 101, 0, 110, 0, 116, 0, 32, 0, 99, 0, 114, 0, 101, 0, 97, 0, 116, 0, 101, 0, 100, 0, 13, 0, 13, 0, 117, 0, 115, 0, 105, 0, 110, 0, 103, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 70, 0, 111, 0, 110, 0, 116, 0, 32, 0, 83, 0, 111, 0, 102, 0, 116, 0, 119, 0, 97, 0, 114, 0, 101, 0, 46, 0, 13, 0, 13, 0, 13, 0, 13, 0, 84, 0, 69, 0, 82, 0, 77, 0, 73, 0, 78, 0, 65, 0, 84, 0, 73, 0, 79, 0, 78, 0, 13, 0, 13, 0, 84, 0, 104, 0, 105, 0, 115, 0, 32, 0, 108, 0, 105, 0, 99, 0, 101, 0, 110, 0, 115, 0, 101, 0, 32, 0, 98, 0, 101, 0, 99, 0, 111, 0, 109, 0, 101, 0, 115, 0, 32, 0, 110, 0, 117, 0, 108, 0, 108, 0, 32, 0, 97, 0, 110, 0, 100, 0, 32, 0, 118, 0, 111, 0, 105, 0, 100, 0, 32, 0, 105, 0, 102, 0, 32, 0, 97, 0, 110, 0, 121, 0, 32, 0, 111, 0, 102, 0, 32, 0, 116, 0, 104, 0, 101, 0, 32, 0, 97, 0, 98, 0, 111, 0, 118, 0, 101, 0, 32, 0, 99, 0, 111, 0, 110, 0, 100, 0, 105, 0, 116, 0, 105, 0, 111, 0, 110, 0, 115, 0, 32, 0, 97, 0, 114, 0, 101, 0, 13, 0, 13, 0, 110, 0, 111, 0, 116, 0, 32, 0, 109, 0, 101, 0, 116, 0, 46, 0, 13, 0, 13, 0, 13, 0, 13, 0, 68, 0, 73, 0, 83, 0, 67, 0, 76, 0, 65, 0, 73, 0, 77, 0, 69, 0, 82, 0, 13, 0, 13, 0, 84, 0, 72, 0, 69, 0, 32, 0, 70, 0, 79, 0, 78, 0, 84, 0, 32, 0, 83, 0, 79, 0, 70, 0, 84, 0, 87, 0, 65, 0, 82, 0, 69, 0, 32, 0, 73, 0, 83, 0, 32, 0, 80, 0, 82, 0, 79, 0, 86, 0, 73, 0, 68, 0, 69, 0, 68, 0, 32, 0, 34, 0, 65, 0, 83, 0, 32, 0, 73, 0, 83, 0, 34, 0, 44, 0, 32, 0, 87, 0, 73, 0, 84, 0, 72, 0, 79, 0, 85, 0, 84, 0, 32, 0, 87, 0, 65, 0, 82, 0, 82, 0, 65, 0, 78, 0, 84, 0, 89, 0, 32, 0, 79, 0, 70, 0, 32, 0, 65, 0, 78, 0, 89, 0, 32, 0, 75, 0, 73, 0, 78, 0, 68, 0, 44, 0, 13, 0, 13, 0, 69, 0, 88, 0, 80, 0, 82, 0, 69, 0, 83, 0, 83, 0, 32, 0, 79, 0, 82, 0, 32, 0, 73, 0, 77, 0, 80, 0, 76, 0, 73, 0, 69, 0, 68, 0, 44, 0, 32, 0, 73, 0, 78, 0, 67, 0, 76, 0, 85, 0, 68, 0, 73, 0, 78, 0, 71, 0, 32, 0, 66, 0, 85, 0, 84, 0, 32, 0, 78, 0, 79, 0, 84, 0, 32, 0, 76, 0, 73, 0, 77, 0, 73, 0, 84, 0, 69, 0, 68, 0, 32, 0, 84, 0, 79, 0, 32, 0, 65, 0, 78, 0, 89, 0, 32, 0, 87, 0, 65, 0, 82, 0, 82, 0, 65, 0, 78, 0, 84, 0, 73, 0, 69, 0, 83, 0, 32, 0, 79, 0, 70, 0, 13, 0, 13, 0, 77, 0, 69, 0, 82, 0, 67, 0, 72, 0, 65, 0, 78, 0, 84, 0, 65, 0, 66, 0, 73, 0, 76, 0, 73, 0, 84, 0, 89, 0, 44, 0, 32, 0, 70, 0, 73, 0, 84, 0, 78, 0, 69, 0, 83, 0, 83, 0, 32, 0, 70, 0, 79, 0, 82, 0, 32, 0, 65, 0, 32, 0, 80, 0, 65, 0, 82, 0, 84, 0, 73, 0, 67, 0, 85, 0, 76, 0, 65, 0, 82, 0, 32, 0, 80, 0, 85, 0, 82, 0, 80, 0, 79, 0, 83, 0, 69, 0, 32, 0, 65, 0, 78, 0, 68, 0, 32, 0, 78, 0, 79, 0, 78, 0, 73, 0, 78, 0, 70, 0, 82, 0, 73, 0, 78, 0, 71, 0, 69, 0, 77, 0, 69, 0, 78, 0, 84, 0, 13, 0, 13, 0, 79, 0, 70, 0, 32, 0, 67, 0, 79, 0, 80, 0, 89, 0, 82, 0, 73, 0, 71, 0, 72, 0, 84, 0, 44, 0, 32, 0, 80, 0, 65, 0, 84, 0, 69, 0, 78, 0, 84, 0, 44, 0, 32, 0, 84, 0, 82, 0, 65, 0, 68, 0, 69, 0, 77, 0, 65, 0, 82, 0, 75, 0, 44, 0, 32, 0, 79, 0, 82, 0, 32, 0, 79, 0, 84, 0, 72, 0, 69, 0, 82, 0, 32, 0, 82, 0, 73, 0, 71, 0, 72, 0, 84, 0, 46, 0, 32, 0, 73, 0, 78, 0, 32, 0, 78, 0, 79, 0, 32, 0, 69, 0, 86, 0, 69, 0, 78, 0, 84, 0, 32, 0, 83, 0, 72, 0, 65, 0, 76, 0, 76, 0, 32, 0, 84, 0, 72, 0, 69, 0, 13, 0, 13, 0, 67, 0, 79, 0, 80, 0, 89, 0, 82, 0, 73, 0, 71, 0, 72, 0, 84, 0, 32, 0, 72, 0, 79, 0, 76, 0, 68, 0, 69, 0, 82, 0, 32, 0, 66, 0, 69, 0, 32, 0, 76, 0, 73, 0, 65, 0, 66, 0, 76, 0, 69, 0, 32, 0, 70, 0, 79, 0, 82, 0, 32, 0, 65, 0, 78, 0, 89, 0, 32, 0, 67, 0, 76, 0, 65, 0, 73, 0, 77, 0, 44, 0, 32, 0, 68, 0, 65, 0, 77, 0, 65, 0, 71, 0, 69, 0, 83, 0, 32, 0, 79, 0, 82, 0, 32, 0, 79, 0, 84, 0, 72, 0, 69, 0, 82, 0, 32, 0, 76, 0, 73, 0, 65, 0, 66, 0, 73, 0, 76, 0, 73, 0, 84, 0, 89, 0, 44, 0, 13, 0, 13, 0, 73, 0, 78, 0, 67, 0, 76, 0, 85, 0, 68, 0, 73, 0, 78, 0, 71, 0, 32, 0, 65, 0, 78, 0, 89, 0, 32, 0, 71, 0, 69, 0, 78, 0, 69, 0, 82, 0, 65, 0, 76, 0, 44, 0, 32, 0, 83, 0, 80, 0, 69, 0, 67, 0, 73, 0, 65, 0, 76, 0, 44, 0, 32, 0, 73, 0, 78, 0, 68, 0, 73, 0, 82, 0, 69, 0, 67, 0, 84, 0, 44, 0, 32, 0, 73, 0, 78, 0, 67, 0, 73, 0, 68, 0, 69, 0, 78, 0, 84, 0, 65, 0, 76, 0, 44, 0, 32, 0, 79, 0, 82, 0, 32, 0, 67, 0, 79, 0, 78, 0, 83, 0, 69, 0, 81, 0, 85, 0, 69, 0, 78, 0, 84, 0, 73, 0, 65, 0, 76, 0, 13, 0, 13, 0, 68, 0, 65, 0, 77, 0, 65, 0, 71, 0, 69, 0, 83, 0, 44, 0, 32, 0, 87, 0, 72, 0, 69, 0, 84, 0, 72, 0, 69, 0, 82, 0, 32, 0, 73, 0, 78, 0, 32, 0, 65, 0, 78, 0, 32, 0, 65, 0, 67, 0, 84, 0, 73, 0, 79, 0, 78, 0, 32, 0, 79, 0, 70, 0, 32, 0, 67, 0, 79, 0, 78, 0, 84, 0, 82, 0, 65, 0, 67, 0, 84, 0, 44, 0, 32, 0, 84, 0, 79, 0, 82, 0, 84, 0, 32, 0, 79, 0, 82, 0, 32, 0, 79, 0, 84, 0, 72, 0, 69, 0, 82, 0, 87, 0, 73, 0, 83, 0, 69, 0, 44, 0, 32, 0, 65, 0, 82, 0, 73, 0, 83, 0, 73, 0, 78, 0, 71, 0, 13, 0, 13, 0, 70, 0, 82, 0, 79, 0, 77, 0, 44, 0, 32, 0, 79, 0, 85, 0, 84, 0, 32, 0, 79, 0, 70, 0, 32, 0, 84, 0, 72, 0, 69, 0, 32, 0, 85, 0, 83, 0, 69, 0, 32, 0, 79, 0, 82, 0, 32, 0, 73, 0, 78, 0, 65, 0, 66, 0, 73, 0, 76, 0, 73, 0, 84, 0, 89, 0, 32, 0, 84, 0, 79, 0, 32, 0, 85, 0, 83, 0, 69, 0, 32, 0, 84, 0, 72, 0, 69, 0, 32, 0, 70, 0, 79, 0, 78, 0, 84, 0, 32, 0, 83, 0, 79, 0, 70, 0, 84, 0, 87, 0, 65, 0, 82, 0, 69, 0, 32, 0, 79, 0, 82, 0, 32, 0, 70, 0, 82, 0, 79, 0, 77, 0, 13, 0, 13, 0, 79, 0, 84, 0, 72, 0, 69, 0, 82, 0, 32, 0, 68, 0, 69, 0, 65, 0, 76, 0, 73, 0, 78, 0, 71, 0, 83, 0, 32, 0, 73, 0, 78, 0, 32, 0, 84, 0, 72, 0, 69, 0, 32, 0, 70, 0, 79, 0, 78, 0, 84, 0, 32, 0, 83, 0, 79, 0, 70, 0, 84, 0, 87, 0, 65, 0, 82, 0, 69, 0, 46, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 255, 69, 0, 123, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 112, 0, 0, 0, 1, 0, 2, 0, 3, 0, 6, 0, 7, 0, 8, 0, 9, 0, 10, 0, 11, 0, 12, 0, 13, 0, 14, 0, 15, 0, 16, 0, 17, 0, 18, 0, 19, 0, 20, 0, 21, 0, 22, 0, 23, 0, 24, 0, 25, 0, 26, 0, 27, 0, 28, 0, 29, 0, 30, 0, 31, 0, 32, 0, 33, 0, 34, 0, 35, 0, 36, 0, 37, 0, 38, 0, 39, 0, 40, 0, 41, 0, 42, 0, 43, 0, 44, 0, 45, 0, 46, 0, 47, 0, 48, 0, 49, 0, 50, 0, 51, 0, 52, 0, 53, 0, 54, 0, 55, 0, 56, 0, 57, 0, 58, 0, 59, 0, 60, 0, 61, 0, 62, 0, 63, 0, 64, 0, 65, 0, 66, 0, 67, 0, 68, 0, 69, 0, 70, 0, 71, 0, 72, 0, 73, 0, 74, 0, 75, 0, 76, 0, 77, 0, 78, 0, 79, 0, 80, 0, 81, 0, 82, 0, 83, 0, 84, 0, 85, 0, 86, 0, 87, 0, 88, 0, 89, 0, 90, 0, 91, 0, 92, 0, 93, 0, 94, 0, 95, 0, 96, 0, 97, 0, 98, 0, 99, 0, 100, 0, 101, 0, 102, 0, 103, 0, 104, 0, 105, 0, 106, 0, 107, 0, 108, 0, 109, 0, 110, 0, 111, 0, 112, 0, 113, 0, 114, 0, 115, 0, 116, 0, 117, 0, 118, 0, 119, 0, 120, 0, 121, 0, 122, 0, 123, 0, 124, 0, 125, 0, 126, 0, 127, 0, 128, 0, 129, 0, 130, 0, 131, 0, 132, 0, 133, 0, 134, 0, 135, 0, 136, 0, 137, 0, 138, 0, 139, 0, 140, 0, 141, 0, 142, 0, 143, 0, 144, 0, 145, 0, 146, 0, 147, 0, 148, 0, 149, 0, 150, 0, 151, 0, 152, 0, 153, 0, 154, 0, 155, 0, 156, 0, 157, 0, 158, 0, 159, 0, 160, 0, 161, 0, 162, 0, 163, 0, 164, 0, 165, 0, 166, 0, 167, 0, 168, 0, 169, 0, 170, 0, 171, 1, 2, 0, 173, 0, 174, 0, 175, 0, 176, 0, 177, 0, 178, 0, 179, 0, 180, 0, 181, 0, 182, 0, 183, 0, 184, 0, 185, 0, 186, 0, 187, 0, 188, 1, 3, 0, 190, 0, 191, 0, 192, 0, 193, 0, 194, 0, 195, 0, 196, 0, 197, 0, 198, 0, 199, 0, 200, 0, 201, 0, 202, 0, 203, 0, 204, 0, 205, 0, 206, 0, 207, 0, 208, 0, 209, 0, 210, 0, 211, 0, 212, 0, 213, 0, 214, 0, 215, 0, 216, 0, 217, 0, 218, 0, 219, 0, 220, 0, 221, 0, 222, 0, 223, 0, 224, 0, 225, 0, 4, 0, 5, 1, 4, 0, 189, 0, 232, 1, 5, 0, 242, 0, 243, 0, 241, 0, 245, 0, 244, 0, 246, 0, 233, 0, 240, 0, 235, 0, 237, 0, 234, 0, 236, 0, 238, 1, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11, 0, 253, 0, 254, 1, 12, 1, 13, 1, 14, 1, 15, 0, 255, 1, 0, 1, 16, 1, 17, 1, 18, 1, 1, 1, 19, 1, 20, 1, 21, 1, 22, 1, 23, 1, 24, 1, 25, 1, 26, 1, 27, 1, 28, 1, 29, 1, 30, 0, 248, 0, 249, 1, 31, 1, 32, 1, 33, 1, 34, 1, 35, 1, 36, 1, 37, 1, 38, 1, 39, 1, 40, 1, 41, 1, 42, 1, 43, 1, 44, 1, 45, 1, 46, 0, 250, 1, 47, 1, 48, 1, 49, 1, 50, 1, 51, 1, 52, 1, 53, 1, 54, 1, 55, 1, 56, 1, 57, 1, 58, 1, 59, 1, 60, 1, 61, 0, 226, 0, 227, 1, 62, 1, 63, 1, 64, 1, 65, 1, 66, 1, 67, 1, 68, 1, 69, 1, 70, 1, 71, 1, 72, 1, 73, 1, 74, 1, 75, 1, 76, 1, 77, 1, 78, 1, 79, 1, 80, 1, 81, 1, 82, 1, 83, 1, 84, 1, 85, 1, 86, 0, 251, 0, 252, 0, 228, 0, 229, 1, 87, 1, 88, 1, 89, 1, 90, 1, 91, 1, 92, 1, 93, 1, 94, 1, 95, 1, 96, 1, 97, 1, 98, 1, 99, 1, 100, 1, 101, 1, 102, 1, 103, 1, 104, 1, 105, 1, 106, 1, 107, 1, 108, 1, 109, 1, 110, 1, 111, 1, 112, 0, 230, 0, 231, 1, 113, 1, 114, 1, 115, 1, 116, 1, 117, 1, 118, 1, 119, 1, 120, 1, 121, 1, 122, 1, 123, 1, 124, 1, 125, 1, 126, 1, 127, 1, 128, 1, 129, 1, 130, 1, 131, 1, 132, 1, 133, 1, 134, 1, 135, 1, 136, 1, 137, 1, 138, 1, 139, 1, 140, 1, 141, 1, 142, 1, 143, 1, 144, 1, 145, 1, 146, 1, 147, 1, 148, 1, 149, 1, 150, 1, 151, 1, 152, 1, 153, 1, 154, 1, 155, 1, 156, 1, 157, 1, 158, 1, 159, 1, 160, 1, 161, 1, 162, 1, 163, 1, 164, 1, 165, 1, 166, 1, 167, 1, 168, 1, 169, 1, 170, 1, 171, 1, 172, 1, 173, 1, 174, 1, 175, 1, 176, 1, 177, 1, 178, 1, 179, 1, 180, 1, 181, 1, 182, 1, 183, 1, 184, 1, 185, 1, 186, 1, 187, 1, 188, 1, 189, 1, 190, 1, 191, 1, 192, 1, 193, 1, 194, 1, 195, 1, 196, 1, 197, 1, 198, 1, 199, 1, 200, 1, 201, 1, 202, 1, 203, 1, 204, 1, 205, 1, 206, 1, 207, 1, 208, 1, 209, 1, 210, 1, 211, 1, 212, 1, 213, 1, 214, 1, 215, 1, 216, 1, 217, 1, 218, 1, 219, 1, 220, 1, 221, 1, 222, 1, 223, 1, 224, 1, 225, 1, 226, 1, 227, 1, 228, 1, 229, 1, 230, 1, 231, 1, 232, 1, 233, 1, 234, 1, 235, 1, 236, 1, 237, 1, 238, 1, 239, 1, 240, 1, 241, 1, 242, 1, 243, 1, 244, 1, 245, 1, 246, 1, 247, 1, 248, 1, 249, 1, 250, 1, 251, 1, 252, 1, 253, 1, 254, 1, 255, 2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 2, 5, 2, 6, 2, 7, 2, 8, 2, 9, 2, 10, 2, 11, 2, 12, 2, 13, 2, 14, 2, 15, 2, 16, 2, 17, 2, 18, 2, 19, 2, 20, 2, 21, 2, 22, 2, 23, 2, 24, 2, 25, 2, 26, 2, 27, 2, 28, 2, 29, 2, 30, 2, 31, 2, 32, 2, 33, 2, 34, 2, 35, 2, 36, 2, 37, 2, 38, 2, 39, 2, 40, 2, 41, 2, 42, 2, 43, 2, 44, 2, 45, 2, 46, 2, 47, 2, 48, 2, 49, 2, 50, 2, 51, 2, 52, 0, 239, 2, 53, 2, 54, 2, 55, 2, 56, 2, 57, 2, 58, 2, 59, 2, 60, 2, 61, 2, 62, 2, 63, 2, 64, 2, 65, 2, 66, 2, 67, 2, 68, 2, 69, 2, 70, 2, 71, 2, 72, 2, 73, 2, 74, 2, 75, 2, 76, 2, 77, 2, 78, 2, 79, 2, 80, 2, 81, 2, 82, 2, 83, 2, 84, 2, 85, 2, 86, 2, 87, 2, 88, 2, 89, 2, 90, 2, 91, 2, 92, 2, 93, 2, 94, 2, 95, 2, 96, 2, 97, 2, 98, 2, 99, 2, 100, 2, 101, 2, 102, 2, 103, 2, 104, 2, 105, 2, 106, 2, 107, 2, 108, 2, 109, 2, 110, 2, 111, 2, 112, 2, 113, 7, 117, 110, 105, 48, 48, 65, 48, 4, 69, 117, 114, 111, 11, 99, 111, 109, 109, 97, 97, 99, 99, 101, 110, 116, 7, 117, 110, 105, 48, 48, 65, 68, 7, 65, 109, 97, 99, 114, 111, 110, 7, 97, 109, 97, 99, 114, 111, 110, 6, 65, 98, 114, 101, 118, 101, 6, 97, 98, 114, 101, 118, 101, 7, 65, 111, 103, 111, 110, 101, 107, 7, 97, 111, 103, 111, 110, 101, 107, 11, 67, 99, 105, 114, 99, 117, 109, 102, 108, 101, 120, 11, 99, 99, 105, 114, 99, 117, 109, 102, 108, 101, 120, 10, 67, 100, 111, 116, 97, 99, 99, 101, 110, 116, 10, 99, 100, 111, 116, 97, 99, 99, 101, 110, 116, 6, 68, 99, 97, 114, 111, 110, 6, 100, 99, 97, 114, 111, 110, 6, 68, 99, 114, 111, 97, 116, 7, 69, 109, 97, 99, 114, 111, 110, 7, 101, 109, 97, 99, 114, 111, 110, 6, 69, 98, 114, 101, 118, 101, 6, 101, 98, 114, 101, 118, 101, 10, 69, 100, 111, 116, 97, 99, 99, 101, 110, 116, 10, 101, 100, 111, 116, 97, 99, 99, 101, 110, 116, 7, 69, 111, 103, 111, 110, 101, 107, 7, 101, 111, 103, 111, 110, 101, 107, 6, 69, 99, 97, 114, 111, 110, 6, 101, 99, 97, 114, 111, 110, 11, 71, 99, 105, 114, 99, 117, 109, 102, 108, 101, 120, 11, 103, 99, 105, 114, 99, 117, 109, 102, 108, 101, 120, 10, 71, 100, 111, 116, 97, 99, 99, 101, 110, 116, 10, 103, 100, 111, 116, 97, 99, 99, 101, 110, 116, 12, 71, 99, 111, 109, 109, 97, 97, 99, 99, 101, 110, 116, 12, 103, 99, 111, 109, 109, 97, 97, 99, 99, 101, 110, 116, 11, 72, 99, 105, 114, 99, 117, 109, 102, 108, 101, 120, 11, 104, 99, 105, 114, 99, 117, 109, 102, 108, 101, 120, 4, 72, 98, 97, 114, 4, 104, 98, 97, 114, 6, 73, 116, 105, 108, 100, 101, 6, 105, 116, 105, 108, 100, 101, 7, 73, 109, 97, 99, 114, 111, 110, 7, 105, 109, 97, 99, 114, 111, 110, 6, 73, 98, 114, 101, 118, 101, 6, 105, 98, 114, 101, 118, 101, 7, 73, 111, 103, 111, 110, 101, 107, 7, 105, 111, 103, 111, 110, 101, 107, 2, 73, 74, 2, 105, 106, 11, 74, 99, 105, 114, 99, 117, 109, 102, 108, 101, 120, 11, 106, 99, 105, 114, 99, 117, 109, 102, 108, 101, 120, 12, 75, 99, 111, 109, 109, 97, 97, 99, 99, 101, 110, 116, 12, 107, 99, 111, 109, 109, 97, 97, 99, 99, 101, 110, 116, 12, 107, 103, 114, 101, 101, 110, 108, 97, 110, 100, 105, 99, 6, 76, 97, 99, 117, 116, 101, 6, 108, 97, 99, 117, 116, 101, 12, 76, 99, 111, 109, 109, 97, 97, 99, 99, 101, 110, 116, 12, 108, 99, 111, 109, 109, 97, 97, 99, 99, 101, 110, 116, 6, 76, 99, 97, 114, 111, 110, 6, 108, 99, 97, 114, 111, 110, 4, 76, 100, 111, 116, 4, 108, 100, 111, 116, 6, 78, 97, 99, 117, 116, 101, 6, 110, 97, 99, 117, 116, 101, 12, 78, 99, 111, 109, 109, 97, 97, 99, 99, 101, 110, 116, 12, 110, 99, 111, 109, 109, 97, 97, 99, 99, 101, 110, 116, 6, 78, 99, 97, 114, 111, 110, 6, 110, 99, 97, 114, 111, 110, 11, 110, 97, 112, 111, 115, 116, 114, 111, 112, 104, 101, 3, 69, 110, 103, 3, 101, 110, 103, 7, 79, 109, 97, 99, 114, 111, 110, 7, 111, 109, 97, 99, 114, 111, 110, 6, 79, 98, 114, 101, 118, 101, 6, 111, 98, 114, 101, 118, 101, 13, 79, 104, 117, 110, 103, 97, 114, 117, 109, 108, 97, 117, 116, 13, 111, 104, 117, 110, 103, 97, 114, 117, 109, 108, 97, 117, 116, 6, 82, 97, 99, 117, 116, 101, 6, 114, 97, 99, 117, 116, 101, 12, 82, 99, 111, 109, 109, 97, 97, 99, 99, 101, 110, 116, 12, 114, 99, 111, 109, 109, 97, 97, 99, 99, 101, 110, 116, 6, 82, 99, 97, 114, 111, 110, 6, 114, 99, 97, 114, 111, 110, 6, 83, 97, 99, 117, 116, 101, 6, 115, 97, 99, 117, 116, 101, 11, 83, 99, 105, 114, 99, 117, 109, 102, 108, 101, 120, 11, 115, 99, 105, 114, 99, 117, 109, 102, 108, 101, 120, 12, 84, 99, 111, 109, 109, 97, 97, 99, 99, 101, 110, 116, 12, 116, 99, 111, 109, 109, 97, 97, 99, 99, 101, 110, 116, 6, 84, 99, 97, 114, 111, 110, 6, 116, 99, 97, 114, 111, 110, 4, 84, 98, 97, 114, 4, 116, 98, 97, 114, 6, 85, 116, 105, 108, 100, 101, 6, 117, 116, 105, 108, 100, 101, 7, 85, 109, 97, 99, 114, 111, 110, 7, 117, 109, 97, 99, 114, 111, 110, 6, 85, 98, 114, 101, 118, 101, 6, 117, 98, 114, 101, 118, 101, 5, 85, 114, 105, 110, 103, 5, 117, 114, 105, 110, 103, 13, 85, 104, 117, 110, 103, 97, 114, 117, 109, 108, 97, 117, 116, 13, 117, 104, 117, 110, 103, 97, 114, 117, 109, 108, 97, 117, 116, 7, 85, 111, 103, 111, 110, 101, 107, 7, 117, 111, 103, 111, 110, 101, 107, 11, 87, 99, 105, 114, 99, 117, 109, 102, 108, 101, 120, 11, 119, 99, 105, 114, 99, 117, 109, 102, 108, 101, 120, 11, 89, 99, 105, 114, 99, 117, 109, 102, 108, 101, 120, 11, 121, 99, 105, 114, 99, 117, 109, 102, 108, 101, 120, 6, 90, 97, 99, 117, 116, 101, 6, 122, 97, 99, 117, 116, 101, 10, 90, 100, 111, 116, 97, 99, 99, 101, 110, 116, 10, 122, 100, 111, 116, 97, 99, 99, 101, 110, 116, 5, 108, 111, 110, 103, 115, 7, 65, 69, 97, 99, 117, 116, 101, 7, 97, 101, 97, 99, 117, 116, 101, 11, 79, 115, 108, 97, 115, 104, 97, 99, 117, 116, 101, 11, 111, 115, 108, 97, 115, 104, 97, 99, 117, 116, 101, 12, 83, 99, 111, 109, 109, 97, 97, 99, 99, 101, 110, 116, 12, 115, 99, 111, 109, 109, 97, 97, 99, 99, 101, 110, 116, 7, 117, 110, 105, 48, 50, 49, 65, 7, 117, 110, 105, 48, 50, 49, 66, 5, 116, 111, 110, 111, 115, 13, 100, 105, 101, 114, 101, 115, 105, 115, 116, 111, 110, 111, 115, 10, 65, 108, 112, 104, 97, 116, 111, 110, 111, 115, 12, 69, 112, 115, 105, 108, 111, 110, 116, 111, 110, 111, 115, 8, 69, 116, 97, 116, 111, 110, 111, 115, 9, 73, 111, 116, 97, 116, 111, 110, 111, 115, 12, 79, 109, 105, 99, 114, 111, 110, 116, 111, 110, 111, 115, 12, 85, 112, 115, 105, 108, 111, 110, 116, 111, 110, 111, 115, 10, 79, 109, 101, 103, 97, 116, 111, 110, 111, 115, 17, 105, 111, 116, 97, 100, 105, 101, 114, 101, 115, 105, 115, 116, 111, 110, 111, 115, 5, 65, 108, 112, 104, 97, 4, 66, 101, 116, 97, 5, 71, 97, 109, 109, 97, 7, 117, 110, 105, 48, 51, 57, 52, 7, 69, 112, 115, 105, 108, 111, 110, 4, 90, 101, 116, 97, 3, 69, 116, 97, 5, 84, 104, 101, 116, 97, 4, 73, 111, 116, 97, 5, 75, 97, 112, 112, 97, 6, 76, 97, 109, 98, 100, 97, 2, 77, 117, 2, 78, 117, 2, 88, 105, 7, 79, 109, 105, 99, 114, 111, 110, 2, 80, 105, 3, 82, 104, 111, 5, 83, 105, 103, 109, 97, 3, 84, 97, 117, 7, 85, 112, 115, 105, 108, 111, 110, 3, 80, 104, 105, 3, 67, 104, 105, 3, 80, 115, 105, 12, 73, 111, 116, 97, 100, 105, 101, 114, 101, 115, 105, 115, 15, 85, 112, 115, 105, 108, 111, 110, 100, 105, 101, 114, 101, 115, 105, 115, 10, 97, 108, 112, 104, 97, 116, 111, 110, 111, 115, 12, 101, 112, 115, 105, 108, 111, 110, 116, 111, 110, 111, 115, 8, 101, 116, 97, 116, 111, 110, 111, 115, 9, 105, 111, 116, 97, 116, 111, 110, 111, 115, 20, 117, 112, 115, 105, 108, 111, 110, 100, 105, 101, 114, 101, 115, 105, 115, 116, 111, 110, 111, 115, 5, 97, 108, 112, 104, 97, 4, 98, 101, 116, 97, 5, 103, 97, 109, 109, 97, 5, 100, 101, 108, 116, 97, 7, 101, 112, 115, 105, 108, 111, 110, 4, 122, 101, 116, 97, 3, 101, 116, 97, 5, 116, 104, 101, 116, 97, 4, 105, 111, 116, 97, 5, 107, 97, 112, 112, 97, 6, 108, 97, 109, 98, 100, 97, 7, 117, 110, 105, 48, 51, 66, 67, 2, 110, 117, 2, 120, 105, 7, 111, 109, 105, 99, 114, 111, 110, 3, 114, 104, 111, 6, 115, 105, 103, 109, 97, 49, 5, 115, 105, 103, 109, 97, 3, 116, 97, 117, 7, 117, 112, 115, 105, 108, 111, 110, 3, 112, 104, 105, 3, 99, 104, 105, 3, 112, 115, 105, 5, 111, 109, 101, 103, 97, 12, 105, 111, 116, 97, 100, 105, 101, 114, 101, 115, 105, 115, 15, 117, 112, 115, 105, 108, 111, 110, 100, 105, 101, 114, 101, 115, 105, 115, 12, 111, 109, 105, 99, 114, 111, 110, 116, 111, 110, 111, 115, 12, 117, 112, 115, 105, 108, 111, 110, 116, 111, 110, 111, 115, 10, 111, 109, 101, 103, 97, 116, 111, 110, 111, 115, 9, 97, 102, 105, 105, 49, 48, 48, 50, 51, 9, 97, 102, 105, 105, 49, 48, 48, 53, 49, 9, 97, 102, 105, 105, 49, 48, 48, 53, 50, 9, 97, 102, 105, 105, 49, 48, 48, 53, 51, 9, 97, 102, 105, 105, 49, 48, 48, 53, 52, 9, 97, 102, 105, 105, 49, 48, 48, 53, 53, 9, 97, 102, 105, 105, 49, 48, 48, 53, 54, 9, 97, 102, 105, 105, 49, 48, 48, 53, 55, 9, 97, 102, 105, 105, 49, 48, 48, 53, 56, 9, 97, 102, 105, 105, 49, 48, 48, 53, 57, 9, 97, 102, 105, 105, 49, 48, 48, 54, 48, 9, 97, 102, 105, 105, 49, 48, 48, 54, 49, 9, 97, 102, 105, 105, 49, 48, 48, 54, 50, 9, 97, 102, 105, 105, 49, 48, 49, 52, 53, 9, 97, 102, 105, 105, 49, 48, 48, 49, 55, 9, 97, 102, 105, 105, 49, 48, 48, 49, 56, 9, 97, 102, 105, 105, 49, 48, 48, 49, 57, 9, 97, 102, 105, 105, 49, 48, 48, 50, 48, 9, 97, 102, 105, 105, 49, 48, 48, 50, 49, 9, 97, 102, 105, 105, 49, 48, 48, 50, 50, 9, 97, 102, 105, 105, 49, 48, 48, 50, 52, 9, 97, 102, 105, 105, 49, 48, 48, 50, 53, 9, 97, 102, 105, 105, 49, 48, 48, 50, 54, 9, 97, 102, 105, 105, 49, 48, 48, 50, 55, 9, 97, 102, 105, 105, 49, 48, 48, 50, 56, 9, 97, 102, 105, 105, 49, 48, 48, 50, 57, 9, 97, 102, 105, 105, 49, 48, 48, 51, 48, 9, 97, 102, 105, 105, 49, 48, 48, 51, 49, 9, 97, 102, 105, 105, 49, 48, 48, 51, 50, 9, 97, 102, 105, 105, 49, 48, 48, 51, 51, 9, 97, 102, 105, 105, 49, 48, 48, 51, 52, 9, 97, 102, 105, 105, 49, 48, 48, 51, 53, 9, 97, 102, 105, 105, 49, 48, 48, 51, 54, 9, 97, 102, 105, 105, 49, 48, 48, 51, 55, 9, 97, 102, 105, 105, 49, 48, 48, 51, 56, 9, 97, 102, 105, 105, 49, 48, 48, 51, 57, 9, 97, 102, 105, 105, 49, 48, 48, 52, 48, 9, 97, 102, 105, 105, 49, 48, 48, 52, 49, 9, 97, 102, 105, 105, 49, 48, 48, 52, 50, 9, 97, 102, 105, 105, 49, 48, 48, 52, 51, 9, 97, 102, 105, 105, 49, 48, 48, 52, 52, 9, 97, 102, 105, 105, 49, 48, 48, 52, 53, 9, 97, 102, 105, 105, 49, 48, 48, 52, 54, 9, 97, 102, 105, 105, 49, 48, 48, 52, 55, 9, 97, 102, 105, 105, 49, 48, 48, 52, 56, 9, 97, 102, 105, 105, 49, 48, 48, 52, 57, 9, 97, 102, 105, 105, 49, 48, 48, 54, 53, 9, 97, 102, 105, 105, 49, 48, 48, 54, 54, 9, 97, 102, 105, 105, 49, 48, 48, 54, 55, 9, 97, 102, 105, 105, 49, 48, 48, 54, 56, 9, 97, 102, 105, 105, 49, 48, 48, 54, 57, 9, 97, 102, 105, 105, 49, 48, 48, 55, 48, 9, 97, 102, 105, 105, 49, 48, 48, 55, 50, 9, 97, 102, 105, 105, 49, 48, 48, 55, 51, 9, 97, 102, 105, 105, 49, 48, 48, 55, 52, 9, 97, 102, 105, 105, 49, 48, 48, 55, 53, 9, 97, 102, 105, 105, 49, 48, 48, 55, 54, 9, 97, 102, 105, 105, 49, 48, 48, 55, 55, 9, 97, 102, 105, 105, 49, 48, 48, 55, 56, 9, 97, 102, 105, 105, 49, 48, 48, 55, 57, 9, 97, 102, 105, 105, 49, 48, 48, 56, 48, 9, 97, 102, 105, 105, 49, 48, 48, 56, 49, 9, 97, 102, 105, 105, 49, 48, 48, 56, 50, 9, 97, 102, 105, 105, 49, 48, 48, 56, 51, 9, 97, 102, 105, 105, 49, 48, 48, 56, 52, 9, 97, 102, 105, 105, 49, 48, 48, 56, 53, 9, 97, 102, 105, 105, 49, 48, 48, 56, 54, 9, 97, 102, 105, 105, 49, 48, 48, 56, 55, 9, 97, 102, 105, 105, 49, 48, 48, 56, 56, 9, 97, 102, 105, 105, 49, 48, 48, 56, 57, 9, 97, 102, 105, 105, 49, 48, 48, 57, 48, 9, 97, 102, 105, 105, 49, 48, 48, 57, 49, 9, 97, 102, 105, 105, 49, 48, 48, 57, 50, 9, 97, 102, 105, 105, 49, 48, 48, 57, 51, 9, 97, 102, 105, 105, 49, 48, 48, 57, 52, 9, 97, 102, 105, 105, 49, 48, 48, 57, 53, 9, 97, 102, 105, 105, 49, 48, 48, 57, 54, 9, 97, 102, 105, 105, 49, 48, 48, 57, 55, 9, 97, 102, 105, 105, 49, 48, 48, 55, 49, 9, 97, 102, 105, 105, 49, 48, 48, 57, 57, 9, 97, 102, 105, 105, 49, 48, 49, 48, 48, 9, 97, 102, 105, 105, 49, 48, 49, 48, 49, 9, 97, 102, 105, 105, 49, 48, 49, 48, 50, 9, 97, 102, 105, 105, 49, 48, 49, 48, 51, 9, 97, 102, 105, 105, 49, 48, 49, 48, 52, 9, 97, 102, 105, 105, 49, 48, 49, 48, 53, 9, 97, 102, 105, 105, 49, 48, 49, 48, 54, 9, 97, 102, 105, 105, 49, 48, 49, 48, 55, 9, 97, 102, 105, 105, 49, 48, 49, 48, 56, 9, 97, 102, 105, 105, 49, 48, 49, 48, 57, 9, 97, 102, 105, 105, 49, 48, 49, 49, 48, 9, 97, 102, 105, 105, 49, 48, 49, 57, 51, 9, 97, 102, 105, 105, 49, 48, 48, 53, 48, 9, 97, 102, 105, 105, 49, 48, 48, 57, 56, 7, 117, 110, 105, 49, 69, 48, 50, 7, 117, 110, 105, 49, 69, 48, 51, 7, 117, 110, 105, 49, 69, 48, 65, 7, 117, 110, 105, 49, 69, 48, 66, 7, 117, 110, 105, 49, 69, 49, 69, 7, 117, 110, 105, 49, 69, 49, 70, 7, 117, 110, 105, 49, 69, 52, 48, 7, 117, 110, 105, 49, 69, 52, 49, 7, 117, 110, 105, 49, 69, 53, 54, 7, 117, 110, 105, 49, 69, 53, 55, 7, 117, 110, 105, 49, 69, 54, 48, 7, 117, 110, 105, 49, 69, 54, 49, 7, 117, 110, 105, 49, 69, 54, 65, 7, 117, 110, 105, 49, 69, 54, 66, 6, 87, 103, 114, 97, 118, 101, 6, 119, 103, 114, 97, 118, 101, 6, 87, 97, 99, 117, 116, 101, 6, 119, 97, 99, 117, 116, 101, 9, 87, 100, 105, 101, 114, 101, 115, 105, 115, 9, 119, 100, 105, 101, 114, 101, 115, 105, 115, 6, 89, 103, 114, 97, 118, 101, 6, 121, 103, 114, 97, 118, 101, 9, 97, 102, 105, 105, 48, 48, 50, 48, 56, 9, 97, 102, 105, 105, 54, 49, 51, 53, 50, 7, 117, 110, 105, 50, 51, 48, 51, 7, 117, 110, 105, 50, 51, 49, 56, 7, 117, 110, 105, 50, 51, 50, 52, 9, 111, 112, 116, 105, 111, 110, 107, 101, 121, 15, 101, 114, 97, 115, 101, 116, 111, 116, 104, 101, 114, 105, 103, 104, 116, 7, 117, 110, 105, 50, 51, 55, 100, 7, 117, 110, 105, 50, 51, 56, 56, 7, 117, 110, 105, 50, 51, 99, 101, 7, 117, 110, 105, 50, 52, 50, 51, 8, 83, 70, 49, 48, 48, 48, 48, 48, 8, 83, 70, 49, 49, 48, 48, 48, 48, 8, 83, 70, 48, 49, 48, 48, 48, 48, 8, 83, 70, 48, 51, 48, 48, 48, 48, 8, 83, 70, 48, 50, 48, 48, 48, 48, 8, 83, 70, 48, 52, 48, 48, 48, 48, 8, 83, 70, 48, 56, 48, 48, 48, 48, 8, 83, 70, 48, 57, 48, 48, 48, 48, 8, 83, 70, 48, 54, 48, 48, 48, 48, 8, 83, 70, 48, 55, 48, 48, 48, 48, 8, 83, 70, 48, 53, 48, 48, 48, 48, 8, 83, 70, 52, 51, 48, 48, 48, 48, 8, 83, 70, 50, 52, 48, 48, 48, 48, 8, 83, 70, 53, 49, 48, 48, 48, 48, 8, 83, 70, 53, 50, 48, 48, 48, 48, 8, 83, 70, 51, 57, 48, 48, 48, 48, 8, 83, 70, 50, 50, 48, 48, 48, 48, 8, 83, 70, 50, 49, 48, 48, 48, 48, 8, 83, 70, 50, 53, 48, 48, 48, 48, 8, 83, 70, 53, 48, 48, 48, 48, 48, 8, 83, 70, 52, 57, 48, 48, 48, 48, 8, 83, 70, 51, 56, 48, 48, 48, 48, 8, 83, 70, 50, 56, 48, 48, 48, 48, 8, 83, 70, 50, 55, 48, 48, 48, 48, 8, 83, 70, 50, 54, 48, 48, 48, 48, 8, 83, 70, 51, 54, 48, 48, 48, 48, 8, 83, 70, 51, 55, 48, 48, 48, 48, 8, 83, 70, 52, 50, 48, 48, 48, 48, 8, 83, 70, 49, 57, 48, 48, 48, 48, 8, 83, 70, 50, 48, 48, 48, 48, 48, 8, 83, 70, 50, 51, 48, 48, 48, 48, 8, 83, 70, 52, 55, 48, 48, 48, 48, 8, 83, 70, 52, 56, 48, 48, 48, 48, 8, 83, 70, 52, 49, 48, 48, 48, 48, 8, 83, 70, 52, 53, 48, 48, 48, 48, 8, 83, 70, 52, 54, 48, 48, 48, 48, 8, 83, 70, 52, 48, 48, 48, 48, 48, 8, 83, 70, 53, 52, 48, 48, 48, 48, 8, 83, 70, 53, 51, 48, 48, 48, 48, 8, 83, 70, 52, 52, 48, 48, 48, 48, 12, 98, 108, 97, 99, 107, 100, 105, 97, 109, 111, 110, 100, 9, 99, 104, 101, 99, 107, 109, 97, 114, 107, 5, 115, 104, 105, 102, 116, 9, 115, 104, 105, 102, 116, 108, 111, 99, 107, 11, 118, 101, 114, 116, 105, 99, 97, 108, 116, 97, 98, 4, 99, 111, 112, 121, 4, 98, 97, 99, 107, 6, 101, 110, 100, 116, 97, 98, 6, 105, 110, 115, 101, 114, 116, 3, 116, 97, 98, 9, 97, 112, 112, 108, 101, 111, 112, 101, 110, 7, 117, 110, 105, 48, 51, 65, 57, 0, 0, 0, 0, 0, 3, 0, 9, 0, 2, 0, 13, 0, 1, 255, 255, 0, 2) +font_name = "Anonymous Pro" +style_name = "Regular" +font_style = 4 +subpixel_positioning = 0 +msdf_pixel_range = 14 +msdf_size = 128 +face_index = null +embolden = null +transform = null +cache/0/16/0/ascent = 14.0 +cache/0/16/0/descent = 3.0 +cache/0/16/0/underline_position = 1.9375 +cache/0/16/0/underline_thickness = 0.96875 +cache/0/16/0/scale = 1.0 +cache/0/16/0/textures/0/offsets = PackedInt32Array(54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 59, 32, 20, 32, 32, 32, 32, 32, 32, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 42, 42, 42, 42, 42, 42, 42, 42, 42, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 35, 35, 35, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 38, 38, 38, 38, 38, 38, 38, 38, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 36, 36, 36, 36, 36, 36, 36, 36, 36, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 0, 0) +cache/0/16/0/textures/0/image = SubResource("Image_1b8gs") +cache/0/16/0/glyphs/86/advance = Vector2(9, 16) +cache/0/16/0/glyphs/86/offset = Vector2(-1, -9) +cache/0/16/0/glyphs/86/size = Vector2(9, 10) +cache/0/16/0/glyphs/86/uv_rect = Rect2(1, 1, 9, 10) +cache/0/16/0/glyphs/86/texture_idx = 0 +cache/0/16/0/glyphs/84/advance = Vector2(9, 16) +cache/0/16/0/glyphs/84/offset = Vector2(-2, -9) +cache/0/16/0/glyphs/84/size = Vector2(11, 10) +cache/0/16/0/glyphs/84/uv_rect = Rect2(12, 1, 11, 10) +cache/0/16/0/glyphs/84/texture_idx = 0 +cache/0/16/0/glyphs/70/advance = Vector2(9, 16) +cache/0/16/0/glyphs/70/offset = Vector2(-2, -9) +cache/0/16/0/glyphs/70/size = Vector2(11, 10) +cache/0/16/0/glyphs/70/uv_rect = Rect2(25, 1, 11, 10) +cache/0/16/0/glyphs/70/texture_idx = 0 +cache/0/16/0/glyphs/83/advance = Vector2(9, 16) +cache/0/16/0/glyphs/83/offset = Vector2(-1, -9) +cache/0/16/0/glyphs/83/size = Vector2(10, 10) +cache/0/16/0/glyphs/83/uv_rect = Rect2(38, 1, 10, 10) +cache/0/16/0/glyphs/83/texture_idx = 0 +cache/0/16/0/glyphs/27/advance = Vector2(9, 16) +cache/0/16/0/glyphs/27/offset = Vector2(1, -9) +cache/0/16/0/glyphs/27/size = Vector2(5, 10) +cache/0/16/0/glyphs/27/uv_rect = Rect2(50, 1, 5, 10) +cache/0/16/0/glyphs/27/texture_idx = 0 +cache/0/16/0/glyphs/16/advance = Vector2(9, 16) +cache/0/16/0/glyphs/16/offset = Vector2(-1, -13) +cache/0/16/0/glyphs/16/size = Vector2(10, 17) +cache/0/16/0/glyphs/16/uv_rect = Rect2(57, 1, 10, 17) +cache/0/16/0/glyphs/16/texture_idx = 0 +cache/0/16/0/glyphs/48/advance = Vector2(9, 16) +cache/0/16/0/glyphs/48/offset = Vector2(-2, -12) +cache/0/16/0/glyphs/48/size = Vector2(11, 13) +cache/0/16/0/glyphs/48/uv_rect = Rect2(69, 1, 11, 13) +cache/0/16/0/glyphs/48/texture_idx = 0 +cache/0/16/0/glyphs/81/advance = Vector2(9, 16) +cache/0/16/0/glyphs/81/offset = Vector2(-1, -9) +cache/0/16/0/glyphs/81/size = Vector2(10, 13) +cache/0/16/0/glyphs/81/uv_rect = Rect2(82, 1, 10, 13) +cache/0/16/0/glyphs/81/texture_idx = 0 +cache/0/16/0/glyphs/79/advance = Vector2(9, 16) +cache/0/16/0/glyphs/79/offset = Vector2(-1, -9) +cache/0/16/0/glyphs/79/size = Vector2(9, 10) +cache/0/16/0/glyphs/79/uv_rect = Rect2(94, 1, 9, 10) +cache/0/16/0/glyphs/79/texture_idx = 0 +cache/0/16/0/glyphs/3/advance = Vector2(9, 16) +cache/0/16/0/glyphs/3/offset = Vector2(-1, -1) +cache/0/16/0/glyphs/3/size = Vector2(2, 2) +cache/0/16/0/glyphs/3/uv_rect = Rect2(105, 1, 2, 2) +cache/0/16/0/glyphs/3/texture_idx = 0 +cache/0/16/0/glyphs/39/advance = Vector2(9, 16) +cache/0/16/0/glyphs/39/offset = Vector2(-1, -12) +cache/0/16/0/glyphs/39/size = Vector2(9, 13) +cache/0/16/0/glyphs/39/uv_rect = Rect2(109, 1, 9, 13) +cache/0/16/0/glyphs/39/texture_idx = 0 +cache/0/16/0/glyphs/74/advance = Vector2(9, 16) +cache/0/16/0/glyphs/74/offset = Vector2(0, -12) +cache/0/16/0/glyphs/74/size = Vector2(7, 13) +cache/0/16/0/glyphs/74/uv_rect = Rect2(120, 1, 7, 13) +cache/0/16/0/glyphs/74/texture_idx = 0 +cache/0/16/0/glyphs/77/advance = Vector2(9, 16) +cache/0/16/0/glyphs/77/offset = Vector2(0, -12) +cache/0/16/0/glyphs/77/size = Vector2(7, 13) +cache/0/16/0/glyphs/77/uv_rect = Rect2(129, 1, 7, 13) +cache/0/16/0/glyphs/77/texture_idx = 0 +cache/0/16/0/glyphs/41/advance = Vector2(9, 16) +cache/0/16/0/glyphs/41/offset = Vector2(-1, -12) +cache/0/16/0/glyphs/41/size = Vector2(9, 13) +cache/0/16/0/glyphs/41/uv_rect = Rect2(138, 1, 9, 13) +cache/0/16/0/glyphs/41/texture_idx = 0 +cache/0/16/0/glyphs/80/advance = Vector2(9, 16) +cache/0/16/0/glyphs/80/offset = Vector2(-2, -9) +cache/0/16/0/glyphs/80/size = Vector2(11, 10) +cache/0/16/0/glyphs/80/uv_rect = Rect2(149, 1, 11, 10) +cache/0/16/0/glyphs/80/texture_idx = 0 +cache/0/16/0/glyphs/78/advance = Vector2(9, 16) +cache/0/16/0/glyphs/78/offset = Vector2(-1, -9) +cache/0/16/0/glyphs/78/size = Vector2(10, 10) +cache/0/16/0/glyphs/78/uv_rect = Rect2(162, 1, 10, 10) +cache/0/16/0/glyphs/78/texture_idx = 0 +cache/0/16/0/glyphs/36/advance = Vector2(9, 16) +cache/0/16/0/glyphs/36/offset = Vector2(-2, -12) +cache/0/16/0/glyphs/36/size = Vector2(11, 13) +cache/0/16/0/glyphs/36/uv_rect = Rect2(174, 1, 11, 13) +cache/0/16/0/glyphs/36/texture_idx = 0 +cache/0/16/0/glyphs/90/advance = Vector2(9, 16) +cache/0/16/0/glyphs/90/offset = Vector2(-2, -9) +cache/0/16/0/glyphs/90/size = Vector2(11, 13) +cache/0/16/0/glyphs/90/uv_rect = Rect2(187, 1, 11, 13) +cache/0/16/0/glyphs/90/texture_idx = 0 +cache/0/16/0/glyphs/38/advance = Vector2(9, 16) +cache/0/16/0/glyphs/38/offset = Vector2(-1, -12) +cache/0/16/0/glyphs/38/size = Vector2(9, 13) +cache/0/16/0/glyphs/38/uv_rect = Rect2(200, 1, 9, 13) +cache/0/16/0/glyphs/38/texture_idx = 0 +cache/0/16/0/glyphs/69/advance = Vector2(9, 16) +cache/0/16/0/glyphs/69/offset = Vector2(-2, -12) +cache/0/16/0/glyphs/69/size = Vector2(10, 13) +cache/0/16/0/glyphs/69/uv_rect = Rect2(211, 1, 10, 13) +cache/0/16/0/glyphs/69/texture_idx = 0 +cache/0/16/0/glyphs/34/advance = Vector2(9, 16) +cache/0/16/0/glyphs/34/offset = Vector2(-2, -12) +cache/0/16/0/glyphs/34/size = Vector2(11, 13) +cache/0/16/0/glyphs/34/uv_rect = Rect2(223, 1, 11, 13) +cache/0/16/0/glyphs/34/texture_idx = 0 +cache/0/16/0/glyphs/85/advance = Vector2(9, 16) +cache/0/16/0/glyphs/85/offset = Vector2(-1, -12) +cache/0/16/0/glyphs/85/size = Vector2(10, 13) +cache/0/16/0/glyphs/85/uv_rect = Rect2(236, 1, 10, 13) +cache/0/16/0/glyphs/85/texture_idx = 0 +cache/0/16/0/glyphs/68/advance = Vector2(9, 16) +cache/0/16/0/glyphs/68/offset = Vector2(-1, -9) +cache/0/16/0/glyphs/68/size = Vector2(10, 10) +cache/0/16/0/glyphs/68/uv_rect = Rect2(1, 13, 10, 10) +cache/0/16/0/glyphs/68/texture_idx = 0 +cache/0/16/0/glyphs/40/advance = Vector2(9, 16) +cache/0/16/0/glyphs/40/offset = Vector2(-2, -12) +cache/0/16/0/glyphs/40/size = Vector2(11, 13) +cache/0/16/0/glyphs/40/uv_rect = Rect2(13, 13, 11, 13) +cache/0/16/0/glyphs/40/texture_idx = 0 +cache/0/16/0/glyphs/26/advance = Vector2(9, 16) +cache/0/16/0/glyphs/26/offset = Vector2(-2, -12) +cache/0/16/0/glyphs/26/size = Vector2(11, 13) +cache/0/16/0/glyphs/26/uv_rect = Rect2(26, 13, 11, 13) +cache/0/16/0/glyphs/26/texture_idx = 0 +cache/0/16/0/glyphs/15/advance = Vector2(9, 16) +cache/0/16/0/glyphs/15/offset = Vector2(1, -3) +cache/0/16/0/glyphs/15/size = Vector2(5, 4) +cache/0/16/0/glyphs/15/uv_rect = Rect2(248, 1, 5, 4) +cache/0/16/0/glyphs/15/texture_idx = 0 +cache/0/16/0/glyphs/47/advance = Vector2(9, 16) +cache/0/16/0/glyphs/47/offset = Vector2(-1, -12) +cache/0/16/0/glyphs/47/size = Vector2(9, 13) +cache/0/16/0/glyphs/47/uv_rect = Rect2(39, 13, 9, 13) +cache/0/16/0/glyphs/47/texture_idx = 0 +cache/0/16/0/glyphs/57/advance = Vector2(9, 16) +cache/0/16/0/glyphs/57/offset = Vector2(-2, -12) +cache/0/16/0/glyphs/57/size = Vector2(11, 13) +cache/0/16/0/glyphs/57/uv_rect = Rect2(94, 13, 11, 13) +cache/0/16/0/glyphs/57/texture_idx = 0 +cache/0/16/0/glyphs/18/advance = Vector2(9, 16) +cache/0/16/0/glyphs/18/offset = Vector2(-1, -12) +cache/0/16/0/glyphs/18/size = Vector2(8, 13) +cache/0/16/0/glyphs/18/uv_rect = Rect2(149, 13, 8, 13) +cache/0/16/0/glyphs/18/texture_idx = 0 +cache/0/16/0/glyphs/17/advance = Vector2(9, 16) +cache/0/16/0/glyphs/17/offset = Vector2(-2, -12) +cache/0/16/0/glyphs/17/size = Vector2(11, 13) +cache/0/16/0/glyphs/17/uv_rect = Rect2(159, 13, 11, 13) +cache/0/16/0/glyphs/17/texture_idx = 0 +cache/0/16/0/glyphs/6/advance = Vector2(9, 16) +cache/0/16/0/glyphs/6/offset = Vector2(-2, -13) +cache/0/16/0/glyphs/6/size = Vector2(11, 15) +cache/0/16/0/glyphs/6/uv_rect = Rect2(69, 16, 11, 15) +cache/0/16/0/glyphs/6/texture_idx = 0 +cache/0/16/0/glyphs/53/advance = Vector2(9, 16) +cache/0/16/0/glyphs/53/offset = Vector2(-1, -12) +cache/0/16/0/glyphs/53/size = Vector2(10, 13) +cache/0/16/0/glyphs/53/uv_rect = Rect2(82, 16, 10, 13) +cache/0/16/0/glyphs/53/texture_idx = 0 +cache/0/16/0/glyphs/52/advance = Vector2(9, 16) +cache/0/16/0/glyphs/52/offset = Vector2(-1, -12) +cache/0/16/0/glyphs/52/size = Vector2(10, 13) +cache/0/16/0/glyphs/52/uv_rect = Rect2(107, 16, 10, 13) +cache/0/16/0/glyphs/52/texture_idx = 0 +cache/0/16/0/glyphs/64/advance = Vector2(9, 16) +cache/0/16/0/glyphs/64/offset = Vector2(-1, 0) +cache/0/16/0/glyphs/64/size = Vector2(10, 3) +cache/0/16/0/glyphs/64/uv_rect = Rect2(119, 16, 10, 3) +cache/0/16/0/glyphs/64/texture_idx = 0 +cache/0/16/0/glyphs/72/advance = Vector2(9, 16) +cache/0/16/0/glyphs/72/offset = Vector2(-2, -9) +cache/0/16/0/glyphs/72/size = Vector2(10, 13) +cache/0/16/0/glyphs/72/uv_rect = Rect2(131, 16, 10, 13) +cache/0/16/0/glyphs/72/texture_idx = 0 +cache/0/16/0/glyphs/93/advance = Vector2(9, 16) +cache/0/16/0/glyphs/93/offset = Vector2(2, -13) +cache/0/16/0/glyphs/93/size = Vector2(4, 16) +cache/0/16/0/glyphs/93/uv_rect = Rect2(248, 7, 4, 16) +cache/0/16/0/glyphs/93/texture_idx = 0 +cache/0/16/0/glyphs/29/advance = Vector2(9, 16) +cache/0/16/0/glyphs/29/offset = Vector2(0, -10) +cache/0/16/0/glyphs/29/size = Vector2(8, 12) +cache/0/16/0/glyphs/29/uv_rect = Rect2(172, 16, 8, 12) +cache/0/16/0/glyphs/29/texture_idx = 0 +cache/0/16/0/glyphs/31/advance = Vector2(9, 16) +cache/0/16/0/glyphs/31/offset = Vector2(0, -10) +cache/0/16/0/glyphs/31/size = Vector2(7, 12) +cache/0/16/0/glyphs/31/uv_rect = Rect2(182, 16, 7, 12) +cache/0/16/0/glyphs/31/texture_idx = 0 +cache/0/16/0/glyphs/9/advance = Vector2(9, 16) +cache/0/16/0/glyphs/9/offset = Vector2(0, -14) +cache/0/16/0/glyphs/9/size = Vector2(7, 19) +cache/0/16/0/glyphs/9/uv_rect = Rect2(191, 16, 7, 19) +cache/0/16/0/glyphs/9/texture_idx = 0 +cache/0/16/0/glyphs/10/advance = Vector2(9, 16) +cache/0/16/0/glyphs/10/offset = Vector2(0, -14) +cache/0/16/0/glyphs/10/size = Vector2(7, 19) +cache/0/16/0/glyphs/10/uv_rect = Rect2(200, 16, 7, 19) +cache/0/16/0/glyphs/10/texture_idx = 0 +cache/0/16/0/glyphs/45/advance = Vector2(9, 16) +cache/0/16/0/glyphs/45/offset = Vector2(-1, -12) +cache/0/16/0/glyphs/45/size = Vector2(9, 13) +cache/0/16/0/glyphs/45/uv_rect = Rect2(209, 16, 9, 13) +cache/0/16/0/glyphs/45/texture_idx = 0 +cache/0/16/0/glyphs/87/advance = Vector2(9, 16) +cache/0/16/0/glyphs/87/offset = Vector2(-2, -9) +cache/0/16/0/glyphs/87/size = Vector2(11, 10) +cache/0/16/0/glyphs/87/uv_rect = Rect2(220, 16, 11, 10) +cache/0/16/0/glyphs/87/texture_idx = 0 +cache/0/16/0/glyphs/73/advance = Vector2(9, 16) +cache/0/16/0/glyphs/73/offset = Vector2(-1, -12) +cache/0/16/0/glyphs/73/size = Vector2(9, 13) +cache/0/16/0/glyphs/73/uv_rect = Rect2(233, 16, 9, 13) +cache/0/16/0/glyphs/73/texture_idx = 0 +cache/0/16/0/glyphs/44/advance = Vector2(9, 16) +cache/0/16/0/glyphs/44/offset = Vector2(-1, -12) +cache/0/16/0/glyphs/44/size = Vector2(10, 13) +cache/0/16/0/glyphs/44/uv_rect = Rect2(50, 20, 10, 13) +cache/0/16/0/glyphs/44/texture_idx = 0 +cache/0/16/0/glyphs/66/advance = Vector2(9, 16) +cache/0/16/0/glyphs/66/offset = Vector2(-2, -9) +cache/0/16/0/glyphs/66/size = Vector2(10, 10) +cache/0/16/0/glyphs/66/uv_rect = Rect2(119, 21, 10, 10) +cache/0/16/0/glyphs/66/texture_idx = 0 +cache/0/16/0/glyphs/49/advance = Vector2(9, 16) +cache/0/16/0/glyphs/49/offset = Vector2(-1, -12) +cache/0/16/0/glyphs/49/size = Vector2(10, 13) +cache/0/16/0/glyphs/49/uv_rect = Rect2(1, 25, 10, 13) +cache/0/16/0/glyphs/49/texture_idx = 0 +cache/0/16/0/glyphs/46/advance = Vector2(9, 16) +cache/0/16/0/glyphs/46/offset = Vector2(-1, -12) +cache/0/16/0/glyphs/46/size = Vector2(9, 13) +cache/0/16/0/glyphs/46/uv_rect = Rect2(244, 25, 9, 13) +cache/0/16/0/glyphs/46/texture_idx = 0 +cache/0/16/0/glyphs/11/advance = Vector2(9, 16) +cache/0/16/0/glyphs/11/offset = Vector2(-1, -9) +cache/0/16/0/glyphs/11/size = Vector2(10, 10) +cache/0/16/0/glyphs/11/uv_rect = Rect2(13, 28, 10, 10) +cache/0/16/0/glyphs/11/texture_idx = 0 +cache/0/16/0/glyphs/71/advance = Vector2(9, 16) +cache/0/16/0/glyphs/71/offset = Vector2(0, -12) +cache/0/16/0/glyphs/71/size = Vector2(9, 13) +cache/0/16/0/glyphs/71/uv_rect = Rect2(25, 28, 9, 13) +cache/0/16/0/glyphs/71/texture_idx = 0 +cache/0/16/0/glyphs/89/advance = Vector2(9, 16) +cache/0/16/0/glyphs/89/offset = Vector2(-2, -9) +cache/0/16/0/glyphs/89/size = Vector2(11, 10) +cache/0/16/0/glyphs/89/uv_rect = Rect2(36, 28, 11, 10) +cache/0/16/0/glyphs/89/texture_idx = 0 +cache/0/16/0/glyphs/42/advance = Vector2(9, 16) +cache/0/16/0/glyphs/42/offset = Vector2(0, -12) +cache/0/16/0/glyphs/42/size = Vector2(7, 13) +cache/0/16/0/glyphs/42/uv_rect = Rect2(94, 28, 7, 13) +cache/0/16/0/glyphs/42/texture_idx = 0 +cache/0/16/0/glyphs/67/advance = Vector2(9, 16) +cache/0/16/0/glyphs/67/offset = Vector2(-1, -12) +cache/0/16/0/glyphs/67/size = Vector2(10, 13) +cache/0/16/0/glyphs/67/uv_rect = Rect2(143, 28, 10, 13) +cache/0/16/0/glyphs/67/texture_idx = 0 +cache/0/16/0/glyphs/55/advance = Vector2(9, 16) +cache/0/16/0/glyphs/55/offset = Vector2(-2, -12) +cache/0/16/0/glyphs/55/size = Vector2(11, 13) +cache/0/16/0/glyphs/55/uv_rect = Rect2(155, 28, 11, 13) +cache/0/16/0/glyphs/55/texture_idx = 0 +cache/0/16/0/glyphs/88/advance = Vector2(9, 16) +cache/0/16/0/glyphs/88/offset = Vector2(-2, -9) +cache/0/16/0/glyphs/88/size = Vector2(11, 10) +cache/0/16/0/glyphs/88/uv_rect = Rect2(220, 28, 11, 10) +cache/0/16/0/glyphs/88/texture_idx = 0 +cache/0/16/0/glyphs/54/advance = Vector2(9, 16) +cache/0/16/0/glyphs/54/offset = Vector2(-1, -12) +cache/0/16/0/glyphs/54/size = Vector2(9, 13) +cache/0/16/0/glyphs/54/uv_rect = Rect2(168, 30, 9, 13) +cache/0/16/0/glyphs/54/texture_idx = 0 +cache/0/16/0/glyphs/13/advance = Vector2(9, 16) +cache/0/16/0/glyphs/13/offset = Vector2(0, -3) +cache/0/16/0/glyphs/13/size = Vector2(6, 7) +cache/0/16/0/glyphs/13/uv_rect = Rect2(179, 30, 6, 7) +cache/0/16/0/glyphs/13/texture_idx = 0 +cache/0/16/0/glyphs/76/advance = Vector2(9, 16) +cache/0/16/0/glyphs/76/offset = Vector2(-1, -12) +cache/0/16/0/glyphs/76/size = Vector2(10, 13) +cache/0/16/0/glyphs/76/uv_rect = Rect2(82, 31, 10, 13) +cache/0/16/0/glyphs/76/texture_idx = 0 +cache/0/16/0/glyphs/37/advance = Vector2(9, 16) +cache/0/16/0/glyphs/37/offset = Vector2(-1, -12) +cache/0/16/0/glyphs/37/size = Vector2(10, 13) +cache/0/16/0/glyphs/37/uv_rect = Rect2(103, 31, 10, 13) +cache/0/16/0/glyphs/37/texture_idx = 0 +cache/0/16/0/glyphs/14/advance = Vector2(9, 16) +cache/0/16/0/glyphs/14/offset = Vector2(-1, -6) +cache/0/16/0/glyphs/14/size = Vector2(10, 3) +cache/0/16/0/glyphs/14/uv_rect = Rect2(131, 31, 10, 3) +cache/0/16/0/glyphs/14/texture_idx = 0 +cache/0/16/0/glyphs/35/advance = Vector2(9, 16) +cache/0/16/0/glyphs/35/offset = Vector2(-1, -12) +cache/0/16/0/glyphs/35/size = Vector2(10, 13) +cache/0/16/0/glyphs/35/uv_rect = Rect2(62, 33, 10, 13) +cache/0/16/0/glyphs/35/texture_idx = 0 +cache/0/16/0/glyphs/51/advance = Vector2(9, 16) +cache/0/16/0/glyphs/51/offset = Vector2(-1, -12) +cache/0/16/0/glyphs/51/size = Vector2(10, 13) +cache/0/16/0/glyphs/51/uv_rect = Rect2(115, 33, 10, 13) +cache/0/16/0/glyphs/51/texture_idx = 0 +cache/0/16/0/glyphs/23/advance = Vector2(9, 16) +cache/0/16/0/glyphs/23/offset = Vector2(-2, -12) +cache/0/16/0/glyphs/23/size = Vector2(11, 13) +cache/0/16/0/glyphs/23/uv_rect = Rect2(49, 35, 11, 13) +cache/0/16/0/glyphs/23/texture_idx = 0 +cache/0/16/0/glyphs/91/advance = Vector2(9, 16) +cache/0/16/0/glyphs/91/offset = Vector2(-1, -9) +cache/0/16/0/glyphs/91/size = Vector2(9, 10) +cache/0/16/0/glyphs/91/uv_rect = Rect2(209, 31, 9, 10) +cache/0/16/0/glyphs/91/texture_idx = 0 +cache/0/16/0/glyphs/25/advance = Vector2(9, 16) +cache/0/16/0/glyphs/25/offset = Vector2(-2, -12) +cache/0/16/0/glyphs/25/size = Vector2(11, 13) +cache/0/16/0/glyphs/25/uv_rect = Rect2(127, 36, 11, 13) +cache/0/16/0/glyphs/25/texture_idx = 0 +cache/0/16/0/glyphs/56/advance = Vector2(9, 16) +cache/0/16/0/glyphs/56/offset = Vector2(-2, -12) +cache/0/16/0/glyphs/56/size = Vector2(11, 13) +cache/0/16/0/glyphs/56/uv_rect = Rect2(187, 37, 11, 13) +cache/0/16/0/glyphs/56/texture_idx = 0 +cache/0/16/0/glyphs/0/advance = Vector2(0, 0) +cache/0/16/0/glyphs/0/offset = Vector2(0, 0) +cache/0/16/0/glyphs/0/size = Vector2(0, 0) +cache/0/16/0/glyphs/0/uv_rect = Rect2(0, 0, 0, 0) +cache/0/16/0/glyphs/0/texture_idx = -1 +cache/0/16/0/glyphs/19/advance = Vector2(9, 16) +cache/0/16/0/glyphs/19/offset = Vector2(-1, -12) +cache/0/16/0/glyphs/19/size = Vector2(9, 13) +cache/0/16/0/glyphs/19/uv_rect = Rect2(233, 31, 9, 13) +cache/0/16/0/glyphs/19/texture_idx = 0 +cache/0/16/0/glyphs/22/advance = Vector2(9, 16) +cache/0/16/0/glyphs/22/offset = Vector2(-1, -12) +cache/0/16/0/glyphs/22/size = Vector2(10, 13) +cache/0/16/0/glyphs/22/uv_rect = Rect2(1, 40, 10, 13) +cache/0/16/0/glyphs/22/texture_idx = 0 +cache/0/16/0/glyphs/24/advance = Vector2(9, 16) +cache/0/16/0/glyphs/24/offset = Vector2(-1, -12) +cache/0/16/0/glyphs/24/size = Vector2(10, 13) +cache/0/16/0/glyphs/24/uv_rect = Rect2(13, 40, 10, 13) +cache/0/16/0/glyphs/24/texture_idx = 0 +cache/0/16/0/glyphs/20/advance = Vector2(9, 16) +cache/0/16/0/glyphs/20/offset = Vector2(-1, -12) +cache/0/16/0/glyphs/20/size = Vector2(10, 13) +cache/0/16/0/glyphs/20/uv_rect = Rect2(48, 33, 10, 13) +cache/0/16/0/glyphs/20/texture_idx = 0 +cache/0/16/0/kerning_overrides/16/0 = Vector2(0, 0) +cache/0/16/0/kerning_overrides/20/0 = Vector2(0, 0) +cache/0/20/0/ascent = 17.0 +cache/0/20/0/descent = 4.0 +cache/0/20/0/underline_position = 2.42188 +cache/0/20/0/underline_thickness = 1.20313 +cache/0/20/0/scale = 1.0 +cache/0/20/0/textures/0/offsets = PackedInt32Array(16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 4, 4, 4, 4, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 13, 13, 13, 13, 13, 13, 13, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) +cache/0/20/0/textures/0/image = SubResource("Image_f4u7m") +cache/0/20/0/glyphs/37/advance = Vector2(11, 20) +cache/0/20/0/glyphs/37/offset = Vector2(-1, -13) +cache/0/20/0/glyphs/37/size = Vector2(12, 14) +cache/0/20/0/glyphs/37/uv_rect = Rect2(1, 1, 12, 14) +cache/0/20/0/glyphs/37/texture_idx = 0 +cache/0/20/0/glyphs/74/advance = Vector2(11, 20) +cache/0/20/0/glyphs/74/offset = Vector2(0, -13) +cache/0/20/0/glyphs/74/size = Vector2(9, 14) +cache/0/20/0/glyphs/74/uv_rect = Rect2(15, 1, 9, 14) +cache/0/20/0/glyphs/74/texture_idx = 0 +cache/0/20/0/glyphs/83/advance = Vector2(11, 20) +cache/0/20/0/glyphs/83/offset = Vector2(-1, -10) +cache/0/20/0/glyphs/83/size = Vector2(12, 11) +cache/0/20/0/glyphs/83/uv_rect = Rect2(26, 1, 12, 11) +cache/0/20/0/glyphs/83/texture_idx = 0 +cache/0/20/0/glyphs/70/advance = Vector2(11, 20) +cache/0/20/0/glyphs/70/offset = Vector2(-2, -10) +cache/0/20/0/glyphs/70/size = Vector2(13, 11) +cache/0/20/0/glyphs/70/uv_rect = Rect2(40, 1, 13, 11) +cache/0/20/0/glyphs/70/texture_idx = 0 +cache/0/20/0/glyphs/68/advance = Vector2(11, 20) +cache/0/20/0/glyphs/68/offset = Vector2(-1, -10) +cache/0/20/0/glyphs/68/size = Vector2(11, 11) +cache/0/20/0/glyphs/68/uv_rect = Rect2(55, 1, 11, 11) +cache/0/20/0/glyphs/68/texture_idx = 0 +cache/0/20/0/glyphs/85/advance = Vector2(11, 20) +cache/0/20/0/glyphs/85/offset = Vector2(-1, -13) +cache/0/20/0/glyphs/85/size = Vector2(12, 14) +cache/0/20/0/glyphs/85/uv_rect = Rect2(68, 1, 12, 14) +cache/0/20/0/glyphs/85/texture_idx = 0 +cache/0/20/0/glyphs/80/advance = Vector2(11, 20) +cache/0/20/0/glyphs/80/offset = Vector2(-2, -10) +cache/0/20/0/glyphs/80/size = Vector2(13, 11) +cache/0/20/0/glyphs/80/uv_rect = Rect2(82, 1, 13, 11) +cache/0/20/0/glyphs/80/texture_idx = 0 +cache/0/20/0/glyphs/84/advance = Vector2(11, 20) +cache/0/20/0/glyphs/84/offset = Vector2(-2, -10) +cache/0/20/0/glyphs/84/size = Vector2(12, 11) +cache/0/20/0/glyphs/84/uv_rect = Rect2(97, 1, 12, 11) +cache/0/20/0/glyphs/84/texture_idx = 0 +cache/0/20/0/glyphs/3/advance = Vector2(11, 20) +cache/0/20/0/glyphs/3/offset = Vector2(-1, -1) +cache/0/20/0/glyphs/3/size = Vector2(2, 2) +cache/0/20/0/glyphs/3/uv_rect = Rect2(111, 1, 2, 2) +cache/0/20/0/glyphs/3/texture_idx = 0 +cache/0/20/0/glyphs/7/advance = Vector2(11, 20) +cache/0/20/0/glyphs/7/offset = Vector2(-2, -13) +cache/0/20/0/glyphs/7/size = Vector2(13, 15) +cache/0/20/0/glyphs/7/uv_rect = Rect2(115, 1, 13, 15) +cache/0/20/0/glyphs/7/texture_idx = 0 +cache/0/20/0/glyphs/39/advance = Vector2(11, 20) +cache/0/20/0/glyphs/39/offset = Vector2(-1, -13) +cache/0/20/0/glyphs/39/size = Vector2(11, 14) +cache/0/20/0/glyphs/39/uv_rect = Rect2(130, 1, 11, 14) +cache/0/20/0/glyphs/39/texture_idx = 0 +cache/0/20/0/glyphs/77/advance = Vector2(11, 20) +cache/0/20/0/glyphs/77/offset = Vector2(0, -13) +cache/0/20/0/glyphs/77/size = Vector2(9, 14) +cache/0/20/0/glyphs/77/uv_rect = Rect2(143, 1, 9, 14) +cache/0/20/0/glyphs/77/texture_idx = 0 +cache/0/20/0/glyphs/27/advance = Vector2(11, 20) +cache/0/20/0/glyphs/27/offset = Vector2(2, -10) +cache/0/20/0/glyphs/27/size = Vector2(5, 11) +cache/0/20/0/glyphs/27/uv_rect = Rect2(154, 1, 5, 11) +cache/0/20/0/glyphs/27/texture_idx = 0 +cache/0/20/0/glyphs/47/advance = Vector2(11, 20) +cache/0/20/0/glyphs/47/offset = Vector2(-1, -13) +cache/0/20/0/glyphs/47/size = Vector2(11, 14) +cache/0/20/0/glyphs/47/uv_rect = Rect2(161, 1, 11, 14) +cache/0/20/0/glyphs/47/texture_idx = 0 +cache/0/20/0/glyphs/66/advance = Vector2(11, 20) +cache/0/20/0/glyphs/66/offset = Vector2(-2, -10) +cache/0/20/0/glyphs/66/size = Vector2(12, 11) +cache/0/20/0/glyphs/66/uv_rect = Rect2(174, 1, 12, 11) +cache/0/20/0/glyphs/66/texture_idx = 0 +cache/0/20/0/glyphs/78/advance = Vector2(11, 20) +cache/0/20/0/glyphs/78/offset = Vector2(-1, -10) +cache/0/20/0/glyphs/78/size = Vector2(12, 11) +cache/0/20/0/glyphs/78/uv_rect = Rect2(188, 1, 12, 11) +cache/0/20/0/glyphs/78/texture_idx = 0 +cache/0/20/0/kerning_overrides/16/0 = Vector2(0, 0) +cache/0/20/0/kerning_overrides/20/0 = Vector2(0, 0) + +[sub_resource type="FontFile" id="FontFile_wf72q"] +fallbacks = Array[Font]([SubResource("FontFile_f0lek")]) +face_index = null +embolden = null +transform = null +cache/0/16/0/ascent = 0.0 +cache/0/16/0/descent = 0.0 +cache/0/16/0/underline_position = 0.0 +cache/0/16/0/underline_thickness = 0.0 +cache/0/16/0/scale = 1.0 +cache/0/16/0/kerning_overrides/16/0 = Vector2(0, 0) +cache/0/16/0/kerning_overrides/20/0 = Vector2(0, 0) +cache/0/20/0/ascent = 0.0 +cache/0/20/0/descent = 0.0 +cache/0/20/0/underline_position = 0.0 +cache/0/20/0/underline_thickness = 0.0 +cache/0/20/0/scale = 1.0 +cache/0/20/0/kerning_overrides/16/0 = Vector2(0, 0) +cache/0/20/0/kerning_overrides/20/0 = Vector2(0, 0) + +[resource] +default_font = SubResource("FontFile_wf72q") +Label/fonts/font = ExtResource("1_df57p") diff --git a/samples/client/petstore/gdscript/addons/gut/gui/MinGui.tscn b/samples/client/petstore/gdscript/addons/gut/gui/MinGui.tscn new file mode 100644 index 000000000000..9db071ec9f3d --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/gui/MinGui.tscn @@ -0,0 +1,161 @@ +[gd_scene load_steps=5 format=3 uid="uid://cnqqdfsn80ise"] + +[ext_resource type="Theme" uid="uid://cstkhwkpajvqu" path="res://addons/gut/gui/GutSceneTheme.tres" id="1_farmq"] +[ext_resource type="FontFile" uid="uid://bnh0lslf4yh87" path="res://addons/gut/fonts/CourierPrime-Regular.ttf" id="2_a2e2l"] +[ext_resource type="Script" path="res://addons/gut/gui/gut_gui.gd" id="2_eokrf"] +[ext_resource type="PackedScene" uid="uid://bvrqqgjpyouse" path="res://addons/gut/gui/ResizeHandle.tscn" id="4_xrhva"] + +[node name="Min" type="Panel"] +clip_contents = true +custom_minimum_size = Vector2(280, 145) +offset_right = 280.0 +offset_bottom = 145.0 +theme = ExtResource("1_farmq") +script = ExtResource("2_eokrf") + +[node name="MainBox" type="VBoxContainer" parent="."] +layout_mode = 1 +anchors_preset = 15 +anchor_right = 1.0 +anchor_bottom = 1.0 +grow_horizontal = 2 +grow_vertical = 2 +metadata/_edit_layout_mode = 1 + +[node name="TitleBar" type="Panel" parent="MainBox"] +custom_minimum_size = Vector2(0, 25) +layout_mode = 2 + +[node name="TitleBox" type="HBoxContainer" parent="MainBox/TitleBar"] +layout_mode = 0 +anchor_right = 1.0 +anchor_bottom = 1.0 +offset_top = 2.0 +offset_bottom = 3.0 +grow_horizontal = 2 +grow_vertical = 2 +metadata/_edit_layout_mode = 1 + +[node name="Spacer1" type="CenterContainer" parent="MainBox/TitleBar/TitleBox"] +layout_mode = 2 +size_flags_horizontal = 3 + +[node name="Title" type="Label" parent="MainBox/TitleBar/TitleBox"] +layout_mode = 2 +text = "Title" + +[node name="Spacer2" type="CenterContainer" parent="MainBox/TitleBar/TitleBox"] +layout_mode = 2 +size_flags_horizontal = 3 + +[node name="TimeLabel" type="Label" parent="MainBox/TitleBar/TitleBox"] +layout_mode = 2 +text = "0.000s" + +[node name="Body" type="HBoxContainer" parent="MainBox"] +layout_mode = 2 +size_flags_vertical = 3 + +[node name="LeftMargin" type="CenterContainer" parent="MainBox/Body"] +custom_minimum_size = Vector2(5, 0) +layout_mode = 2 + +[node name="BodyRows" type="VBoxContainer" parent="MainBox/Body"] +layout_mode = 2 +size_flags_horizontal = 3 + +[node name="ProgressBars" type="HBoxContainer" parent="MainBox/Body/BodyRows"] +layout_mode = 2 +size_flags_horizontal = 3 + +[node name="HBoxContainer" type="HBoxContainer" parent="MainBox/Body/BodyRows/ProgressBars"] +layout_mode = 2 +size_flags_horizontal = 3 + +[node name="Label" type="Label" parent="MainBox/Body/BodyRows/ProgressBars/HBoxContainer"] +layout_mode = 2 +text = "T:" + +[node name="ProgressTest" type="ProgressBar" parent="MainBox/Body/BodyRows/ProgressBars/HBoxContainer"] +custom_minimum_size = Vector2(100, 0) +layout_mode = 2 +size_flags_horizontal = 3 +value = 25.0 + +[node name="HBoxContainer2" type="HBoxContainer" parent="MainBox/Body/BodyRows/ProgressBars"] +layout_mode = 2 +size_flags_horizontal = 3 + +[node name="Label" type="Label" parent="MainBox/Body/BodyRows/ProgressBars/HBoxContainer2"] +layout_mode = 2 +text = "S:" + +[node name="ProgressScript" type="ProgressBar" parent="MainBox/Body/BodyRows/ProgressBars/HBoxContainer2"] +custom_minimum_size = Vector2(100, 0) +layout_mode = 2 +size_flags_horizontal = 3 +value = 75.0 + +[node name="PathDisplay" type="VBoxContainer" parent="MainBox/Body/BodyRows"] +clip_contents = true +layout_mode = 2 +size_flags_vertical = 3 + +[node name="Path" type="Label" parent="MainBox/Body/BodyRows/PathDisplay"] +layout_mode = 2 +theme_override_fonts/font = ExtResource("2_a2e2l") +theme_override_font_sizes/font_size = 14 +text = "res://test/integration/whatever" +clip_text = true +text_overrun_behavior = 3 + +[node name="HBoxContainer" type="HBoxContainer" parent="MainBox/Body/BodyRows/PathDisplay"] +clip_contents = true +layout_mode = 2 + +[node name="S3" type="CenterContainer" parent="MainBox/Body/BodyRows/PathDisplay/HBoxContainer"] +custom_minimum_size = Vector2(5, 0) +layout_mode = 2 + +[node name="File" type="Label" parent="MainBox/Body/BodyRows/PathDisplay/HBoxContainer"] +layout_mode = 2 +size_flags_horizontal = 3 +theme_override_fonts/font = ExtResource("2_a2e2l") +theme_override_font_sizes/font_size = 14 +text = "test_this_thing.gd" +text_overrun_behavior = 3 + +[node name="Footer" type="HBoxContainer" parent="MainBox/Body/BodyRows"] +layout_mode = 2 + +[node name="HandleLeft" parent="MainBox/Body/BodyRows/Footer" node_paths=PackedStringArray("resize_control") instance=ExtResource("4_xrhva")] +layout_mode = 2 +orientation = 0 +resize_control = NodePath("../../../../..") +vertical_resize = false + +[node name="SwitchModes" type="Button" parent="MainBox/Body/BodyRows/Footer"] +layout_mode = 2 +text = "Expand" + +[node name="CenterContainer" type="CenterContainer" parent="MainBox/Body/BodyRows/Footer"] +layout_mode = 2 +size_flags_horizontal = 3 + +[node name="Continue" type="Button" parent="MainBox/Body/BodyRows/Footer"] +layout_mode = 2 +text = "Continue +" + +[node name="HandleRight" parent="MainBox/Body/BodyRows/Footer" node_paths=PackedStringArray("resize_control") instance=ExtResource("4_xrhva")] +layout_mode = 2 +resize_control = NodePath("../../../../..") +vertical_resize = false + +[node name="RightMargin" type="CenterContainer" parent="MainBox/Body"] +custom_minimum_size = Vector2(5, 0) +layout_mode = 2 + +[node name="CenterContainer" type="CenterContainer" parent="MainBox"] +custom_minimum_size = Vector2(2.08165e-12, 2) +layout_mode = 2 diff --git a/samples/client/petstore/gdscript/addons/gut/gui/NormalGui.tscn b/samples/client/petstore/gdscript/addons/gut/gui/NormalGui.tscn new file mode 100644 index 000000000000..f9b85efa5d11 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/gui/NormalGui.tscn @@ -0,0 +1,216 @@ +[gd_scene load_steps=5 format=3 uid="uid://duxblir3vu8x7"] + +[ext_resource type="Theme" uid="uid://cstkhwkpajvqu" path="res://addons/gut/gui/GutSceneTheme.tres" id="1_5hlsm"] +[ext_resource type="Script" path="res://addons/gut/gui/gut_gui.gd" id="2_fue6q"] +[ext_resource type="FontFile" uid="uid://bnh0lslf4yh87" path="res://addons/gut/fonts/CourierPrime-Regular.ttf" id="2_u5uc1"] +[ext_resource type="PackedScene" uid="uid://bvrqqgjpyouse" path="res://addons/gut/gui/ResizeHandle.tscn" id="4_2r8a8"] + +[node name="Large" type="Panel"] +custom_minimum_size = Vector2(500, 150) +offset_right = 632.0 +offset_bottom = 260.0 +theme = ExtResource("1_5hlsm") +script = ExtResource("2_fue6q") + +[node name="MainBox" type="VBoxContainer" parent="."] +layout_mode = 0 +anchor_right = 1.0 +anchor_bottom = 1.0 +grow_horizontal = 2 +grow_vertical = 2 +metadata/_edit_layout_mode = 1 + +[node name="TitleBar" type="Panel" parent="MainBox"] +custom_minimum_size = Vector2(0, 25) +layout_mode = 2 + +[node name="TitleBox" type="HBoxContainer" parent="MainBox/TitleBar"] +layout_mode = 0 +anchor_right = 1.0 +anchor_bottom = 1.0 +offset_top = 2.0 +offset_bottom = 3.0 +grow_horizontal = 2 +grow_vertical = 2 +metadata/_edit_layout_mode = 1 + +[node name="Spacer1" type="CenterContainer" parent="MainBox/TitleBar/TitleBox"] +layout_mode = 2 +size_flags_horizontal = 3 + +[node name="Title" type="Label" parent="MainBox/TitleBar/TitleBox"] +layout_mode = 2 +text = "Title" + +[node name="Spacer2" type="CenterContainer" parent="MainBox/TitleBar/TitleBox"] +layout_mode = 2 +size_flags_horizontal = 3 + +[node name="TimeLabel" type="Label" parent="MainBox/TitleBar/TitleBox"] +custom_minimum_size = Vector2(90, 0) +layout_mode = 2 +text = "999.999s" + +[node name="HBoxContainer" type="HBoxContainer" parent="MainBox"] +layout_mode = 2 +size_flags_vertical = 3 + +[node name="VBoxContainer" type="VBoxContainer" parent="MainBox/HBoxContainer"] +layout_mode = 2 +size_flags_horizontal = 3 + +[node name="OutputBG" type="ColorRect" parent="MainBox/HBoxContainer/VBoxContainer"] +layout_mode = 2 +size_flags_vertical = 3 +color = Color(0.0745098, 0.0705882, 0.0784314, 1) +metadata/_edit_layout_mode = 1 + +[node name="HBoxContainer" type="HBoxContainer" parent="MainBox/HBoxContainer/VBoxContainer/OutputBG"] +layout_mode = 0 +anchor_right = 1.0 +anchor_bottom = 1.0 +grow_horizontal = 2 +grow_vertical = 2 + +[node name="S2" type="CenterContainer" parent="MainBox/HBoxContainer/VBoxContainer/OutputBG/HBoxContainer"] +custom_minimum_size = Vector2(5, 0) +layout_mode = 2 + +[node name="TestOutput" type="RichTextLabel" parent="MainBox/HBoxContainer/VBoxContainer/OutputBG/HBoxContainer"] +layout_mode = 2 +size_flags_horizontal = 3 +size_flags_vertical = 3 +focus_mode = 2 +bbcode_enabled = true +scroll_following = true +autowrap_mode = 0 +selection_enabled = true + +[node name="S1" type="CenterContainer" parent="MainBox/HBoxContainer/VBoxContainer/OutputBG/HBoxContainer"] +custom_minimum_size = Vector2(5, 0) +layout_mode = 2 + +[node name="ControlBox" type="HBoxContainer" parent="MainBox/HBoxContainer/VBoxContainer"] +layout_mode = 2 + +[node name="S1" type="CenterContainer" parent="MainBox/HBoxContainer/VBoxContainer/ControlBox"] +custom_minimum_size = Vector2(5, 0) +layout_mode = 2 + +[node name="ProgressBars" type="VBoxContainer" parent="MainBox/HBoxContainer/VBoxContainer/ControlBox"] +custom_minimum_size = Vector2(2.08165e-12, 2.08165e-12) +layout_mode = 2 + +[node name="TestBox" type="HBoxContainer" parent="MainBox/HBoxContainer/VBoxContainer/ControlBox/ProgressBars"] +layout_mode = 2 + +[node name="Label" type="Label" parent="MainBox/HBoxContainer/VBoxContainer/ControlBox/ProgressBars/TestBox"] +custom_minimum_size = Vector2(60, 0) +layout_mode = 2 +size_flags_horizontal = 3 +text = "Tests" + +[node name="ProgressTest" type="ProgressBar" parent="MainBox/HBoxContainer/VBoxContainer/ControlBox/ProgressBars/TestBox"] +custom_minimum_size = Vector2(100, 0) +layout_mode = 2 +value = 25.0 + +[node name="ScriptBox" type="HBoxContainer" parent="MainBox/HBoxContainer/VBoxContainer/ControlBox/ProgressBars"] +layout_mode = 2 + +[node name="Label" type="Label" parent="MainBox/HBoxContainer/VBoxContainer/ControlBox/ProgressBars/ScriptBox"] +custom_minimum_size = Vector2(60, 0) +layout_mode = 2 +size_flags_horizontal = 3 +text = "Scripts" + +[node name="ProgressScript" type="ProgressBar" parent="MainBox/HBoxContainer/VBoxContainer/ControlBox/ProgressBars/ScriptBox"] +custom_minimum_size = Vector2(100, 0) +layout_mode = 2 +value = 75.0 + +[node name="PathDisplay" type="VBoxContainer" parent="MainBox/HBoxContainer/VBoxContainer/ControlBox"] +layout_mode = 2 +size_flags_horizontal = 3 +size_flags_vertical = 3 + +[node name="Path" type="Label" parent="MainBox/HBoxContainer/VBoxContainer/ControlBox/PathDisplay"] +layout_mode = 2 +size_flags_vertical = 6 +theme_override_fonts/font = ExtResource("2_u5uc1") +theme_override_font_sizes/font_size = 14 +text = "res://test/integration/whatever" +text_overrun_behavior = 3 + +[node name="HBoxContainer" type="HBoxContainer" parent="MainBox/HBoxContainer/VBoxContainer/ControlBox/PathDisplay"] +layout_mode = 2 +size_flags_vertical = 3 + +[node name="S3" type="CenterContainer" parent="MainBox/HBoxContainer/VBoxContainer/ControlBox/PathDisplay/HBoxContainer"] +custom_minimum_size = Vector2(5, 0) +layout_mode = 2 + +[node name="File" type="Label" parent="MainBox/HBoxContainer/VBoxContainer/ControlBox/PathDisplay/HBoxContainer"] +layout_mode = 2 +size_flags_horizontal = 3 +theme_override_fonts/font = ExtResource("2_u5uc1") +theme_override_font_sizes/font_size = 14 +text = "test_this_thing.gd" +text_overrun_behavior = 3 + +[node name="Spacer1" type="CenterContainer" parent="MainBox/HBoxContainer/VBoxContainer/ControlBox"] +visible = false +layout_mode = 2 +size_flags_horizontal = 10 + +[node name="Continue" type="Button" parent="MainBox/HBoxContainer/VBoxContainer/ControlBox"] +layout_mode = 2 +size_flags_vertical = 4 +text = "Continue +" + +[node name="S3" type="CenterContainer" parent="MainBox/HBoxContainer/VBoxContainer/ControlBox"] +custom_minimum_size = Vector2(5, 0) +layout_mode = 2 + +[node name="BottomPad" type="CenterContainer" parent="MainBox"] +custom_minimum_size = Vector2(0, 5) +layout_mode = 2 + +[node name="Footer" type="HBoxContainer" parent="MainBox"] +layout_mode = 2 + +[node name="SidePad1" type="CenterContainer" parent="MainBox/Footer"] +custom_minimum_size = Vector2(2, 2.08165e-12) +layout_mode = 2 + +[node name="ResizeHandle3" parent="MainBox/Footer" node_paths=PackedStringArray("resize_control") instance=ExtResource("4_2r8a8")] +custom_minimum_size = Vector2(25, 25) +layout_mode = 2 +orientation = 0 +resize_control = NodePath("../../..") +vertical_resize = null + +[node name="SwitchModes" type="Button" parent="MainBox/Footer"] +layout_mode = 2 +text = "Compact +" + +[node name="CenterContainer" type="CenterContainer" parent="MainBox/Footer"] +layout_mode = 2 +size_flags_horizontal = 3 + +[node name="ResizeHandle2" parent="MainBox/Footer" node_paths=PackedStringArray("resize_control") instance=ExtResource("4_2r8a8")] +custom_minimum_size = Vector2(25, 25) +layout_mode = 2 +orientation = 1 +resize_control = NodePath("../../..") +vertical_resize = null + +[node name="SidePad2" type="CenterContainer" parent="MainBox/Footer"] +custom_minimum_size = Vector2(2, 2.08165e-12) +layout_mode = 2 + +[node name="BottomPad2" type="CenterContainer" parent="MainBox"] +custom_minimum_size = Vector2(2.08165e-12, 2) +layout_mode = 2 diff --git a/samples/client/petstore/gdscript/addons/gut/gui/OutputText.gd b/samples/client/petstore/gdscript/addons/gut/gui/OutputText.gd new file mode 100644 index 000000000000..22eaa34c46b4 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/gui/OutputText.gd @@ -0,0 +1,341 @@ +@tool +extends VBoxContainer + +# ############################################################################## +# Keeps search results from the TextEdit +# ############################################################################## +class TextEditSearcher: + var te : TextEdit + var _last_term = '' + var _last_pos = Vector2(-1, -1) + var _ignore_caret_change = false + + func set_text_edit(which): + te = which + te.caret_changed.connect(_on_caret_changed) + + + func _on_caret_changed(): + if(_ignore_caret_change): + _ignore_caret_change = false + else: + _last_pos = _get_caret(); + + + func _get_caret(): + return Vector2(te.get_caret_column(), te.get_caret_line()) + + + func _set_caret_and_sel(pos, len): + te.set_caret_line(pos.y) + te.set_caret_column(pos.x) + if(len > 0): + te.select(pos.y, pos.x, pos.y, pos.x + len) + + + func _find(term, search_flags): + var pos = _get_caret() + if(term == _last_term): + if(search_flags == 0): + pos = _last_pos + pos.x += 1 + else: + pos = _last_pos + pos.x -= 1 + + var result = te.search(term, search_flags, pos.y, pos.x) +# print('searching from ', pos, ' for "', term, '" = ', result) + if(result.y != -1): + _ignore_caret_change = true + _set_caret_and_sel(result, term.length()) + _last_pos = result + + _last_term = term + + func find_next(term): + _find(term, 0) + + func find_prev(term): + _find(term, te.SEARCH_BACKWARDS) + + + +# ############################################################################## +# Start OutputText control code +# ############################################################################## +@onready var _ctrls = { + output = $Output, + + copy_button = $Toolbar/CopyButton, + use_colors = $Toolbar/UseColors, + clear_button = $Toolbar/ClearButton, + word_wrap = $Toolbar/WordWrap, + show_search = $Toolbar/ShowSearch, + caret_position = $Toolbar/LblPosition, + + search_bar = { + bar = $Search, + search_term = $Search/SearchTerm, + } +} + +var _sr = TextEditSearcher.new() +var _highlighter : CodeHighlighter + +# Automatically used when running the OutputText scene from the editor. Changes +# to this method only affect test-running the control through the editor. +func _test_running_setup(): + _ctrls.use_colors.text = 'use colors' + _ctrls.show_search.text = 'search' + _ctrls.word_wrap.text = 'ww' + + set_all_fonts("CourierPrime") + set_font_size(5) +# print(_ctrls.output.get_theme_font_size("normal_font")) + _ctrls.output.queue_redraw() + + load_file('user://.gut_editor.bbcode') + await get_tree().process_frame + + show_search(true) + _ctrls.output.set_caret_line(0) + _ctrls.output.scroll_vertical = 0 + + _ctrls.output.caret_changed.connect(_on_caret_changed) + + +func _on_caret_changed(): + var txt = str("line:",_ctrls.output.get_caret_line(), ' col:', _ctrls.output.get_caret_column()) + _ctrls.caret_position.text = str(txt) + + +func _ready(): + _sr.set_text_edit(_ctrls.output) + _ctrls.use_colors.icon = get_theme_icon('RichTextEffect', 'EditorIcons') + _ctrls.show_search.icon = get_theme_icon('Search', 'EditorIcons') + _ctrls.word_wrap.icon = get_theme_icon('Loop', 'EditorIcons') + + _setup_colors() + _ctrls.use_colors.button_pressed = true + _use_highlighting(true) + + if(get_parent() == get_tree().root): + _test_running_setup() + +# ------------------ +# Private +# ------------------ + +# Call this after changes in colors and the like to get them to apply. reloads +# the text of the output control. +func _refresh_output(): + var orig_pos = _ctrls.output.scroll_vertical + var text = _ctrls.output.text + + _ctrls.output.text = text + _ctrls.output.scroll_vertical = orig_pos + + +func _create_highlighter(default_color=Color(1, 1, 1, 1)): + var to_return = CodeHighlighter.new() + + to_return.function_color = default_color + to_return.number_color = default_color + to_return.symbol_color = default_color + to_return.member_variable_color = default_color + + var keywords = [ + ['Failed', Color.RED], + ['Passed', Color.GREEN], + ['Pending', Color.YELLOW], + ['Orphans', Color.YELLOW], + ['WARNING', Color.YELLOW], + ['ERROR', Color.RED] + ] + + for keyword in keywords: + to_return.add_keyword_color(keyword[0], keyword[1]) + + return to_return + + +func _setup_colors(): + _ctrls.output.clear() + + var f_color = null + if (_ctrls.output.theme == null) : + f_color = get_theme_color("font_color") + else : + f_color = _ctrls.output.theme.font_color + + _highlighter = _create_highlighter() + _ctrls.output.queue_redraw() + + +func _set_font(font_name, custom_name): + var rtl = _ctrls.output + if(font_name == null): + rtl.add_theme_font_override(custom_name, null) + else: + var dyn_font = FontFile.new() + dyn_font.load_dynamic_font('res://addons/gut/fonts/' + font_name + '.ttf') + rtl.add_theme_font_override(custom_name, dyn_font) + + +func _use_highlighting(should): + if(should): + _ctrls.output.syntax_highlighter = _highlighter + else: + _ctrls.output.syntax_highlighter = null + _refresh_output() + +# ------------------ +# Events +# ------------------ +func _on_CopyButton_pressed(): + copy_to_clipboard() + + +func _on_UseColors_pressed(): + _use_highlighting(_ctrls.use_colors.button_pressed) + + +func _on_ClearButton_pressed(): + clear() + + +func _on_ShowSearch_pressed(): + show_search(_ctrls.show_search.button_pressed) + + +func _on_SearchTerm_focus_entered(): + _ctrls.search_bar.search_term.call_deferred('select_all') + +func _on_SearchNext_pressed(): + _sr.find_next(_ctrls.search_bar.search_term.text) + + +func _on_SearchPrev_pressed(): + _sr.find_prev(_ctrls.search_bar.search_term.text) + + +func _on_SearchTerm_text_changed(new_text): + if(new_text == ''): + _ctrls.output.deselect() + else: + _sr.find_next(new_text) + + +func _on_SearchTerm_text_entered(new_text): + if(Input.is_physical_key_pressed(KEY_SHIFT)): + _sr.find_prev(new_text) + else: + _sr.find_next(new_text) + + +func _on_SearchTerm_gui_input(event): + if(event is InputEventKey and !event.pressed and event.keycode == KEY_ESCAPE): + show_search(false) + + +func _on_WordWrap_pressed(): + if(_ctrls.word_wrap.button_pressed): + _ctrls.output.wrap_mode = TextEdit.LINE_WRAPPING_BOUNDARY + else: + _ctrls.output.wrap_mode = TextEdit.LINE_WRAPPING_NONE + + _ctrls.output.queue_redraw() + +# ------------------ +# Public +# ------------------ +func show_search(should): + _ctrls.search_bar.bar.visible = should + if(should): + _ctrls.search_bar.search_term.grab_focus() + _ctrls.search_bar.search_term.select_all() + _ctrls.show_search.button_pressed = should + + +func search(text, start_pos, highlight=true): + return _sr.find_next(text) + + +func copy_to_clipboard(): + var selected = _ctrls.output.get_selected_text() + if(selected != ''): + DisplayServer.clipboard_set(selected) + else: + DisplayServer.clipboard_set(_ctrls.output.text) + + +func clear(): + _ctrls.output.text = '' + + +func set_all_fonts(base_name): + if(base_name == 'Default'): + _set_font(null, 'font') + _set_font(null, 'normal_font') + _set_font(null, 'bold_font') + _set_font(null, 'italics_font') + _set_font(null, 'bold_italics_font') + else: + _set_font(base_name + '-Regular', 'font') + _set_font(base_name + '-Regular', 'normal_font') + _set_font(base_name + '-Bold', 'bold_font') + _set_font(base_name + '-Italic', 'italics_font') + _set_font(base_name + '-BoldItalic', 'bold_italics_font') + + +func set_font_size(new_size): + return # this isn't working. + var rtl = _ctrls.output +# rtl.add_theme_font_size_override("font", new_size) +# rtl.add_theme_font_size_override("normal_font", new_size) +# rtl.add_theme_font_size_override("bold_font", new_size) +# rtl.add_theme_font_size_override("italics_font", new_size) +# rtl.add_theme_font_size_override("bold_italics_font", new_size) + rtl.set("theme_override_font_sizes/size", new_size) +# print(rtl.get("theme_override_font_sizes/size")) + +# if(rtl.get('custom_fonts/font') != null): +# rtl.get('custom_fonts/font').size = new_size +# rtl.get('custom_fonts/bold_italics_font').size = new_size +# rtl.get('custom_fonts/bold_font').size = new_size +# rtl.get('custom_fonts/italics_font').size = new_size +# rtl.get('custom_fonts/normal_font').size = new_size + + +func set_use_colors(value): + pass + + +func get_use_colors(): + return false; + + +func get_rich_text_edit(): + return _ctrls.output + + +func load_file(path): + var f = FileAccess.open(path, FileAccess.READ) + if(f == null): + return + + var t = f.get_as_text() + f = null # closes file + _ctrls.output.text = t + _ctrls.output.scroll_vertical = _ctrls.output.get_line_count() + _ctrls.output.set_deferred('scroll_vertical', _ctrls.output.get_line_count()) + + +func add_text(text): + if(is_inside_tree()): + _ctrls.output.text += text + + +func scroll_to_line(line): + _ctrls.output.scroll_vertical = line + _ctrls.output.set_caret_line(line) diff --git a/samples/client/petstore/gdscript/addons/gut/gui/OutputText.tscn b/samples/client/petstore/gdscript/addons/gut/gui/OutputText.tscn new file mode 100644 index 000000000000..32fe9f6cce68 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/gui/OutputText.tscn @@ -0,0 +1,114 @@ +[gd_scene load_steps=5 format=3 uid="uid://bqmo4dj64c7yl"] + +[ext_resource type="Script" path="res://addons/gut/gui/OutputText.gd" id="1"] + +[sub_resource type="Image" id="Image_o4jv5"] +data = { +"data": PackedByteArray(255, 255, 255, 0, 255, 255, 255, 0, 255, 128, 128, 4, 255, 128, 128, 4, 255, 128, 128, 4, 255, 128, 128, 4, 255, 128, 128, 4, 255, 128, 128, 4, 255, 128, 128, 4, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 255, 255, 0, 255, 93, 93, 131, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 255, 255, 0, 255, 93, 93, 255, 255, 93, 93, 131, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 255, 255, 0, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 131, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 255, 255, 0, 255, 93, 93, 252, 255, 93, 93, 252, 255, 93, 93, 252, 255, 94, 94, 127, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 128, 128, 4, 255, 128, 128, 4, 255, 128, 128, 4, 255, 128, 128, 4, 255, 128, 128, 4, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 93, 93, 231, 255, 93, 93, 55, 255, 97, 97, 58, 255, 93, 93, 233, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 231, 255, 94, 94, 54, 255, 94, 94, 57, 255, 93, 93, 233, 255, 93, 93, 255, 255, 93, 93, 255, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 97, 97, 42, 255, 255, 255, 0, 255, 255, 255, 0, 255, 97, 97, 42, 255, 93, 93, 233, 255, 93, 93, 232, 255, 93, 93, 41, 255, 255, 255, 0, 255, 255, 255, 0, 255, 97, 97, 42, 255, 93, 93, 233, 255, 93, 93, 232, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 96, 96, 45, 255, 97, 97, 42, 255, 255, 255, 0, 255, 97, 97, 42, 255, 97, 97, 42, 255, 255, 255, 0, 255, 98, 98, 47, 255, 97, 97, 42, 255, 255, 255, 0, 255, 97, 97, 42, 255, 97, 97, 42, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 96, 96, 45, 255, 93, 93, 235, 255, 93, 93, 233, 255, 97, 97, 42, 255, 255, 255, 0, 255, 255, 255, 0, 255, 94, 94, 46, 255, 93, 93, 236, 255, 93, 93, 233, 255, 97, 97, 42, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 93, 93, 235, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 233, 255, 95, 95, 59, 255, 96, 96, 61, 255, 93, 93, 235, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 233, 255, 95, 95, 59, 255, 96, 96, 61, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 93, 93, 255, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 93, 93, 252, 255, 93, 93, 252, 255, 93, 93, 252, 255, 93, 93, 252, 255, 93, 93, 252, 255, 93, 93, 252, 255, 93, 93, 252, 255, 93, 93, 252, 255, 93, 93, 252, 255, 93, 93, 252, 255, 93, 93, 252, 255, 93, 93, 252, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 0), +"format": "RGBA8", +"height": 16, +"mipmaps": false, +"width": 16 +} + +[sub_resource type="ImageTexture" id="ImageTexture_uk57o"] +image = SubResource("Image_o4jv5") + +[sub_resource type="CodeHighlighter" id="CodeHighlighter_sv352"] +number_color = Color(1, 1, 1, 1) +symbol_color = Color(1, 1, 1, 1) +function_color = Color(1, 1, 1, 1) +member_variable_color = Color(1, 1, 1, 1) +keyword_colors = { +"ERROR": Color(1, 0, 0, 1), +"Failed": Color(1, 0, 0, 1), +"Orphans": Color(1, 1, 0, 1), +"Passed": Color(0, 1, 0, 1), +"Pending": Color(1, 1, 0, 1), +"WARNING": Color(1, 1, 0, 1) +} + +[node name="OutputText" type="VBoxContainer"] +offset_right = 862.0 +offset_bottom = 523.0 +size_flags_horizontal = 3 +size_flags_vertical = 3 +script = ExtResource("1") + +[node name="Toolbar" type="HBoxContainer" parent="."] +layout_mode = 2 +size_flags_horizontal = 3 + +[node name="ShowSearch" type="Button" parent="Toolbar"] +layout_mode = 2 +tooltip_text = "Search" +toggle_mode = true +icon = SubResource("ImageTexture_uk57o") + +[node name="UseColors" type="Button" parent="Toolbar"] +layout_mode = 2 +tooltip_text = "Colorized Text" +toggle_mode = true +button_pressed = true +icon = SubResource("ImageTexture_uk57o") + +[node name="WordWrap" type="Button" parent="Toolbar"] +layout_mode = 2 +tooltip_text = "Word Wrap" +toggle_mode = true +icon = SubResource("ImageTexture_uk57o") + +[node name="CenterContainer" type="CenterContainer" parent="Toolbar"] +layout_mode = 2 +size_flags_horizontal = 3 + +[node name="LblPosition" type="Label" parent="Toolbar"] +layout_mode = 2 + +[node name="CopyButton" type="Button" parent="Toolbar"] +layout_mode = 2 +text = " Copy " + +[node name="ClearButton" type="Button" parent="Toolbar"] +layout_mode = 2 +text = " Clear " + +[node name="Output" type="TextEdit" parent="."] +layout_mode = 2 +size_flags_horizontal = 3 +size_flags_vertical = 3 +deselect_on_focus_loss_enabled = false +virtual_keyboard_enabled = false +middle_mouse_paste_enabled = false +highlight_all_occurrences = true +highlight_current_line = true +syntax_highlighter = SubResource("CodeHighlighter_sv352") +scroll_smooth = true + +[node name="Search" type="HBoxContainer" parent="."] +visible = false +layout_mode = 2 + +[node name="SearchTerm" type="LineEdit" parent="Search"] +layout_mode = 2 +size_flags_horizontal = 3 + +[node name="SearchNext" type="Button" parent="Search"] +layout_mode = 2 +text = "Next" + +[node name="SearchPrev" type="Button" parent="Search"] +layout_mode = 2 +text = "Prev" + +[connection signal="pressed" from="Toolbar/ShowSearch" to="." method="_on_ShowSearch_pressed"] +[connection signal="pressed" from="Toolbar/UseColors" to="." method="_on_UseColors_pressed"] +[connection signal="pressed" from="Toolbar/WordWrap" to="." method="_on_WordWrap_pressed"] +[connection signal="pressed" from="Toolbar/CopyButton" to="." method="_on_CopyButton_pressed"] +[connection signal="pressed" from="Toolbar/ClearButton" to="." method="_on_ClearButton_pressed"] +[connection signal="focus_entered" from="Search/SearchTerm" to="." method="_on_SearchTerm_focus_entered"] +[connection signal="gui_input" from="Search/SearchTerm" to="." method="_on_SearchTerm_gui_input"] +[connection signal="text_changed" from="Search/SearchTerm" to="." method="_on_SearchTerm_text_changed"] +[connection signal="text_submitted" from="Search/SearchTerm" to="." method="_on_SearchTerm_text_entered"] +[connection signal="pressed" from="Search/SearchNext" to="." method="_on_SearchNext_pressed"] +[connection signal="pressed" from="Search/SearchPrev" to="." method="_on_SearchPrev_pressed"] diff --git a/samples/client/petstore/gdscript/addons/gut/gui/ResizeHandle.gd b/samples/client/petstore/gdscript/addons/gut/gui/ResizeHandle.gd new file mode 100644 index 000000000000..3d46fde3442f --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/gui/ResizeHandle.gd @@ -0,0 +1,108 @@ +@tool +extends ColorRect +# ############################################################################# +# Resize Handle control. Place onto a control. Set the orientation, then +# set the control that this should resize. Then you can resize the control +# by dragging this thing around. It's pretty neat. +# ############################################################################# +enum ORIENTATION { + LEFT, + RIGHT +} + +@export var orientation := ORIENTATION.RIGHT : + get: return orientation + set(val): + orientation = val + queue_redraw() +@export var resize_control : Control = null +@export var vertical_resize := true + +var _line_width = .5 +var _line_color = Color(.4, .4, .4) +var _active_line_color = Color(.3, .3, .3) +var _invalid_line_color = Color(1, 0, 0) + +var _grab_margin = 2 +var _line_space = 3 +var _num_lines = 8 + +var _mouse_down = false +# Called when the node enters the scene tree for the first time. + + +func _draw(): + var c = _line_color + if(resize_control == null): + c = _invalid_line_color + elif(_mouse_down): + c = _active_line_color + + if(orientation == ORIENTATION.LEFT): + _draw_resize_handle_left(c) + else: + _draw_resize_handle_right(c) + + +func _gui_input(event): + if(resize_control == null): + return + + if(orientation == ORIENTATION.LEFT): + _handle_left_input(event) + else: + _handle_right_input(event) + + +# Draw the lines in the corner to show where you can +# drag to resize the dialog +func _draw_resize_handle_right(color): + var br = size + + for i in range(_num_lines): + var start = br - Vector2(i * _line_space, 0) + var end = br - Vector2(0, i * _line_space) + draw_line(start, end, color, _line_width, true) + + +func _draw_resize_handle_left(color): + var bl = Vector2(0, size.y) + + for i in range(_num_lines): + var start = bl + Vector2(i * _line_space, 0) + var end = bl - Vector2(0, i * _line_space) + draw_line(start, end, color, _line_width, true) + + +func _handle_right_input(event : InputEvent): + if(event is InputEventMouseMotion): + if(_mouse_down and + event.global_position.x > 0 and + event.global_position.y < DisplayServer.window_get_size().y): + + if(vertical_resize): + resize_control.size.y += event.relative.y + resize_control.size.x += event.relative.x + elif(event is InputEventMouseButton): + if(event.button_index == MOUSE_BUTTON_LEFT): + _mouse_down = event.pressed + queue_redraw() + + +func _handle_left_input(event : InputEvent): + if(event is InputEventMouseMotion): + if(_mouse_down and + event.global_position.x > 0 and + event.global_position.y < DisplayServer.window_get_size().y): + + var start_size = resize_control.size + resize_control.size.x -= event.relative.x + if(resize_control.size.x != start_size.x): + resize_control.global_position.x += event.relative.x + + if(vertical_resize): + resize_control.size.y += event.relative.y + elif(event is InputEventMouseButton): + if(event.button_index == MOUSE_BUTTON_LEFT): + _mouse_down = event.pressed + queue_redraw() diff --git a/samples/client/petstore/gdscript/addons/gut/gui/ResizeHandle.tscn b/samples/client/petstore/gdscript/addons/gut/gui/ResizeHandle.tscn new file mode 100644 index 000000000000..2862ec92c270 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/gui/ResizeHandle.tscn @@ -0,0 +1,8 @@ +[gd_scene load_steps=2 format=3 uid="uid://bvrqqgjpyouse"] + +[ext_resource type="Script" path="res://addons/gut/gui/ResizeHandle.gd" id="1_oi5ed"] + +[node name="ResizeHandle" type="ColorRect"] +custom_minimum_size = Vector2(20, 20) +color = Color(1, 1, 1, 0) +script = ExtResource("1_oi5ed") diff --git a/samples/client/petstore/gdscript/addons/gut/gui/ResultsTree.gd b/samples/client/petstore/gdscript/addons/gut/gui/ResultsTree.gd new file mode 100644 index 000000000000..4438ddaf786b --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/gui/ResultsTree.gd @@ -0,0 +1,348 @@ +@tool +extends Control + +var _show_orphans = true +var show_orphans = true : + get: return _show_orphans + set(val): _show_orphans = val + + +var _hide_passing = true +var hide_passing = true : + get: return _hide_passing + set(val): _hide_passing = val + + +var _icons = { + red = load('res://addons/gut/images/red.png'), + green = load('res://addons/gut/images/green.png'), + yellow = load('res://addons/gut/images/yellow.png'), +} +const _col_1_bg_color = Color(0, 0, 0, .1) +var _max_icon_width = 10 +var _root : TreeItem + +@onready var _ctrls = { + tree = $Tree, + lbl_overlay = $Tree/TextOverlay +} + + +signal item_selected(script_path, inner_class, test_name, line_number) +# ------------------- +# Private +# ------------------- +func _ready(): + _root = _ctrls.tree.create_item() + _root = _ctrls.tree.create_item() + _ctrls.tree.set_hide_root(true) + _ctrls.tree.columns = 2 + _ctrls.tree.set_column_expand(0, true) + _ctrls.tree.set_column_expand(1, false) + _ctrls.tree.set_column_clip_content(0, true) + + $Tree.item_selected.connect(_on_tree_item_selected) + + if(get_parent() == get_tree().root): + _test_running_setup() + +func _test_running_setup(): + load_json_file('user://.gut_editor.json') + + +func _on_tree_item_selected(): + var item = _ctrls.tree.get_selected() + var item_meta = item.get_metadata(0) + var item_type = null + + # Only select the left side of the tree item, cause I like that better. + # you can still click the right, but only the left gets highlighted. + if(item.is_selected(1)): + item.deselect(1) + item.select(0) + + if(item_meta == null): + return + else: + item_type = item_meta.type + + var script_path = ''; + var line = -1; + var test_name = '' + var inner_class = '' + + if(item_type == 'test'): + var s_item = item.get_parent() + script_path = s_item.get_metadata(0)['path'] + inner_class = s_item.get_metadata(0)['inner_class'] + line = -1 + test_name = item.get_text(0) + elif(item_type == 'assert'): + var s_item = item.get_parent().get_parent() + script_path = s_item.get_metadata(0)['path'] + inner_class = s_item.get_metadata(0)['inner_class'] + line = _get_line_number_from_assert_msg(item.get_text(0)) + test_name = item.get_parent().get_text(0) + elif(item_type == 'script'): + script_path = item.get_metadata(0)['path'] + if(item.get_parent() != _root): + inner_class = item.get_text(0) + line = -1 + test_name = '' + else: + return + + item_selected.emit(script_path, inner_class, test_name, line) + + +func _get_line_number_from_assert_msg(msg): + var line = -1 + if(msg.find('at line') > 0): + line = msg.split("at line")[-1].split(" ")[-1].to_int() + return line + + +func _get_path_and_inner_class_name_from_test_path(path): + var to_return = { + path = '', + inner_class = '' + } + + to_return.path = path + if !path.ends_with('.gd'): + var loc = path.find('.gd') + to_return.inner_class = path.split('.')[-1] + to_return.path = path.substr(0, loc + 3) + return to_return + + +func _find_script_item_with_path(path): + var items = _root.get_children() + var to_return = null + + var idx = 0 + while(idx < items.size() and to_return == null): + var item = items[idx] + if(item.get_metadata(0).path == path): + to_return = item + else: + idx += 1 + + return to_return + + +func _add_script_tree_item(script_path, script_json): + var path_info = _get_path_and_inner_class_name_from_test_path(script_path) + var item_text = script_path + var parent = _root + + if(path_info.inner_class != ''): + parent = _find_script_item_with_path(path_info.path) + item_text = path_info.inner_class + if(parent == null): + parent = _add_script_tree_item(path_info.path, {}) + + parent.get_metadata(0).inner_tests += script_json['props']['tests'] + parent.get_metadata(0).inner_passing += script_json['props']['tests'] + parent.get_metadata(0).inner_passing -= script_json['props']['failures'] + parent.get_metadata(0).inner_passing -= script_json['props']['pending'] + + var total_text = str("All ", parent.get_metadata(0).inner_tests, " passed") + if(parent.get_metadata(0).inner_passing != parent.get_metadata(0).inner_tests): + total_text = str(parent.get_metadata(0).inner_passing, '/', parent.get_metadata(0).inner_tests, ' passed.') + parent.set_text(1, total_text) + + var item = _ctrls.tree.create_item(parent) + item.set_text(0, item_text) + var meta = { + "type":"script", + "path":path_info.path, + "inner_class":path_info.inner_class, + "json":script_json, + "inner_passing":0, + "inner_tests":0 + } + item.set_metadata(0, meta) + item.set_custom_bg_color(1, _col_1_bg_color) + + return item + + +func _add_assert_item(text, icon, parent_item): + # print(' * adding assert') + var assert_item = _ctrls.tree.create_item(parent_item) + assert_item.set_icon_max_width(0, _max_icon_width) + assert_item.set_text(0, text) + assert_item.set_metadata(0, {"type":"assert"}) + assert_item.set_icon(0, icon) + assert_item.set_custom_bg_color(1, _col_1_bg_color) + + return assert_item + + +func _add_test_tree_item(test_name, test_json, script_item): + # print(' * adding test ', test_name) + var no_orphans_to_show = !_show_orphans or (_show_orphans and test_json.orphans == 0) + if(_hide_passing and test_json['status'] == 'pass' and no_orphans_to_show): + return + + var item = _ctrls.tree.create_item(script_item) + var status = test_json['status'] + var meta = {"type":"test", "json":test_json} + + item.set_text(0, test_name) + item.set_text(1, status) + item.set_text_alignment(1, HORIZONTAL_ALIGNMENT_RIGHT) + item.set_custom_bg_color(1, _col_1_bg_color) + + item.set_metadata(0, meta) + item.set_icon_max_width(0, _max_icon_width) + + var orphan_text = 'orphans' + if(test_json.orphans == 1): + orphan_text = 'orphan' + orphan_text = str(test_json.orphans, ' ', orphan_text) + + if(status == 'pass' and no_orphans_to_show): + item.set_icon(0, _icons.green) + elif(status == 'pass' and !no_orphans_to_show): + item.set_icon(0, _icons.yellow) + item.set_text(1, orphan_text) + elif(status == 'fail'): + item.set_icon(0, _icons.red) + else: + item.set_icon(0, _icons.yellow) + + if(!_hide_passing): + for passing in test_json.passing: + _add_assert_item('pass: ' + passing, _icons.green, item) + + for failure in test_json.failing: + _add_assert_item("fail: " + failure.replace("\n", ''), _icons.red, item) + + for pending in test_json.pending: + _add_assert_item("pending: " + pending.replace("\n", ''), _icons.yellow, item) + + if(status != 'pass' and !no_orphans_to_show): + _add_assert_item(orphan_text, _icons.yellow, item) + + return item + + +func _add_script_to_tree(key, script_json): + var tests = script_json['tests'] + var test_keys = tests.keys() + var s_item = _add_script_tree_item(key, script_json) + var bad_count = 0 + + for test_key in test_keys: + var t_item = _add_test_tree_item(test_key, tests[test_key], s_item) + if(tests[test_key].status != 'pass'): + bad_count += 1 + elif(t_item != null): + t_item.collapsed = true + + if(s_item.get_children().size() == 0): + s_item.free() + else: + var total_text = str('All ', test_keys.size(), ' passed') + if(bad_count == 0): + s_item.collapsed = true + else: + total_text = str(test_keys.size() - bad_count, '/', test_keys.size(), ' passed') + s_item.set_text(1, total_text) + + +func _free_childless_scripts(): + var items = _root.get_children() + for item in items: + var next_item = item.get_next() + if(item.get_children().size() == 0): + item.free() + item = next_item + + +func _show_all_passed(): + if(_root.get_children() == null): + add_centered_text('Everything passed!') + + +func _load_result_tree(j): + var scripts = j['test_scripts']['scripts'] + var script_keys = scripts.keys() + # if we made it here, the json is valid and we did something, otherwise the + # 'nothing to see here' should be visible. + clear_centered_text() + + for key in script_keys: + if(scripts[key]['props']['tests'] > 0): + _add_script_to_tree(key, scripts[key]) + + _free_childless_scripts() + _show_all_passed() + + +# ------------------- +# Public +# ------------------- +func load_json_file(path): + var file = FileAccess.open(path, FileAccess.READ) + var text = '' + if(file != null): + text = file.get_as_text() + + if(text != ''): + var test_json_conv = JSON.new() + var result = test_json_conv.parse(text) + if(result != OK): + add_centered_text(str(path, " has invalid json in it \n", + 'Error ', result, "@", test_json_conv.get_error_line(), "\n", + test_json_conv.get_error_message())) + return + + var data = test_json_conv.get_data() + load_json_results(data) + else: + add_centered_text(str(path, ' was empty or does not exist.')) + + +func load_json_results(j): + clear() + _load_result_tree(j) + + +func clear(): + _ctrls.tree.clear() + _root = _ctrls.tree.create_item() + + +func set_summary_min_width(width): + _ctrls.tree.set_column_custom_minimum_width(1, width) + + +func add_centered_text(t): + _ctrls.lbl_overlay.visible = true + _ctrls.lbl_overlay.text = t + + +func clear_centered_text(): + _ctrls.lbl_overlay.visible = false + _ctrls.lbl_overlay.text = '' + + +func collapse_all(): + set_collapsed_on_all(_root, true) + + +func expand_all(): + set_collapsed_on_all(_root, false) + + +func set_collapsed_on_all(item, value): + item.set_collapsed_recursive(value) + if(item == _root and value): + item.set_collapsed(false) + + +func get_selected(): + return _ctrls.tree.get_selected() diff --git a/samples/client/petstore/gdscript/addons/gut/gui/ResultsTree.tscn b/samples/client/petstore/gdscript/addons/gut/gui/ResultsTree.tscn new file mode 100644 index 000000000000..ab6a1a5a9d90 --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/gui/ResultsTree.tscn @@ -0,0 +1,32 @@ +[gd_scene load_steps=2 format=3 uid="uid://dls5r5f6157nq"] + +[ext_resource type="Script" path="res://addons/gut/gui/ResultsTree.gd" id="1_b4uub"] + +[node name="ResultsTree" type="VBoxContainer"] +custom_minimum_size = Vector2(10, 10) +anchors_preset = 15 +anchor_right = 1.0 +anchor_bottom = 1.0 +offset_right = -70.0 +offset_bottom = -104.0 +grow_horizontal = 2 +grow_vertical = 2 +size_flags_horizontal = 3 +size_flags_vertical = 3 +script = ExtResource("1_b4uub") + +[node name="Tree" type="Tree" parent="."] +layout_mode = 2 +size_flags_horizontal = 3 +size_flags_vertical = 3 +columns = 2 +hide_root = true + +[node name="TextOverlay" type="Label" parent="Tree"] +visible = false +layout_mode = 1 +anchors_preset = 15 +anchor_right = 1.0 +anchor_bottom = 1.0 +grow_horizontal = 2 +grow_vertical = 2 diff --git a/samples/client/petstore/gdscript/addons/gut/gui/RunAtCursor.gd b/samples/client/petstore/gdscript/addons/gut/gui/RunAtCursor.gd new file mode 100644 index 000000000000..d0482548359a --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/gui/RunAtCursor.gd @@ -0,0 +1,158 @@ +@tool +extends Control + + +var ScriptTextEditors = load('res://addons/gut/gui/script_text_editor_controls.gd') + +@onready var _ctrls = { + btn_script = $HBox/BtnRunScript, + btn_inner = $HBox/BtnRunInnerClass, + btn_method = $HBox/BtnRunMethod, + lbl_none = $HBox/LblNoneSelected, + arrow_1 = $HBox/Arrow1, + arrow_2 = $HBox/Arrow2 +} + +var _editors = null +var _cur_editor = null +var _last_line = -1 +var _cur_script_path = null +var _last_info = { + script = null, + inner_class = null, + test_method = null +} + + +signal run_tests(what) + + +func _ready(): + _ctrls.lbl_none.visible = true + _ctrls.btn_script.visible = false + _ctrls.btn_inner.visible = false + _ctrls.btn_method.visible = false + _ctrls.arrow_1.visible = false + _ctrls.arrow_2.visible = false + +# ---------------- +# Private +# ---------------- +func _set_editor(which): + _last_line = -1 + if(_cur_editor != null and _cur_editor.get_ref()): + # _cur_editor.get_ref().disconnect('cursor_changed',Callable(self,'_on_cursor_changed')) + _cur_editor.get_ref().caret_changed.disconnect(_on_cursor_changed) + + if(which != null): + _cur_editor = weakref(which) + which.caret_changed.connect(_on_cursor_changed.bind(which)) + # which.connect('cursor_changed',Callable(self,'_on_cursor_changed'),[which]) + + _last_line = which.get_caret_line() + _last_info = _editors.get_line_info() + _update_buttons(_last_info) + + +func _update_buttons(info): + _ctrls.lbl_none.visible = _cur_script_path == null + _ctrls.btn_script.visible = _cur_script_path != null + + _ctrls.btn_inner.visible = info.inner_class != null + _ctrls.arrow_1.visible = info.inner_class != null + _ctrls.btn_inner.text = str(info.inner_class) + _ctrls.btn_inner.tooltip_text = str("Run all tests in Inner-Test-Class ", info.inner_class) + + _ctrls.btn_method.visible = info.test_method != null + _ctrls.arrow_2.visible = info.test_method != null + _ctrls.btn_method.text = str(info.test_method) + _ctrls.btn_method.tooltip_text = str("Run test ", info.test_method) + + # The button's new size won't take effect until the next frame. + # This appears to be what was causing the button to not be clickable the + # first time. + call_deferred("_update_size") + +func _update_size(): + custom_minimum_size.x = _ctrls.btn_method.size.x + _ctrls.btn_method.position.x + +# ---------------- +# Events +# ---------------- +func _on_cursor_changed(which): + if(which.get_caret_line() != _last_line): + _last_line = which.get_caret_line() + _last_info = _editors.get_line_info() + _update_buttons(_last_info) + + +func _on_BtnRunScript_pressed(): + var info = _last_info.duplicate() + info.script = _cur_script_path.get_file() + info.inner_class = null + info.test_method = null + emit_signal("run_tests", info) + + +func _on_BtnRunInnerClass_pressed(): + var info = _last_info.duplicate() + info.script = _cur_script_path.get_file() + info.test_method = null + emit_signal("run_tests", info) + + +func _on_BtnRunMethod_pressed(): + var info = _last_info.duplicate() + info.script = _cur_script_path.get_file() + emit_signal("run_tests", info) + + +# ---------------- +# Public +# ---------------- +func set_script_text_editors(value): + _editors = value + + +func activate_for_script(path): + _ctrls.btn_script.visible = true + _ctrls.btn_script.text = path.get_file() + _ctrls.btn_script.tooltip_text = str("Run all tests in script ", path) + _cur_script_path = path + _editors.refresh() + # We have to wait a beat for the visibility to change on + # the editors, otherwise we always get the first one. + await get_tree().process_frame + _set_editor(_editors.get_current_text_edit()) + + +func get_script_button(): + return _ctrls.btn_script + + +func get_inner_button(): + return _ctrls.btn_inner + + +func get_test_button(): + return _ctrls.btn_method + + +# not used, thought was configurable but it's just the script prefix +func set_method_prefix(value): + _editors.set_method_prefix(value) + + +# not used, thought was configurable but it's just the script prefix +func set_inner_class_prefix(value): + _editors.set_inner_class_prefix(value) + + +# Mashed this function in here b/c it has _editors. Probably should be +# somewhere else (possibly in script_text_editor_controls). +func search_current_editor_for_text(txt): + var te = _editors.get_current_text_edit() + var result = te.search(txt, 0, 0, 0) + var to_return = -1 + + return to_return diff --git a/samples/client/petstore/gdscript/addons/gut/gui/RunAtCursor.tscn b/samples/client/petstore/gdscript/addons/gut/gui/RunAtCursor.tscn new file mode 100644 index 000000000000..bba1dacb1eca --- /dev/null +++ b/samples/client/petstore/gdscript/addons/gut/gui/RunAtCursor.tscn @@ -0,0 +1,65 @@ +[gd_scene load_steps=4 format=3 uid="uid://0yunjxtaa8iw"] + +[ext_resource type="Script" path="res://addons/gut/gui/RunAtCursor.gd" id="1"] +[ext_resource type="Texture2D" uid="uid://cr6tvdv0ve6cv" path="res://addons/gut/gui/play.png" id="2"] +[ext_resource type="Texture2D" uid="uid://6wra5rxmfsrl" path="res://addons/gut/gui/arrow.png" id="3"] + +[node name="RunAtCursor" type="Control"] +layout_mode = 3 +anchors_preset = 15 +anchor_right = 1.0 +anchor_bottom = 1.0 +offset_right = 1.0 +offset_bottom = -527.0 +grow_horizontal = 2 +grow_vertical = 2 +size_flags_horizontal = 3 +size_flags_vertical = 3 +script = ExtResource("1") + +[node name="HBox" type="HBoxContainer" parent="."] +layout_mode = 0 +anchor_right = 1.0 +anchor_bottom = 1.0 +size_flags_horizontal = 3 +size_flags_vertical = 3 + +[node name="LblNoneSelected" type="Label" parent="HBox"] +layout_mode = 2 +text = "" + +[node name="BtnRunScript" type="Button" parent="HBox"] +visible = false +layout_mode = 2 +text = "