From e5d0963c5f8ba5dad5e2ef6c0f2ec7f90b6d715c Mon Sep 17 00:00:00 2001 From: Lily Rose Date: Wed, 23 Jul 2025 12:29:02 +1000 Subject: [PATCH] Initial commit --- .github/workflows/test.yml | 23 + .gitignore | 4 + README.md | 24 + gleam.toml | 21 + manifest.toml | 16 + src/kicad_sexpr.gleam | 95 + src/kicad_sexpr/decode.gleam | 263 ++ src/kicad_sexpr/parse.gleam | 217 ++ src/kicad_sexpr/token.gleam | 2947 ++++++++++++++++ test.kicad_mod | 152 + test/kicad_sexpr_test.gleam | 13 + test2.kicad_mod | 338 ++ test3.kicad_mod | 6400 ++++++++++++++++++++++++++++++++++ 13 files changed, 10513 insertions(+) create mode 100644 .github/workflows/test.yml create mode 100644 .gitignore create mode 100644 README.md create mode 100644 gleam.toml create mode 100644 manifest.toml create mode 100644 src/kicad_sexpr.gleam create mode 100644 src/kicad_sexpr/decode.gleam create mode 100644 src/kicad_sexpr/parse.gleam create mode 100644 src/kicad_sexpr/token.gleam create mode 100644 test.kicad_mod create mode 100644 test/kicad_sexpr_test.gleam create mode 100644 test2.kicad_mod create mode 100644 test3.kicad_mod diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml new file mode 100644 index 0000000..7c92c48 --- /dev/null +++ b/.github/workflows/test.yml @@ -0,0 +1,23 @@ +name: test + +on: + push: + branches: + - master + - main + pull_request: + +jobs: + test: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: erlef/setup-beam@v1 + with: + otp-version: "27.1.2" + gleam-version: "1.11.1" + rebar3-version: "3" + # elixir-version: "1" + - run: gleam deps download + - run: gleam test + - run: gleam format --check src test diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..599be4e --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +*.beam +*.ez +/build +erl_crash.dump diff --git a/README.md b/README.md new file mode 100644 index 0000000..025c569 --- /dev/null +++ b/README.md @@ -0,0 +1,24 @@ +# kicad_sexpr + +[![Package Version](https://img.shields.io/hexpm/v/kicad_sexpr)](https://hex.pm/packages/kicad_sexpr) +[![Hex Docs](https://img.shields.io/badge/hex-docs-ffaff3)](https://hexdocs.pm/kicad_sexpr/) + +```sh +gleam add kicad_sexpr@1 +``` +```gleam +import kicad_sexpr + +pub fn main() -> Nil { + // TODO: An example of the project in use +} +``` + +Further documentation can be found at . + +## Development + +```sh +gleam run # Run the project +gleam test # Run the tests +``` diff --git a/gleam.toml b/gleam.toml new file mode 100644 index 0000000..60af32b --- /dev/null +++ b/gleam.toml @@ -0,0 +1,21 @@ +name = "kicad_sexpr" +version = "1.0.0" + +# Fill out these fields if you intend to generate HTML documentation or publish +# your project to the Hex package manager. +# +# description = "" +# licences = ["Apache-2.0"] +# repository = { type = "github", user = "", repo = "" } +# links = [{ title = "Website", href = "" }] +# +# For a full reference of all the available options, you can have a look at +# https://gleam.run/writing-gleam/gleam-toml/. + +[dependencies] +gleam_stdlib = ">= 0.44.0 and < 2.0.0" +simplifile = ">= 2.3.0 and < 3.0.0" +splitter = ">= 1.0.0 and < 2.0.0" + +[dev-dependencies] +gleeunit = ">= 1.0.0 and < 2.0.0" diff --git a/manifest.toml b/manifest.toml new file mode 100644 index 0000000..a14c26a --- /dev/null +++ b/manifest.toml @@ -0,0 +1,16 @@ +# This file was generated by Gleam +# You typically do not need to edit this file + +packages = [ + { name = "filepath", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "B06A9AF0BF10E51401D64B98E4B627F1D2E48C154967DA7AF4D0914780A6D40A" }, + { name = "gleam_stdlib", version = "0.62.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "DC8872BC0B8550F6E22F0F698CFE7F1E4BDA7312FDEB40D6C3F44C5B706C8310" }, + { name = "gleeunit", version = "1.6.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "63022D81C12C17B7F1A60E029964E830A4CBD846BBC6740004FC1F1031AE0326" }, + { name = "simplifile", version = "2.3.0", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "0A868DAC6063D9E983477981839810DC2E553285AB4588B87E3E9C96A7FB4CB4" }, + { name = "splitter", version = "1.0.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "splitter", source = "hex", outer_checksum = "128FC521EE33B0012E3E64D5B55168586BC1B9C8D7B0D0CA223B68B0D770A547" }, +] + +[requirements] +gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" } +gleeunit = { version = ">= 1.0.0 and < 2.0.0" } +simplifile = { version = ">= 2.3.0 and < 3.0.0" } +splitter = { version = ">= 1.0.0 and < 2.0.0" } diff --git a/src/kicad_sexpr.gleam b/src/kicad_sexpr.gleam new file mode 100644 index 0000000..98a1120 --- /dev/null +++ b/src/kicad_sexpr.gleam @@ -0,0 +1,95 @@ +import gleam/float +import gleam/int +import gleam/io + +import gleam/list +import gleam/result +import gleam/string +import kicad_sexpr/decode +import kicad_sexpr/parse + +import kicad_sexpr/token +import simplifile + +fn print_stats(title: String, successes: Int, total: Int) { + io.println( + title + <> ": " + <> int.to_string(successes) + <> "/" + <> int.to_string(total) + <> " (" + <> int.to_float(100 * successes) /. int.to_float(total) + |> float.to_precision(2) + |> float.to_string + |> string.append("%") + <> ")", + ) +} + +pub fn main() -> Nil { + let assert Ok(file_names) = + simplifile.get_files("/usr/share/kicad/footprints") + + // let #(file_names, _) = file_names |> list.drop(0) |> list.split(1000) + // let file_names = list.sample(file_names, 1000) + // let file_names = ["/usr/share/kicad/symbols/RF_Module.kicad_sym"] + + let num_file_names = list.length(file_names) + io.println("Total: " <> int.to_string(num_file_names)) + + let #(successfully_read, _failed_to_read) = + file_names + |> list.map(fn(file_name) { + simplifile.read(file_name) + |> result.map(fn(res) { #(file_name, res) }) + |> result.map_error(fn(res) { #(file_name, res) }) + }) + |> result.partition + let num_successfully_read = list.length(successfully_read) + print_stats("Read", num_successfully_read, num_file_names) + + let #(successfully_parsed, _failed_to_parse) = + successfully_read + |> list.map(fn(data) { + let #(file_name, file_contents) = data + parse.run(file_contents) + |> result.map(fn(res) { #(file_name, file_contents, res) }) + |> result.map_error(fn(res) { #(file_name, file_contents, res) }) + }) + |> result.partition + let num_successfully_parsed = list.length(successfully_parsed) + print_stats("Parsed", num_successfully_parsed, num_successfully_read) + + let #(successfully_decoded, failed_to_decode) = + successfully_parsed + |> list.map(fn(data) { + let #(file_name, file_contents, sexpr) = data + decode.run(token.footprint_file, sexpr) + |> result.map(fn(res) { #(file_name, file_contents, sexpr, res) }) + |> result.map_error(fn(res) { #(file_name, file_contents, sexpr, res) }) + }) + |> result.partition + let num_successfully_decoded = list.length(successfully_decoded) + print_stats("Decoded", num_successfully_decoded, num_successfully_parsed) + list.each(failed_to_decode, fn(data) { + let #(file_name, _file_contents, _sexpr, error) = data + io.println(file_name) + echo error + // panic + }) + + // let assert Ok(footprint_str) = + // simplifile.read( + // "/usr/share/kicad/footprints/Relay_SMD.pretty/Relay_DPDT_AXICOM_IMSeries_JLeg.kicad_mod", + // ) + // // let assert Ok(footprint_str) = simplifile.read("test2.kicad_mod") + // let assert Ok(t) = + // parse.run( + // " (wobble \"hi there \\\" \\\\ this is a test\" (wibble foo bar) bar) ", + // ) + // io.println(parse.sexpr_to_pretty_string(t)) + // let assert Ok(t) = decode.run(wobble, t) + // echo t + Nil +} diff --git a/src/kicad_sexpr/decode.gleam b/src/kicad_sexpr/decode.gleam new file mode 100644 index 0000000..048019e --- /dev/null +++ b/src/kicad_sexpr/decode.gleam @@ -0,0 +1,263 @@ +import gleam/bool +import gleam/float +import gleam/int +import gleam/list +import gleam/option.{type Option, None, Some} +import gleam/pair +import gleam/result +import kicad_sexpr/parse.{type SExpr} + +pub type ExprType { + Token(name: String) + String + Int + Float + Name + Unknown +} + +pub type DecodeError { + UnexpectedEndOfAttributes(expected: ExprType) + UnexpectedTrailingAttributes(got: List(SExpr)) + IncorrectExprType(got: SExpr, expected: ExprType) + IncorrectTokenName(got: String, expected: String) + IncorrectName(got: String, expected: String) + UnmatchedEnum(got: String, expected: List(String)) + UnmatchedIntEnum(got: Int, expected: List(Int)) + UnmatchedOneOf(got: SExpr) + TokenAttributeError(name: String, error: DecodeError) +} + +pub type Decoded(a) = + Result(#(a, List(SExpr)), DecodeError) + +pub type Decoder(a) = + fn(List(SExpr)) -> Decoded(a) + +pub type NextFn(a, b) = + fn(a) -> Decoder(b) + +pub fn token( + named name: String, + with decoder: Decoder(a), + then next: NextFn(a, b), +) -> Decoder(b) { + fn(sexprs: List(SExpr)) { + case sexprs { + [] -> Error(UnexpectedEndOfAttributes(Token(name))) + [parse.Token(name: name_, attributes:), ..sexprs] if name_ == name -> { + use #(value, rest) <- result.try( + decoder(attributes) + |> result.map_error(TokenAttributeError(name:, error: _)), + ) + use <- bool.guard( + rest != [], + Error(TokenAttributeError( + name:, + error: UnexpectedTrailingAttributes(rest), + )), + ) + next(value)(sexprs) + } + [parse.Token(name: name_, ..), ..] -> + Error(IncorrectTokenName(got: name_, expected: name)) + [sexpr, ..] -> Error(IncorrectExprType(got: sexpr, expected: Token(name))) + } + } +} + +pub fn token_wrapper( + named name: String, + with attr: fn(NextFn(a, a)) -> Decoder(b), + then next: NextFn(b, c), +) -> Decoder(c) { + token(named: name, then: next, with: attr(success)) +} + +pub fn string(then next: NextFn(String, a)) -> Decoder(a) { + fn(sexprs: List(SExpr)) { + case sexprs { + [] -> Error(UnexpectedEndOfAttributes(String)) + [parse.String(value), ..sexprs] -> next(value)(sexprs) + [sexpr, ..] -> Error(IncorrectExprType(got: sexpr, expected: String)) + } + } +} + +pub fn float(then next: NextFn(Float, a)) -> Decoder(a) { + fn(sexprs: List(SExpr)) { + case sexprs { + [] -> Error(UnexpectedEndOfAttributes(Float)) + [parse.Int(value), ..sexprs] -> next(int.to_float(value))(sexprs) + [parse.Float(value), ..sexprs] -> next(value)(sexprs) + [sexpr, ..] -> Error(IncorrectExprType(got: sexpr, expected: Float)) + } + } +} + +pub fn int(then next: NextFn(Int, a)) -> Decoder(a) { + fn(sexprs: List(SExpr)) { + case sexprs { + [] -> Error(UnexpectedEndOfAttributes(Int)) + [parse.Float(value), ..sexprs] -> next(float.round(value))(sexprs) + [parse.Int(value), ..sexprs] -> next(value)(sexprs) + [sexpr, ..] -> Error(IncorrectExprType(got: sexpr, expected: Int)) + } + } +} + +pub fn enum( + with variants: List(#(String, a)), + then next: NextFn(a, b), +) -> Decoder(b) { + fn(sexprs: List(SExpr)) { + case sexprs { + [] -> Error(UnexpectedEndOfAttributes(Name)) + [parse.Name(value), ..sexprs] -> + case list.key_find(variants, value) { + Ok(value) -> next(value)(sexprs) + Error(Nil) -> + Error(UnmatchedEnum( + got: value, + expected: list.map(variants, pair.first), + )) + } + [sexpr, ..] -> Error(IncorrectExprType(got: sexpr, expected: Name)) + } + } +} + +pub fn int_enum(with variants: List(a), then next: NextFn(a, b)) -> Decoder(b) { + fn(sexprs: List(SExpr)) { + case sexprs { + [] -> Error(UnexpectedEndOfAttributes(Int)) + [parse.Int(value), ..sexprs] -> { + let variants = list.index_map(variants, fn(x, i) { #(i, x) }) + case list.key_find(variants, value) { + Ok(value) -> next(value)(sexprs) + Error(Nil) -> + Error(UnmatchedIntEnum( + got: value, + expected: list.map(variants, pair.first), + )) + } + } + [sexpr, ..] -> Error(IncorrectExprType(got: sexpr, expected: Name)) + } + } +} + +pub fn flag(named name: String, then next: NextFn(Bool, a)) -> Decoder(a) { + fn(sexprs: List(SExpr)) { + case sexprs { + [parse.Name(value), ..sexprs] if value == name -> next(True)(sexprs) + _ -> next(False)(sexprs) + } + } +} + +pub fn optional( + attr: fn(NextFn(a, a)) -> Decoder(b), + then next: NextFn(Option(b), c), +) -> Decoder(c) { + fn(source: List(SExpr)) { + case attr(success)(source) { + Ok(#(value, rest)) -> next(Some(value))(rest) + Error(TokenAttributeError(..) as err) -> Error(err) + Error(_) -> next(None)(source) + } + } +} + +pub fn list( + attr: fn(NextFn(a, a)) -> Decoder(b), + then next: NextFn(List(b), c), +) -> Decoder(c) { + fn(source: List(SExpr)) { + use #(value, rest) <- result.try(do_list(source, attr(success), [])) + next(value)(rest) + } +} + +fn do_list( + source: List(SExpr), + decoder: Decoder(a), + results: List(a), +) -> Decoded(List(a)) { + case decoder(source) { + Ok(#(value, rest)) -> do_list(rest, decoder, [value, ..results]) + Error(TokenAttributeError(..) as err) -> Error(err) + Error(_) -> Ok(#(results, source)) + } +} + +pub fn of(with decoder: Decoder(a), then next: NextFn(a, b)) -> Decoder(b) { + fn(source: List(SExpr)) { + use #(token, rest) <- result.try(decoder(source)) + next(token)(rest) + } +} + +pub fn one_of( + attr: fn(NextFn(a, a)) -> Decoder(b), + or attrs: List(fn(NextFn(a, a)) -> Decoder(b)), + then next: NextFn(b, c), +) -> Decoder(c) { + fn(source: List(SExpr)) { + case attr(success)(source) { + Ok(#(value, rest)) -> next(value)(rest) + Error(TokenAttributeError(..) as err) -> Error(err) + Error(_) -> { + use #(value, rest) <- result.try(do_one_of( + source, + list.map(attrs, fn(attr) { attr(success) }), + )) + next(value)(rest) + } + } + } +} + +fn do_one_of(source: List(SExpr), decoders: List(Decoder(a))) -> Decoded(a) { + case decoders { + [] -> + Error( + list.first(source) + |> result.map(UnmatchedOneOf) + |> result.unwrap(UnexpectedEndOfAttributes(Unknown)), + ) + [decoder, ..decoders] -> + case decoder(source) { + Ok(#(value, rest)) -> Ok(#(value, rest)) + Error(TokenAttributeError(..) as err) -> Error(err) + Error(_) -> do_one_of(source, decoders) + } + } +} + +pub fn map( + with attr: fn(NextFn(a, b)) -> Decoder(c), + to map_fn: fn(a) -> b, +) -> fn(NextFn(c, d)) -> Decoder(d) { + of(then: _, with: { + use value <- attr() + success(map_fn(value)) + }) +} + +pub fn success(value: a) -> Decoder(a) { + fn(source: List(SExpr)) { Ok(#(value, source)) } +} + +pub fn failure(error: DecodeError) -> Decoder(a) { + fn(_: List(SExpr)) { Error(error) } +} + +pub fn run( + structurer: fn(NextFn(a, a)) -> Decoder(b), + on source: SExpr, +) -> Result(b, DecodeError) { + use #(value, rest) <- result.try(structurer(success)([source])) + use <- bool.guard(rest != [], Error(UnexpectedTrailingAttributes(rest))) + Ok(value) +} diff --git a/src/kicad_sexpr/parse.gleam b/src/kicad_sexpr/parse.gleam new file mode 100644 index 0000000..3f475bf --- /dev/null +++ b/src/kicad_sexpr/parse.gleam @@ -0,0 +1,217 @@ +import gleam/bool +import gleam/float +import gleam/int +import gleam/list +import gleam/option.{type Option, None, Some} +import gleam/result +import gleam/string + +pub type ParseError { + UnexpectedEndOfFile + UnexpectedTokenCharacter(got: String, expected: String) + UnexpectedNameCharacter(got: String) + UnexpectedNumberCharacter(got: String) + UnexpectedTrailingString(got: String) + UnterminatedString(got: String) + InvalidNumber(got: String) +} + +pub type SExpr { + Token(name: String, attributes: List(SExpr)) + String(String) + Int(Int) + Float(Float) + Name(String) +} + +pub type Parsed(a) = + Result(#(a, String), ParseError) + +pub fn sexpr_to_pretty_string(sexpr: SExpr) -> String { + do_sexpr_to_pretty_string(sexpr, "") +} + +fn do_sexpr_to_pretty_string(sexpr: SExpr, pad: String) -> String { + pad + <> case sexpr { + Token(name:, attributes:) -> + name + <> " :: Token\n" + <> attributes + |> list.map(do_sexpr_to_pretty_string(_, pad <> " ")) + |> string.join("\n") + String(value) -> "\"" <> value <> "\" :: String" + Int(value) -> int.to_string(value) <> " :: Int" + Float(value) -> float.to_string(value) <> " :: Float" + Name(value) -> value <> " :: Name" + } +} + +pub fn run(source: String) -> Result(SExpr, ParseError) { + let source = string.trim(source) + use #(token, rest) <- result.try(attribute(source)) + case string.trim(rest) { + "" -> Ok(token) + rest -> Error(UnexpectedTrailingString(rest)) + } +} + +pub fn token(source: String) -> Parsed(SExpr) { + use #(name, rest) <- result.try(name(source)) + use #(attributes, rest) <- result.try(attributes(rest)) + Ok(#(Token(name:, attributes:), rest)) +} + +fn name_char(source: String) -> Parsed(String) { + case source { + "" -> Error(UnexpectedEndOfFile) + "a" <> rest -> Ok(#("a", rest)) + "b" <> rest -> Ok(#("b", rest)) + "c" <> rest -> Ok(#("c", rest)) + "d" <> rest -> Ok(#("d", rest)) + "e" <> rest -> Ok(#("e", rest)) + "f" <> rest -> Ok(#("f", rest)) + "g" <> rest -> Ok(#("g", rest)) + "h" <> rest -> Ok(#("h", rest)) + "i" <> rest -> Ok(#("i", rest)) + "j" <> rest -> Ok(#("j", rest)) + "k" <> rest -> Ok(#("k", rest)) + "l" <> rest -> Ok(#("l", rest)) + "m" <> rest -> Ok(#("m", rest)) + "n" <> rest -> Ok(#("n", rest)) + "o" <> rest -> Ok(#("o", rest)) + "p" <> rest -> Ok(#("p", rest)) + "q" <> rest -> Ok(#("q", rest)) + "r" <> rest -> Ok(#("r", rest)) + "s" <> rest -> Ok(#("s", rest)) + "t" <> rest -> Ok(#("t", rest)) + "u" <> rest -> Ok(#("u", rest)) + "v" <> rest -> Ok(#("v", rest)) + "w" <> rest -> Ok(#("w", rest)) + "x" <> rest -> Ok(#("x", rest)) + "y" <> rest -> Ok(#("y", rest)) + "z" <> rest -> Ok(#("z", rest)) + "_" <> rest -> Ok(#("_", rest)) + _ -> + Error(UnexpectedNameCharacter(string.first(source) |> result.unwrap(""))) + } +} + +pub fn name(source: String) -> Parsed(String) { + use #(char, rest) <- result.try(name_char(source)) + do_name(rest, char) +} + +fn do_name(source: String, result: String) -> Parsed(String) { + case name_char(source) { + Ok(#(char, rest)) -> do_name(rest, result <> char) + Error(_) -> Ok(#(result, source)) + } +} + +pub fn attributes(source: String) -> Parsed(List(SExpr)) { + do_attributes(source, []) +} + +fn do_attributes(source: String, attributes: List(SExpr)) -> Parsed(List(SExpr)) { + case string.trim_start(source) { + "" -> Error(UnexpectedEndOfFile) + ")" <> rest -> Ok(#(list.reverse(attributes), rest)) + source -> { + use #(attribute, rest) <- result.try(attribute(source)) + do_attributes(rest, [attribute, ..attributes]) + } + } +} + +pub fn attribute(source: String) -> Parsed(SExpr) { + case source { + "" -> Error(UnexpectedEndOfFile) + "(" <> rest -> { + use #(token, rest) <- result.try(token(rest)) + Ok(#(token, rest)) + } + "\"" <> rest -> { + use #(str, rest) <- result.try(string(rest)) + Ok(#(String(str), rest)) + } + source -> { + use <- option.lazy_unwrap(try_number(source)) + use #(name, rest) <- result.try(name(source)) + Ok(#(Name(name), rest)) + } + } +} + +pub fn string(source: String) -> Parsed(String) { + use <- bool.guard(source == "", Error(UnexpectedEndOfFile)) + do_string(source, "") +} + +fn do_string(source: String, result: String) -> Parsed(String) { + case string.split_once(source, "\"") { + Ok(#(start, rest)) -> + case string.last(start) { + Ok("\\") -> do_string(rest, result <> "\"" <> start) + _ -> + Ok(#( + result <> start, + // |> string.replace("\\n", "\n") + // |> string.replace("\\r", "\r") + // |> string.replace("\\t", "\t") + // |> string.replace("\\f", "\f") + rest, + )) + } + Error(Nil) -> Error(UnterminatedString(source)) + } +} + +fn number_char(source: String) -> Parsed(String) { + case source { + "" -> Error(UnexpectedEndOfFile) + "." <> rest -> Ok(#(".", rest)) + "-" <> rest -> Ok(#("-", rest)) + "0" <> rest -> Ok(#("0", rest)) + "1" <> rest -> Ok(#("1", rest)) + "2" <> rest -> Ok(#("2", rest)) + "3" <> rest -> Ok(#("3", rest)) + "4" <> rest -> Ok(#("4", rest)) + "5" <> rest -> Ok(#("5", rest)) + "6" <> rest -> Ok(#("6", rest)) + "7" <> rest -> Ok(#("7", rest)) + "8" <> rest -> Ok(#("8", rest)) + "9" <> rest -> Ok(#("9", rest)) + _ -> + Error(UnexpectedNumberCharacter(string.first(source) |> result.unwrap(""))) + } +} + +pub fn try_number(source: String) -> Option(Parsed(SExpr)) { + case number_char(source) { + Ok(#(char, rest)) -> Some(do_number(rest, char)) + Error(_) -> None + } +} + +fn do_number(source: String, result: String) -> Parsed(SExpr) { + case number_char(source) { + Ok(#(char, rest)) -> do_number(rest, result <> char) + Error(_) -> { + case int.parse(result) { + Ok(n) -> Ok(#(Int(n), source)) + Error(Nil) -> { + let result = case result { + "-." <> rest -> "-0." <> rest + "." <> rest -> "0." <> rest + result -> result + } + case float.parse(result) { + Ok(n) -> Ok(#(Float(n), source)) + Error(Nil) -> Error(InvalidNumber(result)) + } + } + } + } + } +} diff --git a/src/kicad_sexpr/token.gleam b/src/kicad_sexpr/token.gleam new file mode 100644 index 0000000..9e713c8 --- /dev/null +++ b/src/kicad_sexpr/token.gleam @@ -0,0 +1,2947 @@ +import gleam/list +import gleam/option.{type Option} +import gleam/pair +import kicad_sexpr/decode.{type Decoder, type NextFn} + +fn width(then next: NextFn(Float, a)) -> Decoder(a) { + decode.token_wrapper(named: "width", with: decode.float, then: next) +} + +fn thickness(then next: NextFn(Float, a)) -> Decoder(a) { + decode.token_wrapper(named: "thickness", with: decode.float, then: next) +} + +fn yes_no(then next: NextFn(Bool, a)) -> Decoder(a) { + decode.enum(with: [#("yes", True), #("no", False)], then: next) +} + +fn allowed(then next: NextFn(Bool, a)) -> Decoder(a) { + decode.enum(with: [#("allowed", True), #("not_allowed", False)], then: next) +} + +fn optional_fill(then next: NextFn(Option(Bool), a)) -> Decoder(a) { + decode.optional( + decode.token_wrapper(named: "fill", with: yes_no, then: _), + then: next, + ) +} + +fn optional_angle(then next: NextFn(Option(Float), a)) -> Decoder(a) { + decode.optional( + decode.token_wrapper(named: "angle", with: decode.float, then: _), + then: next, + ) +} + +fn optional_corners( + then next: NextFn(Option(#(XY, XY, XY, XY)), a), +) -> Decoder(a) { + decode.optional( + decode.token(named: "pts", then: _, with: { + use xy1 <- xy() + use xy2 <- xy() + use xy3 <- xy() + use xy4 <- xy() + decode.success(#(xy1, xy2, xy3, xy4)) + }), + then: next, + ) +} + +fn optional_hide(then next: NextFn(Option(Bool), a)) -> Decoder(a) { + decode.optional( + decode.token_wrapper(named: "hide", with: yes_no, then: _), + then: next, + ) +} + +fn custom_xy(named name: String, then next: NextFn(XY, a)) -> Decoder(a) { + decode.token(named: name, then: next, with: { + use x <- decode.float() + use y <- decode.float() + decode.success(XY(x:, y:)) + }) +} + +fn layers(then next: NextFn(List(Layer), a)) -> Decoder(a) { + decode.token(named: "layers", then: next, with: { + use layers <- decode.list(decode.string) + let layers = list.map(layers, Layer) + decode.success(layers) + }) +} + +pub type PositionIdentifier { + PositionIdentifier(x: Float, y: Float, angle: Option(Float)) +} + +pub fn position_identifier( + then next: NextFn(PositionIdentifier, a), +) -> Decoder(a) { + decode.token(named: "at", then: next, with: { + use x <- decode.float() + use y <- decode.float() + use angle <- decode.optional(decode.float) + decode.success(PositionIdentifier(x:, y:, angle:)) + }) +} + +pub type XY { + XY(x: Float, y: Float) +} + +pub fn xy(then next: NextFn(XY, a)) -> Decoder(a) { + decode.token(named: "xy", then: next, with: { + use x <- decode.float() + use y <- decode.float() + decode.success(XY(x:, y:)) + }) +} + +pub type XYZ { + XYZ(x: Float, y: Float, z: Float) +} + +pub fn xyz(then next: NextFn(XYZ, a)) -> Decoder(a) { + decode.token(named: "xyz", then: next, with: { + use x <- decode.float() + use y <- decode.float() + use z <- decode.float() + decode.success(XYZ(x:, y:, z:)) + }) +} + +pub type Line { + Line(points: Points) +} + +pub fn line(then next: NextFn(Line, a)) -> Decoder(a) { + decode.token(named: "polyline", then: next, with: { + use points <- points() + decode.success(Line(points:)) + }) +} + +pub type Rectangle { + Rectangle(start: XY, end: XY) +} + +pub fn rectangle(then next: NextFn(Rectangle, a)) -> Decoder(a) { + decode.token(named: "rectangle", then: next, with: { + use start <- custom_xy("start") + use end <- custom_xy("end") + decode.success(Rectangle(start:, end:)) + }) +} + +pub type Circle { + Circle(center: XY, radius: Float) +} + +pub fn circle(then next: NextFn(Circle, a)) -> Decoder(a) { + decode.token(named: "circle", then: next, with: { + use center <- custom_xy("center") + use radius <- decode.token_wrapper(named: "radius", with: decode.float) + decode.success(Circle(center:, radius:)) + }) +} + +pub type Arc { + Arc(start: XY, mid: XY, end: XY) +} + +pub fn arc(then next: NextFn(Arc, a)) -> Decoder(a) { + decode.token(named: "arc", then: next, with: { + use start <- custom_xy("start") + use mid <- custom_xy("mid") + use end <- custom_xy("end") + decode.success(Arc(start:, mid:, end:)) + }) +} + +pub type Curve { + Curve(points: Points) +} + +pub fn curve(then next: NextFn(Curve, a)) -> Decoder(a) { + decode.token(named: "bezier", then: next, with: { + use points <- points() + decode.success(Curve(points:)) + }) +} + +pub type PolyPoint { + XYPolyPoint(XY) + ArcPolyPoint(Arc) +} + +pub fn poly_point(then next: NextFn(PolyPoint, a)) -> Decoder(a) { + decode.one_of( + xy |> decode.map(XYPolyPoint), + or: [arc |> decode.map(ArcPolyPoint)], + then: next, + ) +} + +pub type PolyPoints { + PolyPoints(points: List(PolyPoint)) +} + +pub fn poly_points(then next: NextFn(PolyPoints, a)) -> Decoder(a) { + decode.token(named: "pts", then: next, with: { + use points <- decode.list(poly_point) + decode.success(PolyPoints(points:)) + }) +} + +pub type Points { + Points(points: List(XY)) +} + +pub fn points(then next: NextFn(Points, a)) -> Decoder(a) { + decode.token(named: "pts", then: next, with: { + use points <- decode.list(xy) + decode.success(Points(points:)) + }) +} + +pub type StrokeType { + DashStrokeType + DashDotStrokeType + DashDotDotStrokeType + DotStrokeType + DefaultStrokeType + SolidStrokeType +} + +pub fn stroke_type(then next: NextFn(StrokeType, a)) -> Decoder(a) { + decode.token(named: "type", then: next, with: { + use stroke_type <- decode.enum([ + #("dash", DashStrokeType), + #("dash_dot", DashDotStrokeType), + #("dash_dot_dot", DashDotDotStrokeType), + #("dot", DotStrokeType), + #("default", DefaultStrokeType), + #("solid", SolidStrokeType), + ]) + decode.success(stroke_type) + }) +} + +pub type Color { + Color(r: Float, g: Float, b: Float, a: Float) +} + +pub fn color(then next: NextFn(Color, a)) -> Decoder(a) { + decode.token(named: "color", then: next, with: { + use r <- decode.float() + use g <- decode.float() + use b <- decode.float() + use a <- decode.float() + decode.success(Color(r:, g:, b:, a:)) + }) +} + +pub type Stroke { + Stroke(width: Float, type_: StrokeType, color: Option(Color)) +} + +pub fn stroke(then next: NextFn(Stroke, a)) -> Decoder(a) { + decode.token(named: "stroke", then: next, with: { + use width <- width() + use type_ <- stroke_type() + use color <- decode.optional(color) + decode.success(Stroke(width:, type_:, color:)) + }) +} + +pub type FillType { + NoFill + OutlineFillType + BackgroundFillType +} + +pub fn fill_type(then next: NextFn(FillType, a)) -> Decoder(a) { + decode.token(named: "type", then: next, with: { + use value <- decode.enum([ + #("none", NoFill), + #("outline", OutlineFillType), + #("background", BackgroundFillType), + ]) + decode.success(value) + }) +} + +pub type Fill { + Fill(type_: FillType) +} + +pub fn fill(then next: NextFn(Fill, a)) -> Decoder(a) { + decode.token(named: "fill", then: next, with: { + use type_ <- fill_type() + decode.success(Fill(type_:)) + }) +} + +pub type Size { + Size(height: Float, width: Float) +} + +pub fn size(then next: NextFn(Size, a)) -> Decoder(a) { + decode.token(named: "size", then: next, with: { + use height <- decode.float() + use width <- decode.float() + decode.success(Size(height:, width:)) + }) +} + +pub type Font { + Font( + face: Option(String), + size: Size, + thickness: Option(Float), + bold: Option(Bool), + italic: Option(Bool), + line_spacing: Option(Float), + ) +} + +pub fn font(then next: NextFn(Font, a)) -> Decoder(a) { + decode.token(named: "font", then: next, with: { + use face <- decode.optional(decode.token_wrapper( + named: "face", + with: decode.string, + then: _, + )) + use size <- size() + use thickness <- decode.optional(thickness) + use bold <- decode.optional(decode.token_wrapper( + named: "bold", + with: yes_no, + then: _, + )) + use italic <- decode.optional(decode.token_wrapper( + named: "italic", + with: yes_no, + then: _, + )) + use line_spacing <- decode.optional(decode.token_wrapper( + named: "line_spacing", + with: decode.float, + then: _, + )) + decode.success(Font(face:, size:, thickness:, bold:, italic:, line_spacing:)) + }) +} + +pub type Horizontal { + Left + Right +} + +pub fn horizontal(then next: NextFn(Horizontal, a)) -> Decoder(a) { + decode.enum(then: next, with: [#("left", Left), #("right", Right)]) +} + +pub type Vertical { + Top + Bottom +} + +pub fn vertical(then next: NextFn(Vertical, a)) -> Decoder(a) { + decode.enum(then: next, with: [#("top", Top), #("bottom", Bottom)]) +} + +pub type Justify { + Justify( + horizontal: Option(Horizontal), + vertical: Option(Vertical), + mirror: Bool, + ) +} + +pub fn justify(then next: NextFn(Justify, a)) -> Decoder(a) { + decode.token(named: "justify", then: next, with: { + use horizontal <- decode.optional(horizontal) + use vertical <- decode.optional(vertical) + use mirror <- decode.flag("mirror") + decode.success(Justify(horizontal:, vertical:, mirror:)) + }) +} + +pub type Effects { + Effects(font: Font, justify: Option(Justify), hide: Option(Bool)) +} + +pub fn effects(then next: NextFn(Effects, a)) -> Decoder(a) { + decode.token(named: "effects", then: next, with: { + use font <- font() + use justify <- decode.optional(justify) + use hide <- optional_hide() + decode.success(Effects(font:, justify:, hide:)) + }) +} + +pub type PaperSize { + A0PaperSize + A1PaperSize + A2PaperSize + A3PaperSize + A4PaperSize + A5PaperSize + APaperSize + BPaperSize + CPaperSize + DPaperSize + EPaperSize + CustomPaperSize(width: Float, height: Float) +} + +pub fn paper_size(then next: NextFn(PaperSize, a)) -> Decoder(a) { + decode.one_of( + decode.enum(then: _, with: [ + #("A0", A0PaperSize), + #("A1", A1PaperSize), + #("A2", A2PaperSize), + #("A3", A3PaperSize), + #("A4", A4PaperSize), + #("A5", A5PaperSize), + #("A", APaperSize), + #("B", BPaperSize), + #("C", CPaperSize), + #("D", DPaperSize), + #("E", EPaperSize), + ]), + or: [ + decode.of(then: _, with: { + use width <- decode.float() + use height <- decode.float() + decode.success(CustomPaperSize(width:, height:)) + }), + ], + then: next, + ) +} + +pub type Paper { + Paper(size: PaperSize, portrait: Bool) +} + +pub fn paper(then next: NextFn(Paper, a)) -> Decoder(a) { + decode.token(named: "paper", then: next, with: { + use size <- paper_size() + use portrait <- decode.flag("portrait") + decode.success(Paper(size:, portrait:)) + }) +} + +pub type Comment { + Comment(number: Int, comment: String) +} + +pub fn comment(then next: NextFn(Comment, a)) -> Decoder(a) { + decode.token(named: "comment", then: next, with: { + use number <- decode.int() + use comment <- decode.string() + decode.success(Comment(number:, comment:)) + }) +} + +pub type TitleBlock { + TitleBlock( + title: String, + date: String, + revision: String, + company: String, + comment: Comment, + ) +} + +pub fn title_block(then next: NextFn(TitleBlock, a)) -> Decoder(a) { + decode.token(named: "title_block", then: next, with: { + use title <- decode.token_wrapper(named: "title", with: decode.string) + use date <- decode.token_wrapper(named: "date", with: decode.string) + use revision <- decode.token_wrapper(named: "rev", with: decode.string) + use company <- decode.token_wrapper(named: "company", with: decode.string) + use comment <- comment() + decode.success(TitleBlock(title:, date:, revision:, company:, comment:)) + }) +} + +pub type Property { + Property(key: String, value: String) +} + +pub fn property(then next: NextFn(Property, a)) -> Decoder(a) { + decode.token(named: "property", then: next, with: { + use key <- decode.string() + use value <- decode.string() + decode.success(Property(key:, value:)) + }) +} + +pub type Uuid { + Uuid(uuid: String) +} + +pub fn uuid(then next: NextFn(Uuid, a)) -> Decoder(a) { + decode.token(named: "uuid", then: next, with: { + use uuid <- decode.string() + decode.success(Uuid(uuid:)) + }) +} + +pub type Layer { + Layer(layer: String) +} + +pub fn layer(then next: NextFn(Layer, a)) -> Decoder(a) { + decode.token(named: "layer", then: next, with: { + use layer <- decode.string() + decode.success(Layer(layer:)) + }) +} + +pub type Image { + Image( + position: PositionIdentifier, + scale: Option(Float), + layer: Option(Layer), + uuid: Option(Uuid), + data: String, + ) +} + +pub fn image(then next: NextFn(Image, a)) -> Decoder(a) { + decode.token(named: "image", then: next, with: { + use position <- position_identifier() + use scale <- decode.optional(decode.token_wrapper( + named: "scale", + with: decode.float, + then: _, + )) + use layer <- decode.optional(layer) + use uuid <- decode.optional(uuid) + use data <- decode.string() + decode.success(Image(position:, scale:, layer:, uuid:, data:)) + }) +} + +pub type ConnectionType { + NoConnection + ThermalConnectionType + SolidFillConnectionType +} + +pub fn connection_type(then next: NextFn(ConnectionType, a)) -> Decoder(a) { + decode.int_enum(then: next, with: [ + NoConnection, + ThermalConnectionType, + SolidFillConnectionType, + ]) +} + +pub type FootprintProperty { + FootprintProperty( + key: String, + value: String, + position: PositionIdentifier, + unlocked: Option(Bool), + layer: Layer, + hide: Option(Bool), + uuid: Option(Uuid), + effects: Effects, + ) +} + +pub fn footprint_property(then next: NextFn(FootprintProperty, a)) -> Decoder(a) { + decode.token(named: "property", then: next, with: { + use key <- decode.string() + use value <- decode.string() + use position <- position_identifier() + use unlocked <- decode.optional(decode.token_wrapper( + named: "unlocked", + with: yes_no, + then: _, + )) + use layer <- layer() + use hide <- optional_hide() + use uuid <- decode.optional(uuid) + use effects <- effects() + decode.success(FootprintProperty( + key:, + value:, + position:, + unlocked:, + layer:, + hide:, + uuid:, + effects:, + )) + }) +} + +pub type FootprintAttributeType { + SmdAttributeType + ThroughHoleAttributeType +} + +pub fn footprint_attribute_type( + then next: NextFn(FootprintAttributeType, a), +) -> Decoder(a) { + decode.enum(then: next, with: [ + #("smd", SmdAttributeType), + #("through_hole", ThroughHoleAttributeType), + ]) +} + +pub type FootprintAttributes { + FootprintAttributes( + type_: Option(FootprintAttributeType), + board_only: Bool, + exclude_from_pos_files: Bool, + exclude_from_bom: Bool, + allow_soldermask_bridges: Bool, + allow_missing_courtyard: Bool, + ) +} + +pub fn footprint_attributes( + then next: NextFn(FootprintAttributes, a), +) -> Decoder(a) { + decode.token(named: "attr", then: next, with: { + use type_ <- decode.optional(footprint_attribute_type) + use board_only <- decode.flag("board_only") + use exclude_from_pos_files <- decode.flag("exclude_from_pos_files") + use exclude_from_bom <- decode.flag("exclude_from_bom") + use allow_soldermask_bridges <- decode.flag("allow_soldermask_bridges") + use allow_missing_courtyard <- decode.flag("allow_missing_courtyard") + decode.success(FootprintAttributes( + type_:, + board_only:, + exclude_from_pos_files:, + exclude_from_bom:, + allow_soldermask_bridges:, + allow_missing_courtyard:, + )) + }) +} + +pub type FootprintTextType { + ReferenceTextType + ValueTextType + UserTextType +} + +pub fn footprint_text_type( + then next: NextFn(FootprintTextType, a), +) -> Decoder(a) { + decode.enum(then: next, with: [ + #("reference", ReferenceTextType), + #("value", ValueTextType), + #("user", UserTextType), + ]) +} + +pub type FootprintText { + FootprintText( + type_: FootprintTextType, + text: String, + position: PositionIdentifier, + unlocked: Option(Bool), + layer: Layer, + hide: Option(Bool), + uuid: Option(Uuid), + effects: Effects, + ) +} + +pub fn footprint_text(then next: NextFn(FootprintText, a)) -> Decoder(a) { + decode.token(named: "fp_text", then: next, with: { + use type_ <- footprint_text_type() + use text <- decode.string() + use position <- position_identifier() + use unlocked <- decode.optional(decode.token_wrapper( + named: "unlocked", + with: yes_no, + then: _, + )) + use layer <- layer() + use hide <- optional_hide() + use uuid <- decode.optional(uuid) + use effects <- effects() + decode.success(FootprintText( + type_:, + text:, + position:, + unlocked:, + layer:, + hide:, + uuid:, + effects:, + )) + }) +} + +pub type FootprintTextBox { + FootprintTextBox( + locked: Bool, + text: String, + start: Option(XY), + end: Option(XY), + corners: Option(#(XY, XY, XY, XY)), + margins: Option(#(Float, Float, Float, Float)), + angle: Option(Float), + layer: Layer, + uuid: Option(Uuid), + effects: Effects, + border: Option(Bool), + stroke: Option(Stroke), + render_cache: Option(Nil), + ) +} + +pub fn footprint_text_box(then next: NextFn(FootprintTextBox, a)) -> Decoder(a) { + decode.token(named: "fp_text_box", then: next, with: { + use locked <- decode.flag("locked") + use text <- decode.string() + use start <- decode.optional(custom_xy("start", then: _)) + use end <- decode.optional(custom_xy("end", then: _)) + use corners <- optional_corners() + use margins <- decode.optional(decode.token( + named: "margins", + with: { + use f1 <- decode.float() + use f2 <- decode.float() + use f3 <- decode.float() + use f4 <- decode.float() + decode.success(#(f1, f2, f3, f4)) + }, + then: _, + )) + use angle <- optional_angle() + use layer <- layer() + use uuid <- decode.optional(uuid) + use effects <- effects() + use border <- decode.optional(decode.token_wrapper( + named: "border", + with: yes_no, + then: _, + )) + use stroke <- decode.optional(stroke) + let render_cache = option.None + decode.success(FootprintTextBox( + locked:, + text:, + start:, + end:, + corners:, + margins:, + angle:, + layer:, + uuid:, + effects:, + border:, + stroke:, + render_cache:, + )) + }) +} + +pub type FootprintLine { + FootprintLine( + start: XY, + end: XY, + stroke: Stroke, + layer: Layer, + locked: Bool, + uuid: Option(Uuid), + ) +} + +pub fn footprint_line(then next: NextFn(FootprintLine, a)) -> Decoder(a) { + decode.token(named: "fp_line", then: next, with: { + use start <- custom_xy("start") + use end <- custom_xy("end") + use stroke <- stroke() + use layer <- layer() + use locked <- decode.flag("locked") + use uuid <- decode.optional(uuid) + decode.success(FootprintLine(start:, end:, stroke:, layer:, locked:, uuid:)) + }) +} + +pub type FootprintRectangle { + FootprintRectangle( + start: XY, + end: XY, + stroke: Stroke, + fill: Option(Bool), + layer: Layer, + locked: Bool, + uuid: Option(Uuid), + ) +} + +pub fn footprint_rectangle( + then next: NextFn(FootprintRectangle, a), +) -> Decoder(a) { + decode.token(named: "fp_rect", then: next, with: { + use start <- custom_xy("start") + use end <- custom_xy("end") + use stroke <- stroke() + use fill <- optional_fill() + use layer <- layer() + use locked <- decode.flag("locked") + use uuid <- decode.optional(uuid) + decode.success(FootprintRectangle( + start:, + end:, + stroke:, + fill:, + layer:, + locked:, + uuid:, + )) + }) +} + +pub type FootprintCircle { + FootprintCircle( + center: XY, + end: XY, + stroke: Stroke, + fill: Option(Bool), + layer: Layer, + locked: Bool, + uuid: Option(Uuid), + ) +} + +pub fn footprint_circle(then next: NextFn(FootprintCircle, a)) -> Decoder(a) { + decode.token(named: "fp_circle", then: next, with: { + use center <- custom_xy("center") + use end <- custom_xy("end") + use stroke <- stroke() + use fill <- optional_fill() + use layer <- layer() + use locked <- decode.flag("locked") + use uuid <- decode.optional(uuid) + decode.success(FootprintCircle( + center:, + end:, + stroke:, + fill:, + layer:, + locked:, + uuid:, + )) + }) +} + +pub type FootprintArc { + FootprintArc( + start: XY, + mid: XY, + end: XY, + stroke: Stroke, + layer: Layer, + locked: Bool, + uuid: Option(Uuid), + ) +} + +pub fn footprint_arc(then next: NextFn(FootprintArc, a)) -> Decoder(a) { + decode.token(named: "fp_arc", then: next, with: { + use start <- custom_xy("start") + use mid <- custom_xy("mid") + use end <- custom_xy("end") + use stroke <- stroke() + use layer <- layer() + use locked <- decode.flag("locked") + use uuid <- decode.optional(uuid) + decode.success(FootprintArc( + start:, + mid:, + end:, + stroke:, + layer:, + locked:, + uuid:, + )) + }) +} + +pub type FootprintPolygon { + FootprintPolygon( + points: PolyPoints, + stroke: Stroke, + fill: Option(Bool), + layer: Layer, + locked: Bool, + uuid: Option(Uuid), + ) +} + +pub fn footprint_polygon(then next: NextFn(FootprintPolygon, a)) -> Decoder(a) { + decode.token(named: "fp_poly", then: next, with: { + use points <- poly_points() + use stroke <- stroke() + use fill <- optional_fill() + use layer <- layer() + use locked <- decode.flag("locked") + use uuid <- decode.optional(uuid) + decode.success(FootprintPolygon( + points:, + stroke:, + fill:, + layer:, + locked:, + uuid:, + )) + }) +} + +pub type FootprintCurve { + FootprintCurve( + points: Points, + stroke: Stroke, + layer: Layer, + locked: Bool, + uuid: Option(Uuid), + ) +} + +pub fn footprint_curve(then next: NextFn(FootprintCurve, a)) -> Decoder(a) { + decode.token(named: "fp_curve", then: next, with: { + use points <- points() + use stroke <- stroke() + use layer <- layer() + use locked <- decode.flag("locked") + use uuid <- decode.optional(uuid) + decode.success(FootprintCurve(points:, stroke:, layer:, locked:, uuid:)) + }) +} + +pub type DimensionType { + AlignedDimensionType + LeaderDimensionType + CenterDimensionType + OrthogonalDimensionType + RadialDimensionType +} + +pub fn dimension_type(then next: NextFn(DimensionType, a)) -> Decoder(a) { + decode.enum( + with: [ + #("aligned", AlignedDimensionType), + #("leader", LeaderDimensionType), + #("center", CenterDimensionType), + #("orthogonal", OrthogonalDimensionType), + #("radial", RadialDimensionType), + ], + then: next, + ) +} + +pub type Unit { + InchesUnit + MilsUnit + MillimetersUnit + AutomaticUnit +} + +pub fn unit(then next: NextFn(Unit, a)) -> Decoder(a) { + decode.int_enum( + with: [InchesUnit, MilsUnit, MillimetersUnit, AutomaticUnit], + then: next, + ) +} + +pub type UnitFormat { + NoSuffixUnitFormat + BareSuffixUnitFormat + WrapSuffixUnitFormat +} + +pub fn unit_format(then next: NextFn(UnitFormat, a)) -> Decoder(a) { + decode.int_enum( + with: [NoSuffixUnitFormat, BareSuffixUnitFormat, WrapSuffixUnitFormat], + then: next, + ) +} + +pub type DimensionFormat { + DimensionFormat( + prefix: Option(String), + suffix: Option(String), + unit: Unit, + unit_format: UnitFormat, + precision: Int, + override_value: Option(String), + suppress_zeros: Option(Bool), + ) +} + +pub fn dimension_format(then next: NextFn(DimensionFormat, a)) -> Decoder(a) { + decode.token(named: "format", then: next, with: { + use prefix <- decode.optional(decode.token_wrapper( + named: "prefix", + with: decode.string, + then: _, + )) + use suffix <- decode.optional(decode.token_wrapper( + named: "suffix", + with: decode.string, + then: _, + )) + use unit <- decode.token_wrapper(named: "units", with: unit) + use unit_format <- decode.token_wrapper( + named: "units_format", + with: unit_format, + ) + use precision <- decode.token_wrapper(named: "precision", with: decode.int) + use override_value <- decode.optional(decode.token_wrapper( + named: "override_value", + with: decode.string, + then: _, + )) + use suppress_zeros <- decode.optional(decode.token_wrapper( + named: "suppress_zeros", + with: yes_no, + then: _, + )) + decode.success(DimensionFormat( + prefix:, + suffix:, + unit:, + unit_format:, + precision:, + override_value:, + suppress_zeros:, + )) + }) +} + +pub type TextPositionMode { + OutsideTextPositionMode + InlineTextPositionMode + ManualTextPositionMode +} + +pub fn text_position_mode(then next: NextFn(TextPositionMode, a)) -> Decoder(a) { + decode.int_enum( + with: [ + OutsideTextPositionMode, + InlineTextPositionMode, + ManualTextPositionMode, + ], + then: next, + ) +} + +pub type ArrowDirection { + OutwardArrowDirection + InwardArrowDirection +} + +pub fn arrow_direction(then next: NextFn(ArrowDirection, a)) -> Decoder(a) { + decode.enum( + with: [ + #("outward", OutwardArrowDirection), + #("inward", InwardArrowDirection), + ], + then: next, + ) +} + +pub type TextFrameType { + NoFrame + RectangleFrameType + CircleFrameType + RoundedRectangleFrameType +} + +pub fn text_frame_type(then next: NextFn(TextFrameType, a)) -> Decoder(a) { + decode.int_enum( + with: [ + NoFrame, + RectangleFrameType, + CircleFrameType, + RoundedRectangleFrameType, + ], + then: next, + ) +} + +pub type DimensionStyle { + DimensionStyle( + thickness: Float, + arrow_length: Float, + text_position_mode: TextPositionMode, + arrow_direction: Option(ArrowDirection), + extension_height: Option(Float), + text_frame_type: Option(TextFrameType), + extension_offset: Option(Float), + keep_text_aligned: Option(Bool), + ) +} + +pub fn dimension_style(then next: NextFn(DimensionStyle, a)) -> Decoder(a) { + decode.token(named: "style", then: next, with: { + use thickness <- thickness() + use arrow_length <- decode.token_wrapper( + named: "arrow_length", + with: decode.float, + ) + use text_position_mode <- decode.token_wrapper( + named: "text_position_mode", + with: text_position_mode, + ) + use arrow_direction <- decode.optional(decode.token_wrapper( + named: "arrow_direction", + with: arrow_direction, + then: _, + )) + use extension_height <- decode.optional(decode.token_wrapper( + named: "extension_height", + with: decode.float, + then: _, + )) + use text_frame_type <- decode.optional(decode.token_wrapper( + named: "text_frame", + with: text_frame_type, + then: _, + )) + use extension_offset <- decode.optional(decode.token_wrapper( + named: "extension_offset", + with: decode.float, + then: _, + )) + use keep_text_aligned <- decode.optional(decode.token_wrapper( + named: "keep_text_aligned", + with: yes_no, + then: _, + )) + decode.success(DimensionStyle( + thickness:, + arrow_length:, + text_position_mode:, + arrow_direction:, + extension_height:, + text_frame_type:, + extension_offset:, + keep_text_aligned:, + )) + }) +} + +pub type Dimension { + Dimension( + locked: Bool, + type_: DimensionType, + layer: Layer, + uuid: Option(Uuid), + start: XY, + end: XY, + height: Option(Float), + orientation: Option(Float), + leader_length: Option(Float), + format: Option(DimensionFormat), + style: DimensionStyle, + text: Option(GraphicalText), + ) +} + +pub fn dimension(then next: NextFn(Dimension, a)) -> Decoder(a) { + decode.token(named: "dimension", then: next, with: { + use locked <- decode.flag("locked") + use type_ <- decode.token_wrapper(named: "type", with: dimension_type) + use layer <- layer() + use uuid <- decode.optional(uuid) + use #(start, end) <- decode.token(named: "pts", with: { + use xy1 <- xy() + use xy2 <- xy() + decode.success(#(xy1, xy2)) + }) + use height <- decode.optional(decode.token_wrapper( + named: "height", + with: decode.float, + then: _, + )) + use orientation <- decode.optional(decode.token_wrapper( + named: "orientation", + with: decode.float, + then: _, + )) + use leader_length <- decode.optional(decode.token_wrapper( + named: "leader_length", + with: decode.float, + then: _, + )) + use format <- decode.optional(dimension_format) + use style <- dimension_style() + use text <- decode.optional(graphical_text) + decode.success(Dimension( + locked:, + type_:, + layer:, + uuid:, + start:, + end:, + height:, + orientation:, + leader_length:, + format:, + style:, + text:, + )) + }) +} + +pub type FootprintGraphicItem { + TextFootprintGraphicItem(FootprintText) + TextBoxFootprintGraphicItem(FootprintTextBox) + LineFootprintGraphicItem(FootprintLine) + RectangleFootprintGraphicItem(FootprintRectangle) + CircleFootprintGraphicItem(FootprintCircle) + ArcFootprintGraphicItem(FootprintArc) + PolygonFootprintGraphicItem(FootprintPolygon) + CurveFootprintGraphicItem(FootprintCurve) + DimensionFootprintGraphicItem(Dimension) +} + +pub fn footprint_graphic_item( + then next: NextFn(FootprintGraphicItem, a), +) -> Decoder(a) { + decode.one_of( + footprint_text |> decode.map(TextFootprintGraphicItem), + or: [ + footprint_text_box |> decode.map(TextBoxFootprintGraphicItem), + footprint_line |> decode.map(LineFootprintGraphicItem), + footprint_rectangle |> decode.map(RectangleFootprintGraphicItem), + footprint_circle |> decode.map(CircleFootprintGraphicItem), + footprint_arc |> decode.map(ArcFootprintGraphicItem), + footprint_polygon |> decode.map(PolygonFootprintGraphicItem), + footprint_curve |> decode.map(CurveFootprintGraphicItem), + dimension |> decode.map(DimensionFootprintGraphicItem), + ], + then: next, + ) +} + +pub type GraphicalTextLayer { + GraphicalTextLayer(layer: String, knockout: Bool) +} + +pub fn graphical_text_layer( + then next: NextFn(GraphicalTextLayer, a), +) -> Decoder(a) { + decode.token(named: "layer", then: next, with: { + use layer <- decode.string() + use knockout <- decode.flag("knockout") + decode.success(GraphicalTextLayer(layer:, knockout:)) + }) +} + +pub type GraphicalText { + GraphicalText( + text: String, + position: PositionIdentifier, + layer: Option(GraphicalTextLayer), + uuid: Option(Uuid), + effects: Effects, + ) +} + +pub fn graphical_text(then next: NextFn(GraphicalText, a)) -> Decoder(a) { + decode.token(named: "gr_text", then: next, with: { + use text <- decode.string() + use position <- position_identifier() + use layer <- decode.optional(graphical_text_layer) + use uuid <- decode.optional(uuid) + use effects <- effects() + decode.success(GraphicalText(text:, position:, layer:, uuid:, effects:)) + }) +} + +pub type GraphicalTextBox { + GraphicalTextBox( + locked: Bool, + text: String, + start: Option(XY), + end: Option(XY), + corners: Option(#(XY, XY, XY, XY)), + angle: Option(Float), + layer: Option(Layer), + uuid: Option(Uuid), + effects: Effects, + stroke: Option(Stroke), + render_cache: Option(Nil), + ) +} + +pub fn graphical_text_box(then next: NextFn(GraphicalTextBox, a)) -> Decoder(a) { + decode.token(named: "gr_text_box", then: next, with: { + use locked <- decode.flag("locked") + use text <- decode.string() + use start <- decode.optional(custom_xy("start", then: _)) + use end <- decode.optional(custom_xy("end", then: _)) + use corners <- optional_corners() + use angle <- optional_angle() + use layer <- decode.optional(layer) + use uuid <- decode.optional(uuid) + use effects <- effects() + use stroke <- decode.optional(stroke) + let render_cache = option.None + decode.success(GraphicalTextBox( + locked:, + text:, + start:, + end:, + corners:, + angle:, + layer:, + uuid:, + effects:, + stroke:, + render_cache:, + )) + }) +} + +pub type GraphicalLine { + GraphicalLine( + start: XY, + end: XY, + angle: Option(Float), + layer: Option(Layer), + width: Float, + uuid: Option(Uuid), + ) +} + +pub fn graphical_line(then next: NextFn(GraphicalLine, a)) -> Decoder(a) { + decode.token(named: "gr_line", then: next, with: { + use start <- custom_xy("start") + use end <- custom_xy("end") + use angle <- optional_angle() + use layer <- decode.optional(layer) + use width <- width() + use uuid <- decode.optional(uuid) + decode.success(GraphicalLine(start:, end:, angle:, layer:, width:, uuid:)) + }) +} + +pub type GraphicalRectangle { + GraphicalRectangle( + start: XY, + end: XY, + layer: Option(Layer), + width: Float, + fill: Option(Bool), + uuid: Option(Uuid), + ) +} + +pub fn graphical_rectangle( + then next: NextFn(GraphicalRectangle, a), +) -> Decoder(a) { + decode.token(named: "gr_rect", then: next, with: { + use start <- custom_xy("start") + use end <- custom_xy("end") + use layer <- decode.optional(layer) + use width <- width() + use fill <- optional_fill() + use uuid <- decode.optional(uuid) + decode.success(GraphicalRectangle( + start:, + end:, + layer:, + width:, + fill:, + uuid:, + )) + }) +} + +pub type GraphicalCircle { + GraphicalCircle( + center: XY, + end: XY, + layer: Option(Layer), + width: Float, + fill: Option(Bool), + uuid: Option(Uuid), + ) +} + +pub fn graphical_circle(then next: NextFn(GraphicalCircle, a)) -> Decoder(a) { + decode.token(named: "gr_circle", then: next, with: { + use center <- custom_xy("center") + use end <- custom_xy("end") + use layer <- decode.optional(layer) + use width <- width() + use fill <- optional_fill() + use uuid <- decode.optional(uuid) + decode.success(GraphicalCircle(center:, end:, layer:, width:, fill:, uuid:)) + }) +} + +pub type GraphicalArc { + GraphicalArc( + start: XY, + mid: XY, + end: XY, + layer: Option(Layer), + width: Float, + uuid: Option(Uuid), + ) +} + +pub fn graphical_arc(then next: NextFn(GraphicalArc, a)) -> Decoder(a) { + decode.token(named: "gr_arc", then: next, with: { + use start <- custom_xy("start") + use mid <- custom_xy("mid") + use end <- custom_xy("end") + use layer <- decode.optional(layer) + use width <- width() + use uuid <- decode.optional(uuid) + decode.success(GraphicalArc(start:, mid:, end:, layer:, width:, uuid:)) + }) +} + +pub type GraphicalPolygon { + GraphicalPolygon( + points: PolyPoints, + layer: Option(Layer), + width: Float, + fill: Option(Bool), + uuid: Option(Uuid), + ) +} + +pub fn graphical_polygon(then next: NextFn(GraphicalPolygon, a)) -> Decoder(a) { + decode.token(named: "gr_poly", then: next, with: { + use points <- poly_points() + use layer <- decode.optional(layer) + use width <- width() + use fill <- optional_fill() + use uuid <- decode.optional(uuid) + decode.success(GraphicalPolygon(points:, layer:, width:, fill:, uuid:)) + }) +} + +pub type GraphicalCurve { + GraphicalCurve( + points: Points, + layer: Option(Layer), + width: Float, + uuid: Option(Uuid), + ) +} + +pub fn graphical_curve(then next: NextFn(GraphicalCurve, a)) -> Decoder(a) { + decode.token(named: "bezier", then: next, with: { + use points <- points() + use layer <- decode.optional(layer) + use width <- width() + use uuid <- decode.optional(uuid) + decode.success(GraphicalCurve(points:, layer:, width:, uuid:)) + }) +} + +pub type GraphicalBoundingBox { + GraphicalBoundingBox(start: XY, end: XY) +} + +pub fn graphical_bounding_box( + then next: NextFn(GraphicalBoundingBox, a), +) -> Decoder(a) { + decode.token(named: "gr_bbox", then: next, with: { + use start <- custom_xy("start") + use end <- custom_xy("end") + decode.success(GraphicalBoundingBox(start:, end:)) + }) +} + +pub type GraphicItem { + TextGraphicItem(GraphicalText) + TextBoxGraphicItem(GraphicalTextBox) + LineGraphicItem(GraphicalLine) + RectangleGraphicItem(GraphicalRectangle) + CircleGraphicItem(GraphicalCircle) + ArcGraphicItem(GraphicalArc) + PolygonGraphicItem(GraphicalPolygon) + CurveGraphicItem(GraphicalCurve) + DimensionGraphicItem(Dimension) + BoundingBoxGraphicItem(GraphicalBoundingBox) +} + +pub fn graphic_item(then next: NextFn(GraphicItem, a)) -> Decoder(a) { + decode.one_of( + graphical_text |> decode.map(TextGraphicItem), + or: [ + graphical_text_box |> decode.map(TextBoxGraphicItem), + graphical_line |> decode.map(LineGraphicItem), + graphical_rectangle |> decode.map(RectangleGraphicItem), + graphical_circle |> decode.map(CircleGraphicItem), + graphical_arc |> decode.map(ArcGraphicItem), + graphical_polygon |> decode.map(PolygonGraphicItem), + graphical_curve |> decode.map(CurveGraphicItem), + dimension |> decode.map(DimensionGraphicItem), + graphical_bounding_box |> decode.map(BoundingBoxGraphicItem), + ], + then: next, + ) +} + +pub type SymbolText { + SymbolText(text: String, position: PositionIdentifier, effects: Effects) +} + +pub fn symbol_text(then next: NextFn(SymbolText, a)) -> Decoder(a) { + decode.token(named: "text", then: next, with: { + use text <- decode.string() + use position <- position_identifier() + use effects <- effects() + decode.success(SymbolText(text:, position:, effects:)) + }) +} + +pub type SymbolTextBox { + SymbolTextBox( + text: String, + position: PositionIdentifier, + size: Size, + margins: Option(#(Float, Float, Float, Float)), + stroke: Stroke, + fill: Fill, + effects: Effects, + ) +} + +pub fn symbol_text_box(then next: NextFn(SymbolTextBox, a)) -> Decoder(a) { + decode.token(named: "text_box", then: next, with: { + use text <- decode.string() + use position <- position_identifier() + use size <- size() + use margins <- decode.optional(decode.token( + named: "margins", + with: { + use f1 <- decode.float() + use f2 <- decode.float() + use f3 <- decode.float() + use f4 <- decode.float() + decode.success(#(f1, f2, f3, f4)) + }, + then: _, + )) + use stroke <- stroke() + use fill <- fill() + use effects <- effects() + decode.success(SymbolTextBox( + text:, + position:, + size:, + margins:, + stroke:, + fill:, + effects:, + )) + }) +} + +pub type SymbolLine { + SymbolLine(points: Points, stroke: Stroke, fill: Fill) +} + +pub fn symbol_line(then next: NextFn(SymbolLine, a)) -> Decoder(a) { + decode.token(named: "polyline", then: next, with: { + use points <- points() + use stroke <- stroke() + use fill <- fill() + decode.success(SymbolLine(points:, stroke:, fill:)) + }) +} + +pub type SymbolRectangle { + SymbolRectangle(start: XY, end: XY, stroke: Stroke, fill: Fill) +} + +pub fn symbol_rectangle(then next: NextFn(SymbolRectangle, a)) -> Decoder(a) { + decode.token(named: "rectangle", then: next, with: { + use start <- custom_xy("start") + use end <- custom_xy("end") + use stroke <- stroke() + use fill <- fill() + decode.success(SymbolRectangle(start:, end:, stroke:, fill:)) + }) +} + +pub type SymbolCircle { + SymbolCircle(center: XY, radius: Float, stroke: Stroke, fill: Fill) +} + +pub fn symbol_circle(then next: NextFn(SymbolCircle, a)) -> Decoder(a) { + decode.token(named: "circle", then: next, with: { + use center <- custom_xy("center") + use radius <- decode.token_wrapper(named: "radius", with: decode.float) + use stroke <- stroke() + use fill <- fill() + decode.success(SymbolCircle(center:, radius:, stroke:, fill:)) + }) +} + +pub type SymbolArc { + SymbolArc(start: XY, mid: XY, end: XY, stroke: Stroke, fill: Fill) +} + +pub fn symbol_arc(then next: NextFn(SymbolArc, a)) -> Decoder(a) { + decode.token(named: "arc", then: next, with: { + use start <- custom_xy("start") + use mid <- custom_xy("mid") + use end <- custom_xy("end") + use stroke <- stroke() + use fill <- fill() + decode.success(SymbolArc(start:, mid:, end:, stroke:, fill:)) + }) +} + +pub type SymbolCurve { + SymbolCurve(points: Points, stroke: Stroke, fill: Fill) +} + +pub fn symbol_curve(then next: NextFn(SymbolCurve, a)) -> Decoder(a) { + decode.token(named: "bezier", then: next, with: { + use points <- points() + use stroke <- stroke() + use fill <- fill() + decode.success(SymbolCurve(points:, stroke:, fill:)) + }) +} + +pub type PinElectricalType { + InputElectricalType + OutputElectricalType + BidirectionalElectricalType + TriStateElectricalType + PassiveElectricalType + FreeElectricalType + UnspecifiedElectricalType + PowerInElectricalType + PowerOutElectricalType + OpenCollectorElectricalType + OpenEmitterElectricalType + NoConnectElectricalType +} + +pub fn pin_electrical_type( + then next: NextFn(PinElectricalType, a), +) -> Decoder(a) { + decode.enum( + with: [ + #("input", InputElectricalType), + #("output", OutputElectricalType), + #("bidirectional", BidirectionalElectricalType), + #("tri_state", TriStateElectricalType), + #("passive", PassiveElectricalType), + #("free", FreeElectricalType), + #("unspecified", UnspecifiedElectricalType), + #("power_in", PowerInElectricalType), + #("power_out", PowerOutElectricalType), + #("open_collector", OpenCollectorElectricalType), + #("open_emitter", OpenEmitterElectricalType), + #("no_connect", NoConnectElectricalType), + ], + then: next, + ) +} + +pub type PinGraphicalStyle { + LineGraphicalStyle + InvertedGraphicalStyle + ClockGraphicalStyle + InvertedClockGraphicalStyle + InputLowGraphicalStyle + ClockLowGraphicalStyle + OutputLowGraphicalStyle + EdgeClockHighGraphicalStyle + NonLogicGraphicalStyle +} + +pub fn pin_graphical_style( + then next: NextFn(PinGraphicalStyle, a), +) -> Decoder(a) { + decode.enum( + with: [ + #("line", LineGraphicalStyle), + #("inverted", InvertedGraphicalStyle), + #("clock", ClockGraphicalStyle), + #("inverted_clock", InvertedClockGraphicalStyle), + #("input_low", InputLowGraphicalStyle), + #("clock_low", ClockLowGraphicalStyle), + #("output_low", OutputLowGraphicalStyle), + #("edge_clock_high", EdgeClockHighGraphicalStyle), + #("non_logic", NonLogicGraphicalStyle), + ], + then: next, + ) +} + +pub type PinName { + PinName(name: String, effects: Effects) +} + +pub fn pin_name(then next: NextFn(PinName, a)) -> Decoder(a) { + decode.token(named: "name", then: next, with: { + use name <- decode.string() + use effects <- effects() + decode.success(PinName(name:, effects:)) + }) +} + +pub type PinNumber { + PinNumber(number: String, effects: Effects) +} + +pub fn pin_number(then next: NextFn(PinNumber, a)) -> Decoder(a) { + decode.token(named: "number", then: next, with: { + use number <- decode.string() + use effects <- effects() + decode.success(PinNumber(number:, effects:)) + }) +} + +pub type PinAlternate { + PinAlternate( + name: String, + electrical_type: PinElectricalType, + graphical_style: PinGraphicalStyle, + ) +} + +pub fn pin_alternate(then next: NextFn(PinAlternate, a)) -> Decoder(a) { + decode.token(named: "alternate", then: next, with: { + use name <- decode.string() + use electrical_type <- pin_electrical_type() + use graphical_style <- pin_graphical_style() + decode.success(PinAlternate(name:, electrical_type:, graphical_style:)) + }) +} + +pub type SymbolPin { + SymbolPin( + electrical_type: PinElectricalType, + graphical_style: PinGraphicalStyle, + position: PositionIdentifier, + length: Float, + hide: Option(Bool), + name: PinName, + number: PinNumber, + alternatives: List(PinAlternate), + ) +} + +pub fn symbol_pin(then next: NextFn(SymbolPin, a)) -> Decoder(a) { + decode.token(named: "pin", then: next, with: { + use electrical_type <- pin_electrical_type() + use graphical_style <- pin_graphical_style() + use position <- position_identifier() + use length <- decode.token_wrapper(named: "length", with: decode.float) + use hide_flag <- decode.flag("hide") + use hide <- + case hide_flag { + True -> decode.of(with: decode.success(option.Some(True)), then: _) + False -> optional_hide(then: _) + } + use name <- pin_name() + use number <- pin_number() + use alternatives <- decode.list(pin_alternate) + decode.success(SymbolPin( + electrical_type:, + graphical_style:, + position:, + length:, + hide:, + name:, + number:, + alternatives:, + )) + }) +} + +pub type SymbolGraphicItem { + TextSymbolGraphicItem(SymbolText) + TextBoxSymbolGraphicItem(SymbolTextBox) + LineSymbolGraphicItem(SymbolLine) + RectangleSymbolGraphicItem(SymbolRectangle) + CircleSymbolGraphicItem(SymbolCircle) + ArcSymbolGraphicItem(SymbolArc) + CurveSymbolGraphicItem(SymbolCurve) +} + +pub fn symbol_graphic_item( + then next: NextFn(SymbolGraphicItem, a), +) -> Decoder(a) { + decode.one_of( + symbol_text |> decode.map(TextSymbolGraphicItem), + or: [ + symbol_text_box |> decode.map(TextBoxSymbolGraphicItem), + symbol_line |> decode.map(LineSymbolGraphicItem), + symbol_rectangle |> decode.map(RectangleSymbolGraphicItem), + symbol_circle |> decode.map(CircleSymbolGraphicItem), + symbol_arc |> decode.map(ArcSymbolGraphicItem), + symbol_curve |> decode.map(CurveSymbolGraphicItem), + ], + then: next, + ) +} + +pub type PadType { + ThroughHolePadType + SmdPadPadType + ConnectPadType + NpThroughHolePadType +} + +pub fn pad_type(then next: NextFn(PadType, a)) -> Decoder(a) { + decode.enum( + with: [ + #("thru_hole", ThroughHolePadType), + #("smd", SmdPadPadType), + #("connect", ConnectPadType), + #("np_thru_hole", NpThroughHolePadType), + ], + then: next, + ) +} + +pub type PadShape { + CirclePadShape + RectanglePadShape + OvalPadShape + TrapezoidPadShape + RoundRectPadShape + CustomPadShape +} + +pub fn pad_shape(then next: NextFn(PadShape, a)) -> Decoder(a) { + decode.enum( + with: [ + #("circle", CirclePadShape), + #("rect", RectanglePadShape), + #("oval", OvalPadShape), + #("roundrect", RoundRectPadShape), + #("trapezoid", TrapezoidPadShape), + #("custom", CustomPadShape), + ], + then: next, + ) +} + +pub type PadDrillDefinition { + PadDrillDefinition( + oval: Bool, + diameter: Option(Float), + width: Option(Float), + offset: Option(XY), + ) +} + +pub fn pad_drill_definition( + then next: NextFn(PadDrillDefinition, a), +) -> Decoder(a) { + decode.token(named: "drill", then: next, with: { + use oval <- decode.flag("oval") + use diameter <- decode.optional(decode.float) + use width <- decode.optional(decode.float) + use offset <- decode.optional(custom_xy("offset", then: _)) + decode.success(PadDrillDefinition(oval:, diameter:, width:, offset:)) + }) +} + +pub type PadProperty { + BgaPadProperty + FiducialGlobPadProperty + FiducialLocPadProperty + TestpointPadProperty + HeatsinkPadProperty + CastellatedPadProperty +} + +pub fn pad_property(then next: NextFn(PadProperty, a)) -> Decoder(a) { + decode.enum( + with: [ + #("pad_prop_bga", BgaPadProperty), + #("pad_prop_fiducial_glob", FiducialGlobPadProperty), + #("pad_prop_fiducial_loc", FiducialLocPadProperty), + #("pad_prop_testpoint", TestpointPadProperty), + #("pad_prop_heatsink", HeatsinkPadProperty), + #("pad_prop_castellated", CastellatedPadProperty), + ], + then: next, + ) +} + +pub type Corner { + TopLeft + TopRight + BottomLeft + BottomRight +} + +pub fn corner(then next: NextFn(Corner, a)) -> Decoder(a) { + decode.enum( + with: [ + #("top_left", TopLeft), + #("top_right", TopRight), + #("bottom_left", BottomLeft), + #("bottom_right", BottomRight), + ], + then: next, + ) +} + +pub type Net { + Net(number: Int, name: String) +} + +pub fn net(then next: NextFn(Net, a)) -> Decoder(a) { + decode.token(named: "net", then: next, with: { + use number <- decode.int() + use name <- decode.string() + decode.success(Net(number:, name:)) + }) +} + +pub type ClearanceType { + OutlineClearanceType + ConvexHullClearanceType +} + +pub fn clearance_type(then next: NextFn(ClearanceType, a)) -> Decoder(a) { + decode.enum( + with: [ + #("outline", OutlineClearanceType), + #("convexhull", ConvexHullClearanceType), + ], + then: next, + ) +} + +pub type AnchorPadShape { + RectangleAnchorPadShape + CircleAnchorPadShape +} + +pub fn anchor_pad_shape(then next: NextFn(AnchorPadShape, a)) -> Decoder(a) { + decode.enum( + with: [ + #("rect", RectangleAnchorPadShape), + #("circle", CircleAnchorPadShape), + ], + then: next, + ) +} + +pub type CustomPadOptions { + CustomPadOptions(clearance: ClearanceType, anchor: AnchorPadShape) +} + +pub fn custom_pad_options(then next: NextFn(CustomPadOptions, a)) -> Decoder(a) { + decode.token(named: "options", then: next, with: { + use clearance <- decode.token_wrapper( + named: "clearance", + with: clearance_type, + ) + use anchor <- decode.token_wrapper(named: "anchor", with: anchor_pad_shape) + decode.success(CustomPadOptions(clearance:, anchor:)) + }) +} + +pub type CustomPadPrimitives { + CustomPadPrimitives( + graphic_items: List(GraphicItem), + width: Option(Float), + fill: Option(Bool), + ) +} + +pub fn custom_pad_primitives( + then next: NextFn(CustomPadPrimitives, a), +) -> Decoder(a) { + decode.token(named: "primitives", then: next, with: { + use graphic_items <- decode.list(graphic_item) + use width <- decode.optional(width) + use fill <- optional_fill() + decode.success(CustomPadPrimitives(graphic_items:, width:, fill:)) + }) +} + +pub type Pad { + Pad( + number: String, + type_: PadType, + shape: PadShape, + position: PositionIdentifier, + locked: Bool, + size: Size, + drill: Option(PadDrillDefinition), + rect_delta: Option(XY), + property: Option(PadProperty), + layers: List(Layer), + remove_unused_layers: Option(Bool), + keep_end_layers: Option(Bool), + roundrect_rratio: Option(Float), + chamfer_ratio: Option(Float), + chamfer: Option(List(Corner)), + net: Option(Net), + pin_function: Option(String), + pin_type: Option(String), + die_length: Option(Float), + solder_mask_margin: Option(Float), + solder_paste_margin: Option(Float), + solder_paste_margin_ratio: Option(Float), + clearance: Option(Float), + zone_connection: Option(ConnectionType), + thermal_width: Option(Float), + thermal_gap: Option(Float), + thermal_bridge_width: Option(Float), + thermal_bridge_angle: Option(Float), + custom_options: Option(CustomPadOptions), + custom_primitives: Option(CustomPadPrimitives), + uuid: Option(Uuid), + ) +} + +pub fn pad(then next: NextFn(Pad, a)) -> Decoder(a) { + decode.token(named: "pad", then: next, with: { + use number <- decode.string() + use type_ <- pad_type() + use shape <- pad_shape() + use position <- position_identifier() + use locked <- decode.flag("locked") + use size <- size() + use drill <- decode.optional(pad_drill_definition) + use rect_delta <- decode.optional(custom_xy(named: "rect_delta", then: _)) + use property <- decode.optional(decode.token_wrapper( + named: "property", + with: pad_property, + then: _, + )) + use layers <- layers() + use remove_unused_layers <- decode.optional(decode.token_wrapper( + named: "remove_unused_layers", + with: yes_no, + then: _, + )) + use keep_end_layers <- decode.optional(decode.token_wrapper( + named: "keep_end_layers", + with: yes_no, + then: _, + )) + use roundrect_rratio <- decode.optional(decode.token_wrapper( + named: "roundrect_rratio", + with: decode.float, + then: _, + )) + use chamfer_ratio <- decode.optional(decode.token_wrapper( + named: "chamfer_ratio", + with: decode.float, + then: _, + )) + use chamfer <- decode.optional(decode.token_wrapper( + named: "chamfer", + with: decode.list(corner, then: _), + then: _, + )) + use net <- decode.optional(net) + use pin_function <- decode.optional(decode.token_wrapper( + named: "pinfunction", + with: decode.string, + then: _, + )) + use pin_type <- decode.optional(decode.token_wrapper( + named: "pintype", + with: decode.string, + then: _, + )) + use die_length <- decode.optional(decode.token_wrapper( + named: "die_length", + with: decode.float, + then: _, + )) + use solder_mask_margin <- decode.optional(decode.token_wrapper( + named: "solder_mask_margin", + with: decode.float, + then: _, + )) + use solder_paste_margin <- decode.optional(decode.token_wrapper( + named: "solder_paste_margin", + with: decode.float, + then: _, + )) + use solder_paste_margin_ratio <- decode.optional(decode.token_wrapper( + named: "solder_paste_margin_ratio", + with: decode.float, + then: _, + )) + use clearance <- decode.optional(decode.token_wrapper( + named: "clearance", + with: decode.float, + then: _, + )) + use zone_connection <- decode.optional(decode.token_wrapper( + named: "zone_connect", + with: connection_type, + then: _, + )) + use thermal_width <- decode.optional(decode.token_wrapper( + named: "thermal_width", + with: decode.float, + then: _, + )) + use thermal_gap <- decode.optional(decode.token_wrapper( + named: "thermal_gap", + with: decode.float, + then: _, + )) + use thermal_bridge_width <- decode.optional(decode.token_wrapper( + named: "thermal_bridge_width", + with: decode.float, + then: _, + )) + use thermal_bridge_angle <- decode.optional(decode.token_wrapper( + named: "thermal_bridge_angle", + with: decode.float, + then: _, + )) + use custom_options <- decode.optional(custom_pad_options) + use custom_primitives <- decode.optional(custom_pad_primitives) + use uuid <- decode.optional(uuid) + decode.success(Pad( + number:, + type_:, + shape:, + position:, + locked:, + size:, + drill:, + rect_delta:, + property:, + layers:, + remove_unused_layers:, + keep_end_layers:, + roundrect_rratio:, + chamfer_ratio:, + chamfer:, + net:, + pin_function:, + pin_type:, + die_length:, + solder_mask_margin:, + solder_paste_margin:, + solder_paste_margin_ratio:, + clearance:, + zone_connection:, + thermal_width:, + thermal_gap:, + thermal_bridge_width:, + thermal_bridge_angle:, + custom_options:, + custom_primitives:, + uuid:, + )) + }) +} + +pub type HatchStyle { + NoHatch + EdgeHatchStyle + FullHatchStyle +} + +pub fn hatch_style(then next: NextFn(HatchStyle, a)) -> Decoder(a) { + decode.enum( + with: [ + #("none", NoHatch), + #("edge", EdgeHatchStyle), + #("full", FullHatchStyle), + ], + then: next, + ) +} + +pub type Hatch { + Hatch(style: HatchStyle, pitch: Float) +} + +pub fn hatch(then next: NextFn(Hatch, a)) -> Decoder(a) { + decode.token(named: "hatch", then: next, with: { + use style <- hatch_style() + use pitch <- decode.float() + decode.success(Hatch(style:, pitch:)) + }) +} + +pub type ConnectPads { + ConnectPads(connection_type: Option(ConnectionType), clearance: Float) +} + +pub fn connect_pads(then next: NextFn(ConnectPads, a)) -> Decoder(a) { + decode.token(named: "connect_pads", then: next, with: { + use connection_type <- decode.optional(connection_type) + use clearance <- decode.token_wrapper( + named: "clearance", + with: decode.float, + ) + decode.success(ConnectPads(connection_type:, clearance:)) + }) +} + +pub type ZoneKeepoutSettings { + ZoneKeepoutSettings( + tracks: Bool, + vias: Bool, + pads: Bool, + copper_pour: Bool, + footprints: Bool, + ) +} + +pub fn zone_keepout_settings( + then next: NextFn(ZoneKeepoutSettings, a), +) -> Decoder(a) { + decode.token(named: "keepout", then: next, with: { + use tracks <- decode.token_wrapper(named: "tracks", with: allowed) + use vias <- decode.token_wrapper(named: "vias", with: allowed) + use pads <- decode.token_wrapper(named: "pads", with: allowed) + use copper_pour <- decode.token_wrapper(named: "copperpour", with: allowed) + use footprints <- decode.token_wrapper(named: "footprints", with: allowed) + decode.success(ZoneKeepoutSettings( + tracks:, + vias:, + pads:, + copper_pour:, + footprints:, + )) + }) +} + +pub type FillMode { + HatchedFillMode +} + +pub fn fill_mode(then next: NextFn(FillMode, a)) -> Decoder(a) { + decode.enum(with: [#("hatched", HatchedFillMode)], then: next) +} + +pub type SmoothingStyle { + ChamferSmoothingStyle + FilletSmoothingStyle +} + +pub fn smoothing_style(then next: NextFn(SmoothingStyle, a)) -> Decoder(a) { + decode.enum( + with: [ + #("chamfer", ChamferSmoothingStyle), + #("fillet", FilletSmoothingStyle), + ], + then: next, + ) +} + +pub type IslandRemovalMode { + AlwaysRemove + NeverRemove + MinimumArea +} + +pub fn island_removal_mode( + then next: NextFn(IslandRemovalMode, a), +) -> Decoder(a) { + decode.int_enum(with: [AlwaysRemove, NeverRemove, MinimumArea], then: next) +} + +pub type SmoothingLevel { + NoSmoothingLevel + FilletSmoothingLevel + ArcMinimumSmoothingLevel + ArcMaximumSmoothingLevel +} + +pub fn smoothing_level(then next: NextFn(SmoothingLevel, a)) -> Decoder(a) { + decode.int_enum( + with: [ + NoSmoothingLevel, + FilletSmoothingLevel, + ArcMinimumSmoothingLevel, + ArcMaximumSmoothingLevel, + ], + then: next, + ) +} + +pub type BorderAlgorithm { + ZoneMinimumThicknessBorderAlgorithm + HatchThicknessBorderAlgorithm +} + +pub fn border_algorithm(then next: NextFn(BorderAlgorithm, a)) -> Decoder(a) { + decode.int_enum( + with: [ZoneMinimumThicknessBorderAlgorithm, HatchThicknessBorderAlgorithm], + then: next, + ) +} + +pub type ZoneFillSettings { + ZoneFillSettings( + filled: Bool, + mode: Option(FillMode), + thermal_gap: Option(Float), + thermal_bridge_width: Option(Float), + smoothing: Option(SmoothingStyle), + radius: Option(Float), + island_removal_mode: Option(IslandRemovalMode), + island_area_min: Option(Float), + hatch_thickness: Option(Float), + hatch_gap: Option(Float), + hatch_orientation: Option(Float), + hatch_smoothing_level: Option(SmoothingLevel), + hatch_smoothing_value: Option(Float), + hatch_border_algorithm: Option(BorderAlgorithm), + hatch_min_hole_area: Option(Float), + ) +} + +pub fn zone_fill_settings(then next: NextFn(ZoneFillSettings, a)) -> Decoder(a) { + decode.token(named: "fill", then: next, with: { + use filled <- decode.flag("yes") + use mode <- decode.optional(decode.token_wrapper( + named: "mode", + with: fill_mode, + then: _, + )) + use thermal_gap <- decode.optional(decode.token_wrapper( + named: "thermal_gap", + with: decode.float, + then: _, + )) + use thermal_bridge_width <- decode.optional(decode.token_wrapper( + named: "thermal_bridge_width", + with: decode.float, + then: _, + )) + use smoothing <- decode.optional(decode.token_wrapper( + named: "smoothing", + with: smoothing_style, + then: _, + )) + use radius <- decode.optional(decode.token_wrapper( + named: "radius", + with: decode.float, + then: _, + )) + use island_removal_mode <- decode.optional(decode.token_wrapper( + named: "island_removal_mode", + with: island_removal_mode, + then: _, + )) + use island_area_min <- decode.optional(decode.token_wrapper( + named: "island_area_min", + with: decode.float, + then: _, + )) + use hatch_thickness <- decode.optional(decode.token_wrapper( + named: "hatch_thickness", + with: decode.float, + then: _, + )) + use hatch_gap <- decode.optional(decode.token_wrapper( + named: "hatch_gap", + with: decode.float, + then: _, + )) + use hatch_orientation <- decode.optional(decode.token_wrapper( + named: "hatch_orientation", + with: decode.float, + then: _, + )) + use hatch_smoothing_level <- decode.optional(decode.token_wrapper( + named: "hatch_smoothing_level", + with: smoothing_level, + then: _, + )) + use hatch_smoothing_value <- decode.optional(decode.token_wrapper( + named: "hatch_smoothing_value", + with: decode.float, + then: _, + )) + use hatch_border_algorithm <- decode.optional(decode.token_wrapper( + named: "hatch_border_algorithm", + with: border_algorithm, + then: _, + )) + use hatch_min_hole_area <- decode.optional(decode.token_wrapper( + named: "hatch_min_hole_area", + with: decode.float, + then: _, + )) + decode.success(ZoneFillSettings( + filled:, + mode:, + thermal_gap:, + thermal_bridge_width:, + smoothing:, + radius:, + island_removal_mode:, + island_area_min:, + hatch_thickness:, + hatch_gap:, + hatch_orientation:, + hatch_smoothing_level:, + hatch_smoothing_value:, + hatch_border_algorithm:, + hatch_min_hole_area:, + )) + }) +} + +pub type FilledPolygon { + FilledPolygon(layer: Layer, points: Points) +} + +pub fn filled_polygon(then next: NextFn(FilledPolygon, a)) -> Decoder(a) { + decode.token(named: "filled_polygon", then: next, with: { + use layer <- layer() + use points <- points() + decode.success(FilledPolygon(layer:, points:)) + }) +} + +pub type FillSegments { + FillSegments(layer: Layer, points: Points) +} + +pub fn fill_segments(then next: NextFn(FillSegments, a)) -> Decoder(a) { + decode.token(named: "fill_segments", then: next, with: { + use layer <- layer() + use points <- points() + decode.success(FillSegments(layer:, points:)) + }) +} + +pub type ZonePlacement { + ZonePlacement(enabled: Bool, sheet_name: String) +} + +pub fn zone_placement(then next: NextFn(ZonePlacement, a)) -> Decoder(a) { + decode.token(named: "placement", then: next, with: { + use enabled <- decode.token_wrapper(named: "enabled", with: yes_no, then: _) + use sheet_name <- + decode.token_wrapper(named: "sheetname", with: decode.string, then: _) + decode.success(ZonePlacement(enabled:, sheet_name:)) + }) +} + +pub type Zone { + Zone( + net: Int, + net_name: String, + layers: List(Layer), + uuid: Option(Uuid), + name: Option(String), + hatch: Hatch, + priority: Option(Int), + connect_pads: ConnectPads, + min_thickness: Float, + filled_areas_thickness: Option(Bool), + keepout_settings: Option(ZoneKeepoutSettings), + placement: Option(ZonePlacement), + fill_settings: ZoneFillSettings, + polygon: PolyPoints, + fill_polygons: List(FilledPolygon), + fill_segments: List(FillSegments), + ) +} + +pub fn zone(then next: NextFn(Zone, a)) -> Decoder(a) { + decode.token(named: "zone", then: next, with: { + use net <- decode.token_wrapper(named: "net", with: decode.int) + use net_name <- decode.token_wrapper(named: "net_name", with: decode.string) + use layers <- decode.one_of(layer |> decode.map(list.wrap), or: [layers]) + use uuid <- decode.optional(uuid) + use name <- decode.optional(decode.token_wrapper( + named: "name", + with: decode.string, + then: _, + )) + use hatch <- hatch() + use priority <- decode.optional(decode.token_wrapper( + named: "priority", + with: decode.int, + then: _, + )) + use connect_pads <- connect_pads() + use min_thickness <- decode.token_wrapper( + named: "min_thickness", + with: decode.float, + ) + use filled_areas_thickness <- decode.optional(decode.token_wrapper( + named: "filled_areas_thickness", + with: yes_no, + then: _, + )) + use keepout_settings <- decode.optional(zone_keepout_settings) + use placement <- decode.optional(zone_placement) + use fill_settings <- zone_fill_settings() + use polygon <- decode.token_wrapper(named: "polygon", with: poly_points) + use fill_polygons <- decode.list(filled_polygon) + use fill_segments <- decode.list(fill_segments) + decode.success(Zone( + net:, + net_name:, + layers:, + uuid:, + name:, + hatch:, + priority:, + connect_pads:, + min_thickness:, + filled_areas_thickness:, + keepout_settings:, + placement:, + fill_settings:, + polygon:, + fill_polygons:, + fill_segments:, + )) + }) +} + +pub type Group { + Group(name: String, uuid: Uuid, members: List(Uuid)) +} + +pub fn group(then next: NextFn(Group, a)) -> Decoder(a) { + decode.token(named: "group", then: next, with: { + use name <- decode.string() + use uuid <- uuid() + use members <- decode.token_wrapper(named: "members", with: decode.list( + decode.string, + then: _, + )) + let members = list.map(members, Uuid) + decode.success(Group(name:, uuid:, members:)) + }) +} + +pub type FootprintModel { + FootprintModel( + file: String, + hide: Option(Bool), + offset: XYZ, + scale: XYZ, + rotate: XYZ, + ) +} + +pub fn footprint_model(then next: NextFn(FootprintModel, a)) -> Decoder(a) { + decode.token(named: "model", then: next, with: { + use file <- decode.string() + use hide <- optional_hide() + use offset <- decode.token_wrapper(named: "offset", with: xyz) + use scale <- decode.token_wrapper(named: "scale", with: xyz) + use rotate <- decode.token_wrapper(named: "rotate", with: xyz) + decode.success(FootprintModel(file:, hide:, offset:, scale:, rotate:)) + }) +} + +pub type Footprint { + Footprint( + library_link: Option(String), + locked: Bool, + placed: Bool, + layer: Layer, + tedit: Option(String), + uuid: Option(Uuid), + position: Option(PositionIdentifier), + description: Option(String), + tags: Option(String), + properties: List(FootprintProperty), + path: Option(String), + autoplace_cost_90: Option(Int), + autoplace_cost_180: Option(Int), + solder_mask_margin: Option(Float), + solder_paste_ratio: Option(Float), + solder_paste_margin: Option(Float), + solder_paste_margin_ratio: Option(Float), + clearance: Option(Float), + zone_connect: Option(ConnectionType), + thermal_width: Option(Float), + thermal_gap: Option(Float), + attributes: Option(FootprintAttributes), + private_layers: Option(List(String)), + net_tie_pad_groups: Option(List(String)), + graphic_items: List(FootprintGraphicItem), + pads: List(Pad), + zones: List(Zone), + groups: List(Group), + embedded_fonts: Option(Bool), + models: List(FootprintModel), + ) +} + +fn base_footprint(then next: NextFn(Footprint, a)) -> Decoder(a) { + decode.of(then: next, with: { + use library_link <- decode.optional(decode.string) + use locked <- decode.flag("locked") + use placed <- decode.flag("placed") + use layer <- layer() + use tedit <- decode.optional(decode.token_wrapper( + named: "tedit", + with: decode.string, + then: _, + )) + use uuid <- decode.optional(uuid) + use position <- decode.optional(position_identifier) + use description <- decode.optional(decode.token_wrapper( + named: "descr", + with: decode.string, + then: _, + )) + use tags <- decode.optional(decode.token_wrapper( + named: "tags", + with: decode.string, + then: _, + )) + use properties_a <- decode.list(footprint_property) + use path <- decode.optional(decode.token_wrapper( + named: "path", + with: decode.string, + then: _, + )) + use autoplace_cost_90 <- decode.optional(decode.token_wrapper( + named: "autoplace_cost90", + with: decode.int, + then: _, + )) + use autoplace_cost_180 <- decode.optional(decode.token_wrapper( + named: "autoplace_cost180", + with: decode.int, + then: _, + )) + use solder_mask_margin <- decode.optional(decode.token_wrapper( + named: "solder_mask_margin", + with: decode.float, + then: _, + )) + use solder_paste_ratio <- decode.optional(decode.token_wrapper( + named: "solder_paste_ratio", + with: decode.float, + then: _, + )) + use solder_paste_margin <- decode.optional(decode.token_wrapper( + named: "solder_paste_margin", + with: decode.float, + then: _, + )) + use solder_paste_margin_ratio <- decode.optional(decode.token_wrapper( + named: "solder_paste_margin_ratio", + with: decode.float, + then: _, + )) + use properties_b <- decode.list(footprint_property) + let properties = list.append(properties_a, properties_b) + use clearance <- decode.optional(decode.token_wrapper( + named: "clearance", + with: decode.float, + then: _, + )) + use zone_connect <- decode.optional(decode.token_wrapper( + named: "zone_connect", + with: connection_type, + then: _, + )) + use thermal_width <- decode.optional(decode.token_wrapper( + named: "thermal_width", + with: decode.float, + then: _, + )) + use thermal_gap <- decode.optional(decode.token_wrapper( + named: "thermal_gap", + with: decode.float, + then: _, + )) + use attributes <- decode.optional(footprint_attributes) + use private_layers <- decode.optional(decode.token_wrapper( + named: "private_layers", + with: decode.list(decode.string, then: _), + then: _, + )) + use net_tie_pad_groups <- decode.optional(decode.token_wrapper( + named: "net_tie_pad_groups", + with: decode.list(decode.string, then: _), + then: _, + )) + use graphic_items <- decode.list(footprint_graphic_item) + use pads <- decode.list(pad) + use zones <- decode.list(zone) + use groups <- decode.list(group) + use embedded_fonts <- decode.optional(decode.token_wrapper( + named: "embedded_fonts", + with: yes_no, + then: _, + )) + use models <- decode.list(footprint_model) + decode.success(Footprint( + library_link:, + locked:, + placed:, + layer:, + tedit:, + uuid:, + position:, + description:, + tags:, + properties:, + path:, + autoplace_cost_90:, + autoplace_cost_180:, + solder_mask_margin:, + solder_paste_ratio:, + solder_paste_margin:, + solder_paste_margin_ratio:, + clearance:, + zone_connect:, + thermal_width:, + thermal_gap:, + attributes:, + private_layers:, + net_tie_pad_groups:, + graphic_items:, + pads:, + zones:, + groups:, + embedded_fonts:, + models:, + )) + }) +} + +pub fn footprint(then next: NextFn(Footprint, a)) -> Decoder(a) { + decode.token_wrapper(named: "footprint", with: base_footprint, then: next) +} + +pub type FootprintFile { + FootprintFile( + name: String, + version: Int, + generator: String, + generator_version: Option(String), + footprint: Footprint, + ) +} + +pub fn footprint_file(then next: NextFn(FootprintFile, a)) -> Decoder(a) { + decode.token(named: "footprint", then: next, with: { + use name <- decode.string() + use version <- decode.token_wrapper(named: "version", with: decode.int) + use generator <- decode.token_wrapper( + named: "generator", + with: decode.string, + ) + use generator_version <- decode.optional(decode.token_wrapper( + named: "generator_version", + with: decode.string, + then: _, + )) + use footprint <- base_footprint() + decode.success(FootprintFile( + name:, + version:, + generator:, + generator_version:, + footprint:, + )) + }) +} + +pub type SymbolProperty { + SymbolProperty( + key: String, + value: String, + id: Option(Int), + position: PositionIdentifier, + show_name: Bool, + effects: Effects, + ) +} + +pub fn symbol_property(then next: NextFn(SymbolProperty, a)) -> Decoder(a) { + decode.token(named: "property", then: next, with: { + use key <- decode.string() + use value <- decode.string() + use id <- decode.optional(decode.token_wrapper( + named: "id", + with: decode.int, + then: _, + )) + use position <- position_identifier() + use show_name <- decode.optional(decode.token( + named: "show_name", + with: decode.success(Nil), + then: _, + )) + let show_name = option.is_some(show_name) + use effects <- effects() + decode.success(SymbolProperty( + key:, + value:, + id:, + position:, + show_name:, + effects:, + )) + }) +} + +pub type Symbol { + Symbol( + library_unit_id: String, + extends: Option(String), + power: Bool, + hide_pin_numbers: Option(Bool), + hide_pin_names: Option(Bool), + pin_names_offset: Option(Float), + exclude_from_sim: Option(Bool), + in_bom: Option(Bool), + on_board: Option(Bool), + properties: List(SymbolProperty), + graphics_items: List(SymbolGraphicItem), + pins: List(SymbolPin), + units: List(Symbol), + unit_name: Option(String), + embedded_fonts: Option(Bool), + ) +} + +fn base_symbol(then next: NextFn(Symbol, a)) -> Decoder(a) { + decode.of(then: next, with: { + use library_unit_id <- decode.string + use extends <- decode.optional(decode.token_wrapper( + named: "extends", + with: decode.string, + then: _, + )) + use power <- decode.optional(decode.token( + named: "power", + with: decode.success(Nil), + then: _, + )) + let power = option.is_some(power) + use hide_pin_numbers <- decode.optional(decode.token_wrapper( + named: "pin_numbers", + with: optional_hide, + then: _, + )) + let hide_pin_numbers = option.flatten(hide_pin_numbers) + use pin_names <- decode.optional(decode.token( + named: "pin_names", + with: { + use offset <- decode.optional(decode.token_wrapper( + named: "offset", + with: decode.float, + then: _, + )) + use hide <- optional_hide() + decode.success(#(offset, hide)) + }, + then: _, + )) + let hide_pin_names = option.map(pin_names, pair.second) |> option.flatten + let pin_names_offset = option.then(pin_names, pair.first) + use exclude_from_sim <- decode.optional(decode.token_wrapper( + named: "exclude_from_sim", + with: yes_no, + then: _, + )) + use in_bom <- decode.optional(decode.token_wrapper( + named: "in_bom", + with: yes_no, + then: _, + )) + use on_board <- decode.optional(decode.token_wrapper( + named: "on_board", + with: yes_no, + then: _, + )) + use properties <- decode.list(symbol_property) + use graphics_items <- decode.list(symbol_graphic_item) + use pins <- decode.list(symbol_pin) + use units <- decode.list(symbol) + use unit_name <- decode.optional(decode.token_wrapper( + named: "unit_name", + with: decode.string, + then: _, + )) + use embedded_fonts <- decode.optional(decode.token_wrapper( + named: "embedded_fonts", + with: yes_no, + then: _, + )) + decode.success(Symbol( + library_unit_id:, + extends:, + power:, + hide_pin_numbers:, + hide_pin_names:, + pin_names_offset:, + exclude_from_sim:, + in_bom:, + on_board:, + properties:, + graphics_items:, + pins:, + units:, + unit_name:, + embedded_fonts:, + )) + }) +} + +pub fn symbol(then next: NextFn(Symbol, a)) -> Decoder(a) { + decode.token_wrapper(named: "symbol", with: base_symbol, then: next) +} + +pub type SymbolLibrary { + SymbolLibrary( + version: Int, + generator: String, + generator_version: Option(String), + symbols: List(Symbol), + ) +} + +pub fn symbol_library(then next: NextFn(SymbolLibrary, a)) -> Decoder(a) { + decode.token(named: "kicad_symbol_lib", then: next, with: { + use version <- decode.token_wrapper(named: "version", with: decode.int) + use generator <- decode.token_wrapper( + named: "generator", + with: decode.string, + ) + use generator_version <- decode.optional(decode.token_wrapper( + named: "generator_version", + with: decode.string, + then: _, + )) + use symbols <- decode.list(symbol) + decode.success(SymbolLibrary( + version:, + generator:, + generator_version:, + symbols:, + )) + }) +} diff --git a/test.kicad_mod b/test.kicad_mod new file mode 100644 index 0000000..0b9d7cf --- /dev/null +++ b/test.kicad_mod @@ -0,0 +1,152 @@ +(footprint "R_1812_4532Metric" + (version 20241229) + (generator "kicad-footprint-generator") + (layer "F.Cu") + (descr "Resistor SMD 1812 (4532 Metric), square (rectangular) end terminal, IPC-7351 nominal, (Body size source: https://www.nikhef.nl/pub/departments/mt/projects/detectorR_D/dtddice/ERJ2G.pdf), generated with kicad-footprint-generator") + (tags "resistor") + (property "Reference" "REF**" + (at 0 -2.65 0) + (layer "F.SilkS") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (property "Value" "R_1812_4532Metric" + (at 0 2.65 0) + (layer "F.Fab") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (attr smd) + (fp_line + (start -1.386252 -1.71) + (end 1.386252 -1.71) + (stroke + (width 0.12) + (type solid) + ) + (layer "F.SilkS") + ) + (fp_line + (start -1.386252 1.71) + (end 1.386252 1.71) + (stroke + (width 0.12) + (type solid) + ) + (layer "F.SilkS") + ) + (fp_line + (start -2.95 -1.95) + (end 2.95 -1.95) + (stroke + (width 0.05) + (type solid) + ) + (layer "F.CrtYd") + ) + (fp_line + (start -2.95 1.95) + (end -2.95 -1.95) + (stroke + (width 0.05) + (type solid) + ) + (layer "F.CrtYd") + ) + (fp_line + (start 2.95 -1.95) + (end 2.95 1.95) + (stroke + (width 0.05) + (type solid) + ) + (layer "F.CrtYd") + ) + (fp_line + (start 2.95 1.95) + (end -2.95 1.95) + (stroke + (width 0.05) + (type solid) + ) + (layer "F.CrtYd") + ) + (fp_line + (start -2.25 -1.6) + (end 2.25 -1.6) + (stroke + (width 0.1) + (type solid) + ) + (layer "F.Fab") + ) + (fp_line + (start -2.25 1.6) + (end -2.25 -1.6) + (stroke + (width 0.1) + (type solid) + ) + (layer "F.Fab") + ) + (fp_line + (start 2.25 -1.6) + (end 2.25 1.6) + (stroke + (width 0.1) + (type solid) + ) + (layer "F.Fab") + ) + (fp_line + (start 2.25 1.6) + (end -2.25 1.6) + (stroke + (width 0.1) + (type solid) + ) + (layer "F.Fab") + ) + (fp_text user "${REFERENCE}" + (at 0 0 0) + (layer "F.Fab") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (pad "1" smd roundrect + (at -2.1375 0) + (size 1.125 3.4) + (layers "F.Cu" "F.Mask" "F.Paste") + (roundrect_rratio 0.222222) + ) + (pad "2" smd roundrect + (at 2.1375 0) + (size 1.125 3.4) + (layers "F.Cu" "F.Mask" "F.Paste") + (roundrect_rratio 0.222222) + ) + (embedded_fonts no) + (model "${KICAD9_3DMODEL_DIR}/Resistor_SMD.3dshapes/R_1812_4532Metric.step" + (offset + (xyz 0 0 0) + ) + (scale + (xyz 1 1 1) + ) + (rotate + (xyz 0 0 0) + ) + ) +) diff --git a/test/kicad_sexpr_test.gleam b/test/kicad_sexpr_test.gleam new file mode 100644 index 0000000..fba3c88 --- /dev/null +++ b/test/kicad_sexpr_test.gleam @@ -0,0 +1,13 @@ +import gleeunit + +pub fn main() -> Nil { + gleeunit.main() +} + +// gleeunit test functions end in `_test` +pub fn hello_world_test() { + let name = "Joe" + let greeting = "Hello, " <> name <> "!" + + assert greeting == "Hello, Joe!" +} diff --git a/test2.kicad_mod b/test2.kicad_mod new file mode 100644 index 0000000..9e49842 --- /dev/null +++ b/test2.kicad_mod @@ -0,0 +1,338 @@ +(footprint "Relay_DPDT_AXICOM_IMSeries_JLeg" + (version 20241229) + (generator "pcbnew") + (generator_version "9.0") + (layer "F.Cu") + (descr "http://www.te.com/commerce/DocumentDelivery/DDEController?Action=showdoc&DocId=Specification+Or+Standard%7F108-98001%7FW5%7Fpdf%7FEnglish%7FENG_SS_108-98001_W5.pdf") + (tags "AXICOM IM-Series Relay J JLeg") + (property "Reference" "REF**" + (at 0 -6 0) + (layer "F.SilkS") + (uuid "dd99cfbd-d6b2-4ffd-9f36-eff1e9c4d053") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (property "Value" "Relay_DPDT_AXICOM_IMSeries_JLeg" + (at 0 6.25 0) + (layer "F.Fab") + (uuid "9aa3f47c-195e-4a1e-a0ef-27453eee41fe") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (property "Datasheet" "" + (at 0 0 0) + (unlocked yes) + (layer "F.Fab") + (hide yes) + (uuid "9a83d93b-caf9-4598-9f8a-6d35d6cad0f8") + (effects + (font + (size 1.27 1.27) + (thickness 0.15) + ) + ) + ) + (property "Description" "" + (at 0 0 0) + (unlocked yes) + (layer "F.Fab") + (hide yes) + (uuid "46230326-fc25-48f7-99b1-be130eacca1a") + (effects + (font + (size 1.27 1.27) + (thickness 0.15) + ) + ) + ) + (attr smd) + (fp_line + (start -3.2 -5.2) + (end -3.2 -4.45) + (stroke + (width 0.15) + (type solid) + ) + (layer "F.SilkS") + (uuid "67f237fb-d063-4749-ad1c-21422dc150de") + ) + (fp_line + (start -3.2 4.45) + (end -3.2 5.2) + (stroke + (width 0.15) + (type solid) + ) + (layer "F.SilkS") + (uuid "9c445b8f-71dc-4f39-8924-f59f9346b135") + ) + (fp_line + (start -3.2 5.2) + (end -2.45 5.2) + (stroke + (width 0.15) + (type solid) + ) + (layer "F.SilkS") + (uuid "6b60da81-bb01-4777-9085-4e5296c89d91") + ) + (fp_line + (start -3.05 -5.2) + (end -3.2 -5.05) + (stroke + (width 0.15) + (type solid) + ) + (layer "F.SilkS") + (uuid "0dd8d971-8a43-4797-840a-0380dabdb52e") + ) + (fp_line + (start -2.9 -5.2) + (end -3.2 -4.9) + (stroke + (width 0.15) + (type solid) + ) + (layer "F.SilkS") + (uuid "3ab4bec7-3ca0-40d3-8118-cf643eb51c1f") + ) + (fp_line + (start -2.75 -5.2) + (end -3.2 -4.75) + (stroke + (width 0.15) + (type solid) + ) + (layer "F.SilkS") + (uuid "6867aae2-5d0a-41ca-b124-cbd3047e8be2") + ) + (fp_line + (start -2.6 -5.2) + (end -3.2 -4.6) + (stroke + (width 0.15) + (type solid) + ) + (layer "F.SilkS") + (uuid "e4e2b51b-7f54-4d83-b7e2-0c837bc417c9") + ) + (fp_line + (start -2.45 -5.2) + (end -3.2 -5.2) + (stroke + (width 0.15) + (type solid) + ) + (layer "F.SilkS") + (uuid "d1c6f2c7-f2a5-40f5-9ef5-d1284a7a4b04") + ) + (fp_line + (start 2.45 -5.2) + (end 3.2 -5.2) + (stroke + (width 0.15) + (type solid) + ) + (layer "F.SilkS") + (uuid "ed1bd233-1f89-4a37-a9ec-64ec98ba8504") + ) + (fp_line + (start 2.45 5.2) + (end 3.2 5.2) + (stroke + (width 0.15) + (type solid) + ) + (layer "F.SilkS") + (uuid "2e76801f-1cb5-4afa-9818-db56f6fd6b4b") + ) + (fp_line + (start 3.2 -5.2) + (end 3.2 -4.45) + (stroke + (width 0.15) + (type solid) + ) + (layer "F.SilkS") + (uuid "aec04f79-dd80-41be-aae9-fd4c7e25e0eb") + ) + (fp_line + (start 3.2 4.45) + (end 3.2 5.2) + (stroke + (width 0.15) + (type solid) + ) + (layer "F.SilkS") + (uuid "89c6d544-8ee2-46dd-a009-96bbeb63f108") + ) + (fp_line + (start -3.45 -5.25) + (end -3.45 5.25) + (stroke + (width 0.05) + (type solid) + ) + (layer "F.CrtYd") + (uuid "577bb927-56fc-4aa5-a4f2-056a46d08910") + ) + (fp_line + (start -3.45 5.25) + (end 3.45 5.25) + (stroke + (width 0.05) + (type solid) + ) + (layer "F.CrtYd") + (uuid "4a3c332a-be3b-47ba-90d7-fa9675b4fdd0") + ) + (fp_line + (start 3.45 -5.25) + (end -3.45 -5.25) + (stroke + (width 0.05) + (type solid) + ) + (layer "F.CrtYd") + (uuid "6ded1472-d1d9-4904-b808-597851b7a26f") + ) + (fp_line + (start 3.45 5.25) + (end 3.45 -5.25) + (stroke + (width 0.05) + (type solid) + ) + (layer "F.CrtYd") + (uuid "6c3f1e97-16d3-404a-ac59-209747f4039e") + ) + (fp_line + (start -3 -4.5) + (end -2.5 -5) + (stroke + (width 0.15) + (type solid) + ) + (layer "F.Fab") + (uuid "9359c75d-e786-4ae7-a81f-0a706b450a81") + ) + (fp_line + (start -3 5) + (end -3 -4.5) + (stroke + (width 0.15) + (type solid) + ) + (layer "F.Fab") + (uuid "da412642-80db-4449-8b83-730ed4a510c0") + ) + (fp_line + (start -2.5 -5) + (end 3 -5) + (stroke + (width 0.15) + (type solid) + ) + (layer "F.Fab") + (uuid "d8faf5d8-35c5-48ab-8bd9-a78a780756e0") + ) + (fp_line + (start 3 -5) + (end 3 5) + (stroke + (width 0.15) + (type solid) + ) + (layer "F.Fab") + (uuid "1e570dff-540f-48e6-b8c4-080ac111214a") + ) + (fp_line + (start 3 5) + (end -3 5) + (stroke + (width 0.15) + (type solid) + ) + (layer "F.Fab") + (uuid "19922db0-8619-4c33-bf9c-63ee863f246a") + ) + (fp_text user "${REFERENCE}" + (at 0.06 0 90) + (layer "F.Fab") + (uuid "6b26c96a-b82c-4db6-85ae-d9cb09a6f67b") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (pad "1" smd rect + (at -2.2 -3.8) + (size 2 0.7) + (layers "F.Cu" "F.Mask" "F.Paste") + (uuid "82eff78a-635a-433b-b1ee-de6410e81430") + ) + (pad "2" smd rect + (at -2.2 -0.6) + (size 2 0.7) + (layers "F.Cu" "F.Mask" "F.Paste") + (uuid "05985d65-1bc3-4618-a5d8-cafdc1a66970") + ) + (pad "3" smd rect + (at -2.2 1.6) + (size 2 0.7) + (layers "F.Cu" "F.Mask" "F.Paste") + (uuid "d8966a22-f301-465e-882c-18cafa507d67") + ) + (pad "4" smd rect + (at -2.2 3.8) + (size 2 0.7) + (layers "F.Cu" "F.Mask" "F.Paste") + (uuid "a0d6dc62-a560-4289-9c84-1a25bb0be83e") + ) + (pad "5" smd rect + (at 2.2 3.8) + (size 2 0.7) + (layers "F.Cu" "F.Mask" "F.Paste") + (uuid "c489d137-cea0-4d95-a34c-4e8dc5daa9d4") + ) + (pad "6" smd rect + (at 2.2 1.6) + (size 2 0.7) + (layers "F.Cu" "F.Mask" "F.Paste") + (uuid "dafce1a4-6cb0-478b-9d93-4c7f8069698d") + ) + (pad "7" smd rect + (at 2.2 -0.6) + (size 2 0.7) + (layers "F.Cu" "F.Mask" "F.Paste") + (uuid "255cb5c5-374a-41a6-8f55-ae69caccfcf7") + ) + (pad "8" smd rect + (at 2.2 -3.8) + (size 2 0.7) + (layers "F.Cu" "F.Mask" "F.Paste") + (uuid "c637267d-9a42-4816-9c0e-4c9e3c7278c1") + ) + (embedded_fonts no) + (model "${KICAD9_3DMODEL_DIR}/Relay_SMD.3dshapes/Relay_DPDT_AXICOM_IMSeries_JLeg.step" + (offset + (xyz 0 0 0) + ) + (scale + (xyz 1 1 1) + ) + (rotate + (xyz 0 0 0) + ) + ) +) diff --git a/test3.kicad_mod b/test3.kicad_mod new file mode 100644 index 0000000..b0c76a2 --- /dev/null +++ b/test3.kicad_mod @@ -0,0 +1,6400 @@ +(footprint "Smolhaj_Scale_0.1" + (version 20241229) + (generator "pcbnew") + (generator_version "9.0") + (layer "F.Cu") + (descr "BLÅHAJ , smol 50cm nominal, 1:10 scale (56mm Snoot-Flosse), MPN 205.406.63 (https://www.ikea.com/gb/en/p/blahaj-soft-toy-baby-shark-20540663/)") + (tags "Ikea Smol Haj") + (property "Reference" "REF**" + (at -2.430063 -0.916005 0) + (unlocked yes) + (layer "F.SilkS") + (hide yes) + (uuid "525bd122-a62b-4665-b759-aa47e1324182") + (effects + (font + (size 1 1) + (thickness 0.1) + ) + ) + ) + (property "Value" "Smolhaj_Scale_0.1" + (at -11.5 -2.25 0) + (unlocked yes) + (layer "F.Fab") + (uuid "72ce629d-03fd-484b-9349-8f3e0a716020") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (property "Datasheet" "" + (at -2.430063 -0.366005 0) + (unlocked yes) + (layer "F.Fab") + (hide yes) + (uuid "5d3ac9a8-a300-4328-8e73-d1cdba2f8773") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (property "Description" "" + (at -2.430063 -0.366005 0) + (unlocked yes) + (layer "F.Fab") + (hide yes) + (uuid "5ad5394a-7198-4b59-b054-f51f52fff9ec") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (attr exclude_from_pos_files exclude_from_bom allow_missing_courtyard) + (private_layers "User.2") + (fp_line + (start -55.897041 7.382052) + (end -55.896611 7.455952) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8f8a8793-b319-4972-ad30-5f5b4edc3f6f") + ) + (fp_line + (start -55.896611 7.455952) + (end -55.892296 7.525516) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ee039847-ff71-484c-9bd8-477778076c74") + ) + (fp_line + (start -55.893483 7.303754) + (end -55.897041 7.382052) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "96073bb6-49c8-44dc-942e-6591824606bb") + ) + (fp_line + (start -55.892296 7.525516) + (end -55.884197 7.590803) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "9c2a7621-1c31-42b3-896e-ade59b3a2225") + ) + (fp_line + (start -55.885832 7.220998) + (end -55.893483 7.303754) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "823da60a-30b8-4cf1-9edf-7b05c2900eae") + ) + (fp_line + (start -55.884197 7.590803) + (end -55.872418 7.651873) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "cae87421-449f-4bad-8116-d81c4554f819") + ) + (fp_line + (start -55.873986 7.133723) + (end -55.885832 7.220998) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "9427845e-a49b-494b-b74a-ffc63c36713e") + ) + (fp_line + (start -55.872418 7.651873) + (end -55.857062 7.70879) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "0c254427-0072-4413-9cdc-fe83aadad6b7") + ) + (fp_line + (start -55.857844 7.041867) + (end -55.873986 7.133723) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "a63fdab0-517f-4339-af69-63f4e50730e8") + ) + (fp_line + (start -55.857062 7.70879) + (end -55.838231 7.761611) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8216c6e5-b041-4fa8-a6b5-c1173ad2907f") + ) + (fp_line + (start -55.838231 7.761611) + (end -55.81603 7.810397) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "adc989c9-8f36-4acd-889b-a75dcadc9cb2") + ) + (fp_line + (start -55.8373 6.945373) + (end -55.857844 7.041867) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "eea9aab6-0e82-484e-9806-ae1248a27b1b") + ) + (fp_line + (start -55.81603 7.810397) + (end -55.790559 7.85521) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1802a561-9ed4-464d-87d7-930499b20062") + ) + (fp_line + (start -55.812253 6.844179) + (end -55.8373 6.945373) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "769090a0-5bff-4f87-92b1-dfd7c06e19d1") + ) + (fp_line + (start -55.790559 7.85521) + (end -55.761923 7.896109) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "61b2258f-3815-44a5-9694-f6e14b2aa9ff") + ) + (fp_line + (start -55.761923 7.896109) + (end -55.730225 7.933156) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "5aca2aba-16c2-4c91-bf0e-daffc8080085") + ) + (fp_line + (start -55.748693 6.627744) + (end -55.812253 6.844179) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "faa24f93-0816-4eb2-ab2d-c6a06a6d85a5") + ) + (fp_line + (start -55.730225 7.933156) + (end -55.695566 7.966411) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "79a23281-ac13-4e6f-ac45-d1df2c262f4a") + ) + (fp_line + (start -55.695566 7.966411) + (end -55.658052 7.995934) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "f5fd826f-548e-4b2b-a4d1-a37d86b11171") + ) + (fp_line + (start -55.668609 6.393574) + (end -55.748693 6.627744) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ee7b56ec-a98a-40af-b5d4-9fc1131f0409") + ) + (fp_line + (start -55.658052 7.995934) + (end -55.617783 8.021786) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ed2b6a50-3f35-4264-87ca-972593f457e4") + ) + (fp_line + (start -55.617783 8.021786) + (end -55.574864 8.044029) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "2da0ea46-8bd6-4a8a-90c4-4156ae88ba43") + ) + (fp_line + (start -55.574864 8.044029) + (end -55.529397 8.062721) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "e4cb3c4b-fac1-4148-80c1-6feb69db6155") + ) + (fp_line + (start -55.573904 6.142972) + (end -55.668609 6.393574) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "acc988ee-ac86-482e-8d45-654dc3b35514") + ) + (fp_line + (start -55.529397 8.062721) + (end -55.481484 8.077924) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "4e6d3358-7bc8-4d0d-b825-9e1249731547") + ) + (fp_line + (start -55.481484 8.077924) + (end -55.43123 8.089699) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "753e7202-b629-4209-9605-235373175056") + ) + (fp_line + (start -55.46648 5.877246) + (end -55.573904 6.142972) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "053d9786-251e-4999-8891-f981f9961297") + ) + (fp_line + (start -55.43123 8.089699) + (end -55.378736 8.098105) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7f35cccb-2ebb-4a89-812c-3d4bb79b009b") + ) + (fp_line + (start -55.378736 8.098105) + (end -55.324105 8.103205) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "b29cab2e-64fb-4fb8-b26d-3478451c2de9") + ) + (fp_line + (start -55.324105 8.103205) + (end -55.267441 8.105056) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "756cbde8-9973-4924-83f1-da89ce5d06fb") + ) + (fp_line + (start -55.267441 8.105056) + (end -55.208847 8.103722) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "a7448da1-c166-4d29-ac94-f2bf5446a529") + ) + (fp_line + (start -55.221088 5.305642) + (end -55.46648 5.877246) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "9c9c4f9d-69c9-465d-a9e6-623cf88f35e9") + ) + (fp_line + (start -55.208847 8.103722) + (end -55.148425 8.099261) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "10097fd4-df60-4ceb-bf0f-530ecb91d6d5") + ) + (fp_line + (start -55.178982 -7.647088) + (end -55.175128 -7.562798) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "0e32d018-3918-4c96-96ac-7cd343828b52") + ) + (fp_line + (start -55.178569 -7.727944) + (end -55.178982 -7.647088) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7e97bd34-54dd-436b-ba86-581cb95a081f") + ) + (fp_line + (start -55.175128 -7.562798) + (end -55.166983 -7.475185) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "da803e80-545c-4486-9f12-47d866b38b06") + ) + (fp_line + (start -55.173908 -7.805251) + (end -55.178569 -7.727944) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "814aeaf4-6337-4d7c-a7ba-ff25a9edd850") + ) + (fp_line + (start -55.166983 -7.475185) + (end -55.154526 -7.384364) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "81c90370-6e54-4c54-840b-70feddc8ad4b") + ) + (fp_line + (start -55.165024 -7.878896) + (end -55.173908 -7.805251) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "695d0dbf-c602-444f-9fde-b6bd198ff48a") + ) + (fp_line + (start -55.154526 -7.384364) + (end -55.116911 -7.193502) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8182dda4-a496-4672-9919-f9c3eb6fec50") + ) + (fp_line + (start -55.151938 -7.948766) + (end -55.165024 -7.878896) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "0a0264bd-841b-4662-afd1-36508915c169") + ) + (fp_line + (start -55.148425 8.099261) + (end -55.086279 8.091736) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "dce63205-9233-44cf-9bc6-935705b0023d") + ) + (fp_line + (start -55.134673 -8.014746) + (end -55.151938 -7.948766) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "fa9037bf-d484-4397-b5bc-c24c9f9f52ef") + ) + (fp_line + (start -55.116911 -7.193502) + (end -55.063737 -6.990858) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "dfdf74d4-2dc9-4564-9dcf-4d1020a56fe8") + ) + (fp_line + (start -55.113249 -8.076722) + (end -55.134673 -8.014746) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "b086203f-80de-4f51-809b-ad0920de4a20") + ) + (fp_line + (start -55.087692 -8.134583) + (end -55.113249 -8.076722) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "57cfa589-ac45-43b2-8c75-6b898ce0aa43") + ) + (fp_line + (start -55.086279 8.091736) + (end -55.022509 8.081206) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "22d9e615-17c4-4067-a5f7-64b8a2e084c2") + ) + (fp_line + (start -55.063737 -6.990858) + (end -54.996783 -6.777025) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "54459e70-98c8-4c98-a94e-76c003159b80") + ) + (fp_line + (start -55.058021 -8.188215) + (end -55.087692 -8.134583) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1deb2279-ef87-45a0-8ba3-5e65a74161d6") + ) + (fp_line + (start -55.024258 -8.237502) + (end -55.058021 -8.188215) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "826cb51b-2b8a-4a01-824d-198fff19af46") + ) + (fp_line + (start -55.022509 8.081206) + (end -54.957222 8.067732) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "d8ac28cc-957a-487b-b48f-0073a1b5382d") + ) + (fp_line + (start -54.996783 -6.777025) + (end -54.917825 -6.552596) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "625249a5-6164-4cb2-a497-e224eb21b86c") + ) + (fp_line + (start -54.986427 -8.282333) + (end -55.024258 -8.237502) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1d452ade-bc8b-4bcb-8d48-f3edb40a93a7") + ) + (fp_line + (start -54.957222 8.067732) + (end -54.890519 8.051374) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "e1cc8954-0f2c-4e20-9d66-017372693987") + ) + (fp_line + (start -54.947648 4.68921) + (end -55.221088 5.305642) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "bf6e7d11-44b2-4da9-a67e-a9d38ea073e3") + ) + (fp_line + (start -54.94455 -8.322593) + (end -54.986427 -8.282333) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8ec7aeab-44c7-4aa3-a21f-a5de251e0103") + ) + (fp_line + (start -54.917825 -6.552596) + (end -54.731014 -6.074328) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "c54812a3-6c5e-40ef-bfd9-93d3eeeaee1c") + ) + (fp_line + (start -54.898648 -8.358169) + (end -54.94455 -8.322593) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "f74d2353-fec1-4c43-adc4-092a396543c1") + ) + (fp_line + (start -54.890519 8.051374) + (end -54.753161 8.010229) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "6d3b2672-e386-4a85-ba71-214cb8862182") + ) + (fp_line + (start -54.848745 -8.388948) + (end -54.898648 -8.358169) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1ae5616f-d760-4dba-8686-7c7f148380b8") + ) + (fp_line + (start -54.79486 -8.414816) + (end -54.848745 -8.388948) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "92b0c628-be02-4823-a878-d74ceb35b43a") + ) + (fp_line + (start -54.753161 8.010229) + (end -54.610673 7.958159) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "59cacb68-b433-4746-82e9-d2b60581a593") + ) + (fp_line + (start -54.737019 -8.435659) + (end -54.79486 -8.414816) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "978a2186-f9f5-42fb-b733-f89a5e247aac") + ) + (fp_line + (start -54.731014 -6.074328) + (end -54.517529 -5.560804) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7c788610-0ef1-4a9b-8486-063787f6fbbe") + ) + (fp_line + (start -54.675242 -8.451363) + (end -54.737019 -8.435659) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8d1b8814-068d-47fb-9d49-59e5cd32b066") + ) + (fp_line + (start -54.661379 4.0384) + (end -54.947648 4.68921) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "69335be0-01f3-48b5-a61c-b3962e388bbc") + ) + (fp_line + (start -54.610673 7.958159) + (end -54.463176 7.895528) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "064c3558-834f-4bea-aa56-67cd76be9620") + ) + (fp_line + (start -54.60955 -8.461817) + (end -54.675242 -8.451363) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "0cf46ecc-3e38-4db2-9306-0673ba521faf") + ) + (fp_line + (start -54.539968 -8.466904) + (end -54.60955 -8.461817) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "b1c16e90-050c-4acd-9ae5-1bf6e60fd0aa") + ) + (fp_line + (start -54.517529 -5.560804) + (end -54.291597 -5.016772) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "e43226ea-99bd-42cb-8f88-f81b19706ed4") + ) + (fp_line + (start -54.466517 -8.466514) + (end -54.539968 -8.466904) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "03acedf3-2c0e-43a1-8d94-c71bc05080c0") + ) + (fp_line + (start -54.463176 7.895528) + (end -54.310793 7.822703) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "cad2afd9-4654-49a0-ae04-bf6f88f01e9e") + ) + (fp_line + (start -54.389217 -8.460531) + (end -54.466517 -8.466514) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "c21905af-2c32-4aad-b50f-2b3ef94aeafd") + ) + (fp_line + (start -54.377498 3.363657) + (end -54.661379 4.0384) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "05e6d027-3f97-4c7f-b90c-40e87a3fa5c6") + ) + (fp_line + (start -54.310793 7.822703) + (end -54.153644 7.740052) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "cacd1322-1fb7-41e1-bf18-74b2a9817bbf") + ) + (fp_line + (start -54.308095 -8.448842) + (end -54.389217 -8.460531) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8d4c3513-5a94-40df-ae65-e289c07e5a5c") + ) + (fp_line + (start -54.291597 -5.016772) + (end -54.067442 -4.446979) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "a9513ca3-0da1-4093-86b3-0ad7f2356b4e") + ) + (fp_line + (start -54.241209 3.020575) + (end -54.377498 3.363657) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "6eee8345-86bd-436c-822c-746bc929bffc") + ) + (fp_line + (start -54.223168 -8.431333) + (end -54.308095 -8.448842) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "55d4b894-8915-4f12-a378-aa6fe6b46ec4") + ) + (fp_line + (start -54.153644 7.740052) + (end -53.99185 7.647939) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "29efd73d-ea98-48a2-b1ad-da03a6299282") + ) + (fp_line + (start -54.134462 -8.407892) + (end -54.223168 -8.431333) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "72dcdcc4-ae54-4543-aa69-a5ba808c40b5") + ) + (fp_line + (start -54.111224 2.675428) + (end -54.241209 3.020575) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "2bcd5e9b-c3f4-4833-ab2a-d775c1981bdc") + ) + (fp_line + (start -54.067442 -4.446979) + (end -53.960476 -4.153909) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "5984acf8-133f-4e32-967e-7bc500bb8b21") + ) + (fp_line + (start -54.041997 -8.378405) + (end -54.134462 -8.407892) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "b0f51006-4b9b-4f74-85c1-08c40267cc21") + ) + (fp_line + (start -53.99185 7.647939) + (end -53.825534 7.546731) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ea5fdb77-3aff-480c-93b2-8271b00fcb50") + ) + (fp_line + (start -53.989445 2.329522) + (end -54.111224 2.675428) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "9f95e87f-d87c-4f18-a618-47a9db28c37b") + ) + (fp_line + (start -53.960476 -4.153909) + (end -53.859289 -3.856178) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ab0293f3-dfb7-4f0f-bbff-790618b04238") + ) + (fp_line + (start -53.945796 -8.342757) + (end -54.041997 -8.378405) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "894498c3-a525-494a-9501-9f9571257d29") + ) + (fp_line + (start -53.877775 1.984164) + (end -53.989445 2.329522) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8722fbc4-407b-4fb2-a8b5-06a5696ab946") + ) + (fp_line + (start -53.859289 -3.856178) + (end -53.765659 -3.554382) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "9e960a98-4797-4713-8649-cd807394a211") + ) + (fp_line + (start -53.845881 -8.300836) + (end -53.945796 -8.342757) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7317c8a2-d579-4352-a6b0-1d0c2ec0159d") + ) + (fp_line + (start -53.825534 7.546731) + (end -53.654818 7.436795) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "14a57a1e-4c06-4708-8301-1106636e8792") + ) + (fp_line + (start -53.777789 1.640454) + (end -53.877775 1.984164) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "a2c2aac5-1cc7-4e44-94bc-427a3886d651") + ) + (fp_line + (start -53.765659 -3.554382) + (end -53.681364 -3.249115) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1cc418f9-1c6c-4f9e-928b-14de0722a7d5") + ) + (fp_line + (start -53.742275 -8.252528) + (end -53.845881 -8.300836) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7963c062-c2a1-44bb-aea4-75623a788ef3") + ) + (fp_line + (start -53.68976 1.298665) + (end -53.777789 1.640454) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "a4b7cbc4-4f02-47b8-af8c-06dfa6a6ecae") + ) + (fp_line + (start -53.681364 -3.249115) + (end -53.607896 -2.940886) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "5b44fd70-617c-4407-afd8-c9b3b4653c75") + ) + (fp_line + (start -53.654818 7.436795) + (end -53.47982 7.318496) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "88ea73d1-74ee-4e12-b78d-16bcf02f38af") + ) + (fp_line + (start -53.634999 -8.19772) + (end -53.742275 -8.252528) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "6d42f77d-e606-4dca-8011-4441749c3145") + ) + (fp_line + (start -53.613632 0.958861) + (end -53.68976 1.298665) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ce692e59-707c-4602-8a56-c81dd73918ae") + ) + (fp_line + (start -53.607896 -2.940886) + (end -53.545598 -2.629845) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "10b88da7-e353-4cf9-a10d-d2a03b83622f") + ) + (fp_line + (start -53.549349 0.621105) + (end -53.613632 0.958861) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "11b4fc7a-2f3c-43b1-b5b6-1e50683d8761") + ) + (fp_line + (start -53.545598 -2.629845) + (end -53.494526 -2.31606) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "19868be0-b333-4c94-97d2-740bdea4f042") + ) + (fp_line + (start -53.524075 -8.136297) + (end -53.634999 -8.19772) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "2f86474d-83c6-4f4e-991d-c5ba095e9863") + ) + (fp_line + (start -53.496852 0.285461) + (end -53.549349 0.621105) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "36eb2e9c-7f97-4362-b9f5-910f51924ab4") + ) + (fp_line + (start -53.494526 -2.31606) + (end -53.454738 -1.999593) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "b3902859-ebb6-4a77-b255-4da0f65e1d26") + ) + (fp_line + (start -53.47982 7.318496) + (end -53.300664 7.192203) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "2d01c3fb-9d82-42ff-b304-08132b53ec20") + ) + (fp_line + (start -53.45609 -0.048008) + (end -53.496852 0.285461) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "00e68dad-faeb-4168-8cd1-bed7917950f0") + ) + (fp_line + (start -53.454738 -1.999593) + (end -53.426287 -1.680506) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "e20cf954-6958-4a6b-9f28-8932633e8e3a") + ) + (fp_line + (start -53.427001 -0.379238) + (end -53.45609 -0.048008) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "202137ac-99ce-493e-8d87-56c2b6046106") + ) + (fp_line + (start -53.426287 -1.680506) + (end -53.409233 -1.358863) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "47fb63b4-bc5a-4f24-abef-61e3ae3f60d9") + ) + (fp_line + (start -53.409533 -0.708166) + (end -53.427001 -0.379238) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8c8a3564-287e-4230-9f3c-bf1eb4164233") + ) + (fp_line + (start -53.409233 -1.358863) + (end -53.403629 -1.03473) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "32054463-8860-4ff6-a2d2-c97460239765") + ) + (fp_line + (start -53.403629 -1.03473) + (end -53.409533 -0.708166) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1d778a8e-e67c-414c-84f4-75983887d2c8") + ) + (fp_line + (start -53.300664 7.192203) + (end -52.930361 6.917093) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8d03f6bd-8e99-4d4c-b4ee-f5e3b6f9c9da") + ) + (fp_line + (start -53.291664 -7.99376) + (end -53.524075 -8.136297) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "62998b13-ecc8-4773-9759-aafd2c713d97") + ) + (fp_line + (start -53.046653 -7.827034) + (end -53.291664 -7.99376) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "a6840a02-26f1-426b-bec4-c3934b19874f") + ) + (fp_line + (start -52.930361 6.917093) + (end -52.544879 6.614399) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "448e69c3-e51a-4b25-83e2-59271146b1f7") + ) + (fp_line + (start -52.79094 -7.63884) + (end -53.046653 -7.827034) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "05ceb2b0-ea51-408e-bfc1-4face151f570") + ) + (fp_line + (start -52.544879 6.614399) + (end -52.14519 6.287047) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "6c2d1634-1c65-4805-b70a-8d2d33a7c868") + ) + (fp_line + (start -52.526422 -7.431898) + (end -52.79094 -7.63884) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "d2b47d15-d95f-47a5-91c4-4da2b75e6add") + ) + (fp_line + (start -52.254995 -7.208931) + (end -52.526422 -7.431898) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "e1b0e4e1-f85b-4460-b41b-3c022b36c77c") + ) + (fp_line + (start -52.14519 6.287047) + (end -51.732776 5.938693) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "55d7e906-d333-404b-8f32-1ebe52a7bb68") + ) + (fp_line + (start -51.978559 -6.972659) + (end -52.254995 -7.208931) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ddf6fb16-7e7b-48eb-95a6-30313aafed15") + ) + (fp_line + (start -51.732776 5.938693) + (end -51.311154 5.575872) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "907d2d35-741c-4bab-8ffe-04c5eced005d") + ) + (fp_line + (start -51.418241 -6.471086) + (end -51.978559 -6.972659) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7c201efb-00be-4f8f-beee-59ac97fb8bd8") + ) + (fp_line + (start -51.311154 5.575872) + (end -50.456383 4.835844) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "00466b17-5c63-4234-ae6c-90ca3280c0bb") + ) + (fp_line + (start -50.860647 -5.948949) + (end -51.418241 -6.471086) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "17a95bb4-f919-436d-903e-f542ad37825b") + ) + (fp_line + (start -50.456383 4.835844) + (end -50.031277 4.473143) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "bc3a35b8-f672-4f83-bf06-33ac0f471197") + ) + (fp_line + (start -50.320954 -5.428017) + (end -50.860647 -5.948949) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "f37dabbb-12a3-47e7-868d-bf05c6d8a748") + ) + (fp_line + (start -50.031277 4.473143) + (end -49.613055 4.124989) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "c54f3c7d-2f69-4487-936a-a85094bf0d48") + ) + (fp_line + (start -49.613055 4.124989) + (end -49.20574 3.798633) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "4a7a1600-ecde-4c5b-a468-cc9d47a61c72") + ) + (fp_line + (start -49.355985 -4.476844) + (end -50.320954 -5.428017) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "c5cbf27b-9cba-4e2f-8917-26cf76a836c6") + ) + (fp_line + (start -49.20574 3.798633) + (end -48.813354 3.501331) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "799c9211-1d4b-4688-a9df-9720a5bd07d8") + ) + (fp_line + (start -48.957123 -4.085295) + (end -49.355985 -4.476844) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "e7308ab2-e788-4083-900d-5e8b809a8c82") + ) + (fp_line + (start -48.813354 3.501331) + (end -48.623901 3.365643) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "0c7aeb98-47a7-4862-8788-e7f3bf108faa") + ) + (fp_line + (start -48.623901 3.365643) + (end -48.438993 3.238748) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "cc3d441b-a5d1-48dc-a42b-84755bcf7135") + ) + (fp_line + (start -48.613212 -3.752933) + (end -48.957123 -4.085295) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "80fd0bfb-561b-4969-a0cf-abd4810d490c") + ) + (fp_line + (start -48.438993 3.238748) + (end -48.25844 3.120361) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "e4e25f1f-05e5-4069-911e-f72c7f0d154f") + ) + (fp_line + (start -48.315763 -3.472427) + (end -48.613212 -3.752933) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "62512e72-f25c-4bd9-8a11-cb027357aeb5") + ) + (fp_line + (start -48.25844 3.120361) + (end -48.082047 3.010196) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8b5c735a-48d0-4f61-95ee-33d4d73b76fa") + ) + (fp_line + (start -48.082047 3.010196) + (end -47.909621 2.907966) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ead91d72-ef41-4da7-94bf-61eb1175c429") + ) + (fp_line + (start -48.056287 -3.236444) + (end -48.315763 -3.472427) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "98e756f2-a7bf-458e-943a-e65a465bd59f") + ) + (fp_line + (start -47.909621 2.907966) + (end -47.740971 2.813388) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "86912a98-f06c-447e-9494-1b05fc2f8563") + ) + (fp_line + (start -47.826296 -3.037654) + (end -48.056287 -3.236444) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "5ea9028d-ea20-4b6f-a2fe-55dca0d6dce3") + ) + (fp_line + (start -47.740971 2.813388) + (end -47.575902 2.726176) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "92c751a7-9f5c-430c-aaa4-5e337dfc3a41") + ) + (fp_line + (start -47.617302 -2.868723) + (end -47.826296 -3.037654) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "e04afcf9-88d3-41a7-83b5-baf0763dc1eb") + ) + (fp_line + (start -47.575902 2.726176) + (end -47.414223 2.646043) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "c7510881-8f97-450a-a78c-33739a761399") + ) + (fp_line + (start -47.420813 -2.722322) + (end -47.617302 -2.868723) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "08c643d7-4b32-4ac7-a7b8-37eaddb258e4") + ) + (fp_line + (start -47.414223 2.646043) + (end -47.255739 2.572705) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "3f130a48-7e3e-4d64-87b7-af83effe1efe") + ) + (fp_line + (start -47.255739 2.572705) + (end -47.10026 2.505875) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7d90e7e1-9dbd-4e67-b8be-bae9f5a0e5d8") + ) + (fp_line + (start -47.228344 -2.591119) + (end -47.420813 -2.722322) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "779899a3-0d4c-4341-a461-434a5a281db9") + ) + (fp_line + (start -47.131026 -2.529111) + (end -47.228344 -2.591119) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "f2060190-da30-4810-9600-dc3a2984895f") + ) + (fp_line + (start -47.10026 2.505875) + (end -46.947591 2.44527) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "3b360dee-17bf-4ba9-8a17-5f3a7f5c9649") + ) + (fp_line + (start -47.031908 -2.469268) + (end -47.131026 -2.529111) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1aca77e8-a5a4-497b-badf-a909474febd5") + ) + (fp_line + (start -46.947591 2.44527) + (end -46.797539 2.390603) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "d016e176-aa3c-4209-a497-c7d895156b79") + ) + (fp_line + (start -46.930307 -2.41179) + (end -47.031908 -2.469268) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "fe88ab8a-aa65-4215-8ec8-b6753b432d2a") + ) + (fp_line + (start -46.825538 -2.356875) + (end -46.930307 -2.41179) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "df36fe51-5f8b-42b1-b7c6-78043f027abd") + ) + (fp_line + (start -46.797539 2.390603) + (end -46.649912 2.341588) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "3331be76-8733-46a3-a1d3-43ad995736a2") + ) + (fp_line + (start -46.71692 -2.30472) + (end -46.825538 -2.356875) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "4b6a1933-7344-48bc-ad50-eca96a8f0946") + ) + (fp_line + (start -46.649912 2.341588) + (end -46.504517 2.29794) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "cd5f8446-3fe3-41cc-ade4-bad57ae85106") + ) + (fp_line + (start -46.603769 -2.255526) + (end -46.71692 -2.30472) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "f91cf827-cf0c-45d1-99f2-5178a38ead30") + ) + (fp_line + (start -46.504517 2.29794) + (end -46.361162 2.259374) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "e5411788-5392-4dbf-b2e4-14f6d3602d4c") + ) + (fp_line + (start -46.485402 -2.20949) + (end -46.603769 -2.255526) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "cefbe271-c86c-4add-bf42-4e274d5fe37e") + ) + (fp_line + (start -46.361162 2.259374) + (end -46.219653 2.225604) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "f9922a52-de26-45c2-b0bc-6d4b0d93f5f6") + ) + (fp_line + (start -46.361135 -2.166811) + (end -46.485402 -2.20949) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1896520c-c6f2-4631-a572-d7e842104910") + ) + (fp_line + (start -46.230285 -2.127688) + (end -46.361135 -2.166811) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "71ed2359-ceed-4730-b1d4-5ee55ddbb884") + ) + (fp_line + (start -46.219653 2.225604) + (end -45.939467 2.171925) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "5cbf4a95-72d5-42c8-ac3b-a979d2b5ec27") + ) + (fp_line + (start -46.092169 -2.092318) + (end -46.230285 -2.127688) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "810d7489-617c-47b5-9876-b44997389f16") + ) + (fp_line + (start -45.946105 -2.060901) + (end -46.092169 -2.092318) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "eb977c2d-1550-40ef-8983-c89b99fa620d") + ) + (fp_line + (start -45.939467 2.171925) + (end -45.797744 2.152289) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "726cf140-6291-4b36-9b01-263a6b94502d") + ) + (fp_line + (start -45.797744 2.152289) + (end -45.652741 2.137685) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "53913eb6-3697-49b9-94fe-31d4785f4350") + ) + (fp_line + (start -45.791408 -2.033636) + (end -45.946105 -2.060901) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "10f12189-b710-4128-9ffd-a42416f4c36e") + ) + (fp_line + (start -45.652741 2.137685) + (end -45.502811 2.128287) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "9eacb060-a3c9-4825-b5d1-ac1ab08699a2") + ) + (fp_line + (start -45.627397 -2.01072) + (end -45.791408 -2.033636) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1e00d448-44f9-4893-8fc4-9849c3fe575a") + ) + (fp_line + (start -45.502811 2.128287) + (end -45.346312 2.12427) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "170c3117-a97b-48d9-8e42-5009cb5ead5c") + ) + (fp_line + (start -45.453387 -1.992353) + (end -45.627397 -2.01072) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "854e7801-178a-441c-b920-611c08fb619a") + ) + (fp_line + (start -45.346312 2.12427) + (end -45.181596 2.125808) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "27fe3352-f901-42a2-a37e-bc33bfb03f51") + ) + (fp_line + (start -45.268695 -1.978733) + (end -45.453387 -1.992353) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ed62ab1a-56ea-4755-9af7-a4b7a4285583") + ) + (fp_line + (start -45.181596 2.125808) + (end -45.007019 2.133073) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1b01959a-8a52-43dd-8deb-e8d516f53a87") + ) + (fp_line + (start -45.072639 -1.97006) + (end -45.268695 -1.978733) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "def3d1cd-2493-4cef-b454-5a3997843494") + ) + (fp_line + (start -45.007019 2.133073) + (end -44.820938 2.14624) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "35ba0c84-b0d0-4845-a7f1-5d0d2551dbef") + ) + (fp_line + (start -44.820938 2.14624) + (end -44.621704 2.165483) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "3b77f077-2a81-4363-97f1-b16e2879c1a7") + ) + (fp_line + (start -44.646879 -1.967588) + (end -45.072639 -1.97006) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "6352029c-1d71-4f8d-99e3-04755c1bc0a9") + ) + (fp_line + (start -44.621704 2.165483) + (end -44.177203 2.222888) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "6f9c6eeb-987b-4545-9df9-14db4da26466") + ) + (fp_line + (start -44.186535 -1.982757) + (end -44.646879 -1.967588) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "46038bb7-e296-4b6f-8dd2-877eab7c41dc") + ) + (fp_line + (start -44.177203 2.222888) + (end -43.660356 2.306681) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "97917dd5-f678-4c66-9a24-0126b0389701") + ) + (fp_line + (start -43.705202 -2.01263) + (end -44.186535 -1.982757) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "23482336-7e44-4a15-94bc-eb6e18988bf7") + ) + (fp_line + (start -43.660356 2.306681) + (end -43.058004 2.418251) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "018567ee-8b04-473e-962a-61bbd16e73a5") + ) + (fp_line + (start -43.216479 -2.054269) + (end -43.705202 -2.01263) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "b01e58a2-57bb-4a0b-8c7e-c212502b4557") + ) + (fp_line + (start -43.058004 2.418251) + (end -41.575062 2.724236) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "89223289-fd43-45d3-bb54-8fcd4d01893b") + ) + (fp_line + (start -42.733964 -2.104735) + (end -43.216479 -2.054269) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "b9288226-8324-4b85-913c-57d10082910a") + ) + (fp_line + (start -42.271255 -2.161089) + (end -42.733964 -2.104735) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "36d91ac6-0d35-4a2f-8756-469543bd7861") + ) + (fp_line + (start -41.84195 -2.220396) + (end -42.271255 -2.161089) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ece8140e-3ffe-478b-becc-41e0b378d5ed") + ) + (fp_line + (start -41.575062 2.724236) + (end -39.77763 3.121756) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "3e608b4a-5d4e-4483-8f7b-ef0e51516e96") + ) + (fp_line + (start -41.459646 -2.279715) + (end -41.84195 -2.220396) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "34302f08-457f-44da-9c17-843ccbca59cf") + ) + (fp_line + (start -41.134796 -2.337176) + (end -41.459646 -2.279715) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "0dbed812-1aae-4643-bb22-2fad295bcb78") + ) + (fp_line + (start -40.993439 -2.365887) + (end -41.134796 -2.337176) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "bf6a8014-1bc6-4f3f-a3f0-d32ac111b181") + ) + (fp_line + (start -40.865245 -2.395161) + (end -40.993439 -2.365887) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "3faf8a4e-08f9-40c1-8fab-1aad6395deef") + ) + (fp_line + (start -40.749548 -2.425428) + (end -40.865245 -2.395161) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "56344b17-7a20-4a71-8b06-860c0515b79c") + ) + (fp_line + (start -40.645686 -2.457121) + (end -40.749548 -2.425428) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "4f2c7b15-2996-45bb-aaa9-dbdf7cff59bc") + ) + (fp_line + (start -40.552995 -2.490669) + (end -40.645686 -2.457121) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "f72079e4-5961-45b5-9091-9dec4e26070b") + ) + (fp_line + (start -40.470811 -2.526504) + (end -40.552995 -2.490669) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "133b7a43-a5a4-4585-b2b2-2ff634539adc") + ) + (fp_line + (start -40.39847 -2.565057) + (end -40.470811 -2.526504) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "24619975-12a2-49df-a4f9-ee70420a1c63") + ) + (fp_line + (start -40.33531 -2.60676) + (end -40.39847 -2.565057) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "c1d6ef8c-97b6-45e2-8f33-a8b99af31974") + ) + (fp_line + (start -40.280667 -2.652043) + (end -40.33531 -2.60676) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1623cd86-fe31-4ea7-8197-3a15cc276f04") + ) + (fp_line + (start -40.233876 -2.701338) + (end -40.280667 -2.652043) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "e0a66dc4-1b09-483b-a5b8-130db0c7a29d") + ) + (fp_line + (start -40.194276 -2.755075) + (end -40.233876 -2.701338) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "5f690001-17ac-45ed-9667-8a4bbdcaddb9") + ) + (fp_line + (start -40.161201 -2.813687) + (end -40.194276 -2.755075) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "052fc356-9cd9-47c5-ae6a-d5954dcbf6c9") + ) + (fp_line + (start -40.13399 -2.877604) + (end -40.161201 -2.813687) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1de03f37-5bfb-455a-bc3e-27c659ebd935") + ) + (fp_line + (start -40.111976 -2.947257) + (end -40.13399 -2.877604) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "cce0f357-afa1-417c-900f-0fad2c5442eb") + ) + (fp_line + (start -40.094475 -3.022815) + (end -40.111976 -2.947257) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7ea81ae4-4fd7-4fe9-adab-e7a9b00e2904") + ) + (fp_line + (start -40.080709 -3.103402) + (end -40.094475 -3.022815) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "c5af14ca-6cd8-4dea-8bb1-e56e7e4c6dc0") + ) + (fp_line + (start -40.069871 -3.187882) + (end -40.080709 -3.103402) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "0e62d970-eec5-4f5b-840b-7eec95454bf4") + ) + (fp_line + (start -40.061157 -3.275115) + (end -40.069871 -3.187882) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "15289ec8-1b46-4a3a-9a6e-bd2454b3fc46") + ) + (fp_line + (start -40.031472 -3.628838) + (end -40.061157 -3.275115) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "9801a07d-0a19-4c2f-8a28-a6e4b8289726") + ) + (fp_line + (start -40.021322 -3.712777) + (end -40.031472 -3.628838) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8450333d-48a3-4ff0-830a-238ab49908f1") + ) + (fp_line + (start -40.008472 -3.792646) + (end -40.021322 -3.712777) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "c46a60d4-cfa8-42c7-b182-23cfb4a2508e") + ) + (fp_line + (start -39.992118 -3.867304) + (end -40.008472 -3.792646) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "93595d8c-5526-4ba8-bfe5-d47eddb9a5f2") + ) + (fp_line + (start -39.971457 -3.935616) + (end -39.992118 -3.867304) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "325b447c-5157-436d-ae4a-4d1ce6ec568a") + ) + (fp_line + (start -39.945684 -3.996444) + (end -39.971457 -3.935616) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1ae0304d-4517-4e7f-b716-4ff76c222789") + ) + (fp_line + (start -39.930628 -4.023696) + (end -39.945684 -3.996444) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "62d35c0e-38f3-4d26-b678-786ef1d57dda") + ) + (fp_line + (start -39.913994 -4.04865) + (end -39.930628 -4.023696) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "323aad1e-6463-4b49-8cfd-12ef6126571a") + ) + (fp_line + (start -39.895679 -4.071163) + (end -39.913994 -4.04865) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "69a6e2b5-edfb-4123-ac3e-2275ccd370d9") + ) + (fp_line + (start -39.875584 -4.091095) + (end -39.895679 -4.071163) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "efdb7656-821c-40d8-99e4-0e00d6caadcd") + ) + (fp_line + (start -39.853607 -4.108304) + (end -39.875584 -4.091095) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "6685eeed-5346-4c45-9c6b-d52563c5aa4a") + ) + (fp_line + (start -39.829649 -4.122644) + (end -39.853607 -4.108304) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "e77a4d08-da0f-41fc-a7ae-86f3ae236fde") + ) + (fp_line + (start -39.803638 -4.134015) + (end -39.829649 -4.122644) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "f1129367-1b1d-40f8-a268-3b76870ae55c") + ) + (fp_line + (start -39.77763 3.121756) + (end -35.559873 4.09088) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "31222062-661c-4895-aaad-971ae93e7e4c") + ) + (fp_line + (start -39.775614 -4.142464) + (end -39.803638 -4.134015) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "9baa8410-7d8d-4fc1-8919-372fcf8114ba") + ) + (fp_line + (start -39.745648 -4.148079) + (end -39.775614 -4.142464) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7e888fa1-b038-456f-b06d-cd45b092ee56") + ) + (fp_line + (start -39.713809 -4.150947) + (end -39.745648 -4.148079) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "e105e235-9c91-40d0-8ed5-a8cbb4ed8333") + ) + (fp_line + (start -39.680169 -4.151155) + (end -39.713809 -4.150947) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "b675a834-9f81-4be2-98ab-148c8f65ecfd") + ) + (fp_line + (start -39.644796 -4.148793) + (end -39.680169 -4.151155) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "3f07d08d-52e6-4dbb-b811-3ac0d237ca41") + ) + (fp_line + (start -39.607761 -4.143945) + (end -39.644796 -4.148793) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "13ee8813-6e6f-45e7-a604-cb69bf99cf3e") + ) + (fp_line + (start -39.569133 -4.1367) + (end -39.607761 -4.143945) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "d7f5e01a-960c-4e52-940b-5513f6fa6edd") + ) + (fp_line + (start -39.528983 -4.127146) + (end -39.569133 -4.1367) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "a2be9695-ff88-460c-ad3c-0535d05c94a9") + ) + (fp_line + (start -39.48738 -4.115369) + (end -39.528983 -4.127146) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "3f1de9ba-a7f8-4dc2-b5dc-db97178ae551") + ) + (fp_line + (start -39.400096 -4.085501) + (end -39.48738 -4.115369) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "19dcdde1-af8c-464f-bcb5-56723262879c") + ) + (fp_line + (start -39.307842 -4.047793) + (end -39.400096 -4.085501) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ce89404c-a419-4e6d-bf90-fc4daa0b422c") + ) + (fp_line + (start -39.211176 -4.002946) + (end -39.307842 -4.047793) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "14b17517-fd93-4cf1-8318-ddc2115c9631") + ) + (fp_line + (start -39.110661 -3.951659) + (end -39.211176 -4.002946) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "26fba68f-8779-4bfe-92c9-52161c542c42") + ) + (fp_line + (start -39.006851 -3.894632) + (end -39.110661 -3.951659) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "bd561433-2c76-47ee-98f4-2d147e006532") + ) + (fp_line + (start -38.900311 -3.832565) + (end -39.006851 -3.894632) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "137ab9ed-a899-47ad-b39d-012c3a62b4c4") + ) + (fp_line + (start -38.791598 -3.766156) + (end -38.900311 -3.832565) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "a008cd7f-8550-4505-9594-829055e5c4d0") + ) + (fp_line + (start -38.681271 -3.696106) + (end -38.791598 -3.766156) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8755b267-1416-4ae8-99f6-734a363d1d39") + ) + (fp_line + (start -38.569892 -3.623115) + (end -38.681271 -3.696106) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "75f9537e-b11c-4f17-9382-35358686e15f") + ) + (fp_line + (start -38.346212 -3.471103) + (end -38.569892 -3.623115) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ed259bfb-12ad-4592-b790-d549d73768cd") + ) + (fp_line + (start -38.123384 -3.316013) + (end -38.346212 -3.471103) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "b91e2b83-a3e9-474f-bd99-b1048831cbd4") + ) + (fp_line + (start -38.011212 -3.239496) + (end -38.123384 -3.316013) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "c9d38c77-0b82-4020-94b7-0d4db555b748") + ) + (fp_line + (start -37.897629 -3.164888) + (end -38.011212 -3.239496) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "0e2b1c8b-91ec-4f2b-8110-003f4a045149") + ) + (fp_line + (start -37.781955 -3.093104) + (end -37.897629 -3.164888) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "13b3064c-5f84-4612-9f2e-050f8a976cd2") + ) + (fp_line + (start -37.663511 -3.025061) + (end -37.781955 -3.093104) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "249b9fcd-6fd3-4507-ac0f-f8fb97aa21f5") + ) + (fp_line + (start -37.541617 -2.961677) + (end -37.663511 -3.025061) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7ff4403f-5bb9-4289-9322-01974c030746") + ) + (fp_line + (start -37.415594 -2.903865) + (end -37.541617 -2.961677) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "518f428c-79ec-4fc7-ab84-69aaaaad5129") + ) + (fp_line + (start -37.284763 -2.852546) + (end -37.415594 -2.903865) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "a28877a4-715b-40ab-8e93-5edd9bb8b83a") + ) + (fp_line + (start -37.148443 -2.808635) + (end -37.284763 -2.852546) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "96f655e7-7f42-49e8-a922-437fea187f4c") + ) + (fp_line + (start -37.078012 -2.789743) + (end -37.148443 -2.808635) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "2ddd8396-bf73-4bd9-bd7c-0be89f90957f") + ) + (fp_line + (start -37.005956 -2.773048) + (end -37.078012 -2.789743) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "818621cb-2c50-4a4e-b323-10e852771e2c") + ) + (fp_line + (start -36.932187 -2.758662) + (end -37.005956 -2.773048) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7dc27be1-5494-4641-aa3d-a14e99c99e20") + ) + (fp_line + (start -36.856621 -2.7467) + (end -36.932187 -2.758662) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "5af093ac-689e-4f65-a2af-57607d0a8bcc") + ) + (fp_line + (start -36.779173 -2.737279) + (end -36.856621 -2.7467) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ae7bacb4-014c-48c8-8015-aa180c0eae1a") + ) + (fp_line + (start -36.69976 -2.730512) + (end -36.779173 -2.737279) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "a677cdb5-178c-4682-a7bf-c9305b967ad4") + ) + (fp_line + (start -36.618294 -2.726513) + (end -36.69976 -2.730512) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "97cfa97e-1234-482f-9aac-ec8b1f290136") + ) + (fp_line + (start -36.534693 -2.725398) + (end -36.618294 -2.726513) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "74383c39-9244-4e4d-ba76-f6354345a090") + ) + (fp_line + (start -36.44887 -2.72728) + (end -36.534693 -2.725398) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "87e7b661-97c7-4651-94c3-7935918d4b2c") + ) + (fp_line + (start -36.36074 -2.732274) + (end -36.44887 -2.72728) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "31a420e9-13b8-469f-8c96-e3e420e1fe19") + ) + (fp_line + (start -36.270219 -2.740495) + (end -36.36074 -2.732274) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "15a1bc59-b12a-4d40-8bee-66e37e73beb3") + ) + (fp_line + (start -36.177221 -2.752059) + (end -36.270219 -2.740495) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "234ae0fb-bf24-4027-aa9e-b7a0c6cfa734") + ) + (fp_line + (start -35.983747 -2.785309) + (end -36.177221 -2.752059) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "6b279185-6f38-4b81-ae36-ff1542bf527c") + ) + (fp_line + (start -35.781077 -2.831164) + (end -35.983747 -2.785309) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "931d47fa-c8c0-4ced-93f3-8c34f1138a8a") + ) + (fp_line + (start -35.57026 -2.888399) + (end -35.781077 -2.831164) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "d2a8650b-31c9-4951-908a-258ab891029b") + ) + (fp_line + (start -35.559873 4.09088) + (end -30.928687 5.143875) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "e4ee631f-7b5f-4aa5-bd14-16fa50550387") + ) + (fp_line + (start -35.352342 -2.955793) + (end -35.57026 -2.888399) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ff14944a-603a-41f3-b9c8-02c63cebfae9") + ) + (fp_line + (start -35.128375 -3.032124) + (end -35.352342 -2.955793) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "cbbbf027-3aed-43eb-b7d5-afe64aee56c8") + ) + (fp_line + (start -34.899402 -3.116169) + (end -35.128375 -3.032124) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "aeca58ae-57f6-459f-8629-4308ebc2d05d") + ) + (fp_line + (start -34.430639 -3.302517) + (end -34.899402 -3.116169) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "28c87bfa-bb85-4843-bd2f-e08a3a4270d5") + ) + (fp_line + (start -32.565034 -4.11212) + (end -34.430639 -3.302517) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "87c0954c-f8e8-48b3-b56a-b04a7a15e0ed") + ) + (fp_line + (start -31.555651 -13.79911) + (end -31.549825 -13.728514) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "d2e96342-0c26-4227-8953-309ff0a23a48") + ) + (fp_line + (start -31.550798 -13.86524) + (end -31.555651 -13.79911) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "4b3689b1-132d-4d47-af89-a4bfe4efbc00") + ) + (fp_line + (start -31.549825 -13.728514) + (end -31.533981 -13.652782) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "470ba89f-965c-48c8-902f-235b8b40253e") + ) + (fp_line + (start -31.544183 -13.896819) + (end -31.550798 -13.86524) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "2b7e7494-a1e4-4564-97a6-115d7a2b984e") + ) + (fp_line + (start -31.534765 -13.927405) + (end -31.544183 -13.896819) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "0784f020-9e51-48c1-a0f6-a21a617312c0") + ) + (fp_line + (start -31.533981 -13.652782) + (end -31.508773 -13.571244) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "cf408431-0d74-4f79-a756-446f1fc721a9") + ) + (fp_line + (start -31.522577 -13.956956) + (end -31.534765 -13.927405) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "050ed1cc-df4e-4b1e-b360-c6e6fc309ac4") + ) + (fp_line + (start -31.508773 -13.571244) + (end -31.474858 -13.483229) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7825e058-7348-4dc6-b3d4-f3ac8cc84a64") + ) + (fp_line + (start -31.50765 -13.985426) + (end -31.522577 -13.956956) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "b668a0aa-26d3-4389-8c9b-e261dd8de01f") + ) + (fp_line + (start -31.490016 -14.012774) + (end -31.50765 -13.985426) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "726ed8a9-a16a-4820-96bc-df4ef41de866") + ) + (fp_line + (start -31.474858 -13.483229) + (end -31.432892 -13.388065) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8ff1e5b2-1174-42ea-95f2-9c42e40cfbfd") + ) + (fp_line + (start -31.469706 -14.038956) + (end -31.490016 -14.012774) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "d4fbd148-ce37-4a28-baf6-b40dc5cb2cf8") + ) + (fp_line + (start -31.446754 -14.063929) + (end -31.469706 -14.038956) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "245dcc55-46f4-47bb-a64f-8f7f8c82c6b0") + ) + (fp_line + (start -31.432892 -13.388065) + (end -31.327437 -13.173617) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "f2ce0cd8-fa9b-4a02-8de4-a53df6714293") + ) + (fp_line + (start -31.421189 -14.087648) + (end -31.446754 -14.063929) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "32556faa-34ba-4fa4-bc53-8a2d809a953c") + ) + (fp_line + (start -31.393044 -14.11007) + (end -31.421189 -14.087648) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ee877da4-7981-4f2c-bb96-c95264926071") + ) + (fp_line + (start -31.362351 -14.131152) + (end -31.393044 -14.11007) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "281917fc-54ce-400e-adc2-56e0192624dc") + ) + (fp_line + (start -31.32914 -14.150851) + (end -31.362351 -14.131152) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "133fc68b-d07e-41bf-af79-bbff6c9ec6b0") + ) + (fp_line + (start -31.327437 -13.173617) + (end -31.048811 -12.629453) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "9129d7a0-027f-4115-a6d2-924ba6846eec") + ) + (fp_line + (start -31.293445 -14.169122) + (end -31.32914 -14.150851) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "276a1e9b-adf5-433a-9b56-b57b304b5e13") + ) + (fp_line + (start -31.255294 -14.185922) + (end -31.293445 -14.169122) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "4aa4cfd4-4c69-4149-ba50-4e4596ec2a36") + ) + (fp_line + (start -31.214723 -14.201209) + (end -31.255294 -14.185922) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "22b0b591-f15a-4b31-ae89-b4b764d4aedc") + ) + (fp_line + (start -31.171762 -14.214938) + (end -31.214723 -14.201209) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "44094635-ecb8-4b61-868a-5cf7bd10c104") + ) + (fp_line + (start -31.126442 -14.227065) + (end -31.171762 -14.214938) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "46abdfb6-f580-47ca-8aa2-007a20dddeec") + ) + (fp_line + (start -31.078795 -14.237549) + (end -31.126442 -14.227065) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "34709924-e99c-4361-a932-378628c1edff") + ) + (fp_line + (start -31.048811 -12.629453) + (end -30.886147 -12.28901) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "e10e3abd-ec1d-41e5-82da-4e2038da9318") + ) + (fp_line + (start -31.040347 -4.720701) + (end -32.565034 -4.11212) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "99583b06-d117-42e0-b9b1-4436d78aa3b7") + ) + (fp_line + (start -31.028853 -14.246345) + (end -31.078795 -14.237549) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "f4d36216-6b07-4ade-9af9-a6614f3ee5a2") + ) + (fp_line + (start -30.976647 -14.253409) + (end -31.028853 -14.246345) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "dee5c6f4-1add-4412-a319-c83a2e5cb7d6") + ) + (fp_line + (start -30.928687 5.143875) + (end -28.482478 5.667962) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1048b0d4-ef60-4255-adea-c8931acb250d") + ) + (fp_line + (start -30.922209 -14.258698) + (end -30.976647 -14.253409) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ab5e3821-057c-4541-b3da-fc04e33abe78") + ) + (fp_line + (start -30.886147 -12.28901) + (end -30.801274 -12.099353) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "29a9e3d1-92ca-4ced-93b2-f646f8fd66b5") + ) + (fp_line + (start -30.865571 -14.262169) + (end -30.922209 -14.258698) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "d9ad4b2e-a8cb-4a92-82ad-abeff591544d") + ) + (fp_line + (start -30.806765 -14.263779) + (end -30.865571 -14.262169) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8bbf9066-af56-4459-b1f9-28611d2d1c55") + ) + (fp_line + (start -30.801274 -12.099353) + (end -30.714916 -11.895844) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "bc7e7830-e6e7-4722-ab5b-8a25d33cd4d8") + ) + (fp_line + (start -30.745822 -14.263483) + (end -30.806765 -14.263779) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "5acd5c52-505e-41b9-bd58-ec9397405af2") + ) + (fp_line + (start -30.733392 -4.858634) + (end -31.040347 -4.720701) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "fec916bf-4453-41a8-b6d5-2abe8ee318c0") + ) + (fp_line + (start -30.714916 -11.895844) + (end -30.540178 -11.447687) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "b4321dc6-2872-4206-b462-21090f089e23") + ) + (fp_line + (start -30.682773 -14.261238) + (end -30.745822 -14.263483) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "3b528653-dae3-472d-8b8a-3a79e6373e88") + ) + (fp_line + (start -30.617652 -14.257001) + (end -30.682773 -14.261238) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1ca912f1-2bae-41f3-aa8c-a33867c4ec05") + ) + (fp_line + (start -30.591867 -4.929414) + (end -30.733392 -4.858634) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8d746d03-06b8-468f-9fa9-a365f791a8e5") + ) + (fp_line + (start -30.550488 -14.250727) + (end -30.617652 -14.257001) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "14db3ef4-0205-4de3-9e76-1c8329741f7b") + ) + (fp_line + (start -30.540178 -11.447687) + (end -30.366201 -10.954628) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "51b609dd-193f-4368-9496-37c320a248ac") + ) + (fp_line + (start -30.481314 -14.242375) + (end -30.550488 -14.250727) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "5d3f7f9f-f8b3-4eb1-ae16-bec3232da814") + ) + (fp_line + (start -30.458508 -5.002364) + (end -30.591867 -4.929414) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "19d1b168-d030-4995-bd03-67278618ab36") + ) + (fp_line + (start -30.410161 -14.231901) + (end -30.481314 -14.242375) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "92a9233c-2d81-4c52-96f0-10096204ee98") + ) + (fp_line + (start -30.366201 -10.954628) + (end -30.197053 -10.429838) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "272aa603-b35c-4a5d-9147-8ebdbe44380a") + ) + (fp_line + (start -30.337062 -14.21926) + (end -30.410161 -14.231901) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "2dc71416-05ba-4eca-885a-9ccaa8cd3733") + ) + (fp_line + (start -30.333468 -5.078198) + (end -30.458508 -5.002364) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1edd6fca-1eb7-4299-9373-f01a1407a5c1") + ) + (fp_line + (start -30.262047 -14.20441) + (end -30.337062 -14.21926) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1dc0ec53-db26-43df-9204-e22bfe4e449b") + ) + (fp_line + (start -30.216892 -5.157636) + (end -30.333468 -5.078198) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "6acf5232-5921-4b8d-9930-742cd8a3aca7") + ) + (fp_line + (start -30.197053 -10.429838) + (end -30.0368 -9.886487) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "5b807a26-ad07-4d66-a059-d36e257fa4c7") + ) + (fp_line + (start -30.18515 -14.187307) + (end -30.262047 -14.20441) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "3cc679f6-ae1a-472c-8895-4461b4e7a299") + ) + (fp_line + (start -30.108931 -5.241394) + (end -30.216892 -5.157636) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "01633f2d-c35f-4795-8027-6ebb8f220047") + ) + (fp_line + (start -30.106401 -14.167906) + (end -30.18515 -14.187307) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8b22660d-25b2-42cf-8cc4-7e92e3bee761") + ) + (fp_line + (start -30.0368 -9.886487) + (end -29.889511 -9.337746) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "14a3a7a6-6ef8-4f4d-8cbf-8e0ae1bd1aaf") + ) + (fp_line + (start -30.009734 -5.33019) + (end -30.108931 -5.241394) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "28b31c10-88ba-47eb-b6a4-b41956d226ab") + ) + (fp_line + (start -29.963463 -5.376696) + (end -30.009734 -5.33019) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "c1185343-7dcf-44d9-aa7d-535d717ab3ef") + ) + (fp_line + (start -29.94348 -14.122051) + (end -30.106401 -14.167906) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ce88f39e-668a-458b-b4be-df3b5af73696") + ) + (fp_line + (start -29.919409 -5.424687) + (end -29.963463 -5.376696) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "a726c700-72f7-4845-bccd-0e2fc94f73fd") + ) + (fp_line + (start -29.889511 -9.337746) + (end -29.759254 -8.796784) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "eef993bb-076a-4eff-89f3-c534754cd6a6") + ) + (fp_line + (start -29.877559 -5.474213) + (end -29.919409 -5.424687) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "83938096-a1de-48c8-ab3e-4346026e2f25") + ) + (fp_line + (start -29.837899 -5.525319) + (end -29.877559 -5.474213) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "dfd88f72-866e-4ff8-aed8-0c8d55922f65") + ) + (fp_line + (start -29.800419 -5.578056) + (end -29.837899 -5.525319) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "569ffd3a-d4cc-41d9-8320-e012517424aa") + ) + (fp_line + (start -29.773571 -14.066537) + (end -29.94348 -14.122051) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "75dc0b42-2e94-4321-8ab8-068c71f0ff0c") + ) + (fp_line + (start -29.765105 -5.632467) + (end -29.800419 -5.578056) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "e42030c6-49fc-47d8-a2aa-f39e8e272ecd") + ) + (fp_line + (start -29.759254 -8.796784) + (end -29.650094 -8.276774) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "c017cf71-c2f9-4476-b53b-9f37428bf034") + ) + (fp_line + (start -29.731944 -5.688602) + (end -29.765105 -5.632467) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ab1bc1f7-5d2b-498c-a5d7-c515ade35a64") + ) + (fp_line + (start -29.700924 -5.74651) + (end -29.731944 -5.688602) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "e93eb207-75d9-4576-b867-0ddfa9b57c60") + ) + (fp_line + (start -29.672033 -5.806234) + (end -29.700924 -5.74651) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ae06580c-b74a-4692-baa9-21bba02773ba") + ) + (fp_line + (start -29.650094 -8.276774) + (end -29.566101 -7.790883) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7084d103-aced-4111-ab3e-05d3a9f38db3") + ) + (fp_line + (start -29.645257 -5.867824) + (end -29.672033 -5.806234) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "bf090a1e-aef8-4a64-b99e-fe66e364126b") + ) + (fp_line + (start -29.620584 -5.931328) + (end -29.645257 -5.867824) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "a13626d3-4d41-4f24-9d2f-cd0fbc1aa592") + ) + (fp_line + (start -29.598004 -5.996794) + (end -29.620584 -5.931328) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "68214289-d637-4750-9c4c-e8a9b515e70b") + ) + (fp_line + (start -29.596967 -14.001066) + (end -29.773571 -14.066537) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "10988dc8-5fcf-4511-82cf-5d37b5fc35ad") + ) + (fp_line + (start -29.5775 -6.064267) + (end -29.598004 -5.996794) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "60e80393-ceb1-40c0-be70-8bb712b97eee") + ) + (fp_line + (start -29.566101 -7.790883) + (end -29.534747 -7.564514) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7753b7d6-d00c-4773-9342-d67a51925510") + ) + (fp_line + (start -29.559063 -6.133795) + (end -29.5775 -6.064267) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "51c65b54-90df-49c4-9271-027fe0e15eda") + ) + (fp_line + (start -29.534747 -7.564514) + (end -29.5108 -7.349591) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "e18933b9-f4af-46ec-96e2-fbc974e071e9") + ) + (fp_line + (start -29.528334 -6.279209) + (end -29.559063 -6.133795) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "0c27035f-5ee3-46c9-8620-f5bf39da776f") + ) + (fp_line + (start -29.5108 -7.349591) + (end -29.494363 -7.145737) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "f99aa4f3-a86e-4d34-a11c-7619e52a39fc") + ) + (fp_line + (start -29.505718 -6.433413) + (end -29.528334 -6.279209) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "482afcc6-043d-4097-9445-4600158af309") + ) + (fp_line + (start -29.494363 -7.145737) + (end -29.485536 -6.952573) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ae1c0669-b5aa-4f73-9be8-f793bf026860") + ) + (fp_line + (start -29.491113 -6.59679) + (end -29.505718 -6.433413) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "85790def-a4cd-413b-b8a6-7edaa6a04643") + ) + (fp_line + (start -29.485536 -6.952573) + (end -29.484419 -6.769716) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "61717a7f-2bf9-48ea-806e-a83ce7efa0cf") + ) + (fp_line + (start -29.484419 -6.769716) + (end -29.491113 -6.59679) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "b491bfa3-2264-4785-9566-d4bbb59bc3a1") + ) + (fp_line + (start -29.413959 -13.92534) + (end -29.596967 -14.001066) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "59b958c7-c503-4a3b-82c0-2aa0abadc561") + ) + (fp_line + (start -29.224837 -13.83906) + (end -29.413959 -13.92534) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "fc405793-b3c3-488b-9e4f-5aa3903ccda0") + ) + (fp_line + (start -29.029892 -13.741929) + (end -29.224837 -13.83906) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "55913305-a7e2-4925-8bf6-99a3579a6493") + ) + (fp_line + (start -28.829417 -13.633647) + (end -29.029892 -13.741929) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "e146dc11-7051-447e-beb5-d145a8d21908") + ) + (fp_line + (start -28.623702 -13.513919) + (end -28.829417 -13.633647) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "bdafa461-f098-4052-bbd1-6df5dd74bb8d") + ) + (fp_line + (start -28.482478 5.667962) + (end -25.938728 6.176253) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "f09ab4b3-61c6-4a7a-a04d-92635eb14808") + ) + (fp_line + (start -28.413037 -13.382442) + (end -28.623702 -13.513919) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "0b22a5ae-6fa9-4b5e-b1f3-ae20a2eace8f") + ) + (fp_line + (start -28.197717 -13.238923) + (end -28.413037 -13.382442) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "63250497-a63e-4596-a78e-85258ef1f2d4") + ) + (fp_line + (start -27.978029 -13.08306) + (end -28.197717 -13.238923) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "2381276e-8e48-4b17-a689-884dc13ede39") + ) + (fp_line + (start -27.754267 -12.914556) + (end -27.978029 -13.08306) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "5521baa5-e142-49df-b199-570977368a55") + ) + (fp_line + (start -27.526721 -12.733113) + (end -27.754267 -12.914556) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "da04d064-5f3a-4a2f-a07c-adf2fb59f102") + ) + (fp_line + (start -27.295683 -12.538433) + (end -27.526721 -12.733113) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "4871d9b3-ee5c-4132-b52f-b814fda51f47") + ) + (fp_line + (start -27.061444 -12.330217) + (end -27.295683 -12.538433) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "794735d8-ab2b-469d-9346-28c299c17138") + ) + (fp_line + (start -26.824295 -12.108168) + (end -27.061444 -12.330217) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "045f0e77-a542-4928-80e2-4d469e36265c") + ) + (fp_line + (start -26.584588 -11.872346) + (end -26.824295 -12.108168) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "12ce5be2-9435-4df1-be03-9cd0a4365040") + ) + (fp_line + (start -26.342901 -11.624241) + (end -26.584588 -11.872346) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "48dff8a8-0506-41f9-a5c0-d2fb5195fe2a") + ) + (fp_line + (start -25.856143 -11.098569) + (end -26.342901 -11.624241) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7552ba43-87e5-4906-81d0-12b5650ef782") + ) + (fp_line + (start -25.384406 6.595726) + (end -25.382877 6.637761) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "b5a5439a-40d8-44d6-9606-02d9c957f73a") + ) + (fp_line + (start -25.382877 6.637761) + (end -25.37822 6.679041) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "841edf7e-a039-41bb-88e3-08ceb10ccdbc") + ) + (fp_line + (start -25.382871 6.552956) + (end -25.384406 6.595726) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "9ce12b35-c364-4912-9d1e-973019ea390b") + ) + (fp_line + (start -25.378332 6.509473) + (end -25.382871 6.552956) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "85be37e3-c158-402e-bf0d-9f5429f21207") + ) + (fp_line + (start -25.37822 6.679041) + (end -25.37037 6.719544) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ce69f8b6-89c5-4e2e-b18e-fb021ea50078") + ) + (fp_line + (start -25.370855 6.4653) + (end -25.378332 6.509473) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "206797f2-ab44-4409-8d02-f9d1b6882b63") + ) + (fp_line + (start -25.37037 6.719544) + (end -25.344908 6.798068) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ee8f86c8-1c7f-4787-94a3-3aefbe575e2c") + ) + (fp_line + (start -25.369121 -10.545923) + (end -25.856143 -11.098569) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8d7b4ed8-6098-4c52-8e70-19545e7e8ca9") + ) + (fp_line + (start -25.360502 6.420459) + (end -25.370855 6.4653) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "be75b313-ca02-465b-8df2-d4b70ff969f1") + ) + (fp_line + (start -25.347338 6.37497) + (end -25.360502 6.420459) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "6094dd45-e67e-4d9d-9d45-6caefa0db62c") + ) + (fp_line + (start -25.344908 6.798068) + (end -25.30632 6.872856) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "704217be-f2b9-408a-86ca-91cfff662734") + ) + (fp_line + (start -25.331426 6.328857) + (end -25.347338 6.37497) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "4cfe9bea-63ab-43ff-9b60-57fa022db200") + ) + (fp_line + (start -25.312828 6.282141) + (end -25.331426 6.328857) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7d2ec941-8127-42c1-8a1d-2216f6760c92") + ) + (fp_line + (start -25.30632 6.872856) + (end -25.254498 6.943373) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "fa04e153-881c-4d19-b1b9-e727e2fde741") + ) + (fp_line + (start -25.291609 6.234844) + (end -25.312828 6.282141) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8220be06-a4cf-4d30-a32e-0fb953a729d5") + ) + (fp_line + (start -25.267831 6.186987) + (end -25.291609 6.234844) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "d46c0c4c-e56e-4e70-9b87-04bf329ec784") + ) + (fp_line + (start -25.254498 6.943373) + (end -25.189339 7.009083) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "574632c3-bb94-40f7-9554-3af44190c2e8") + ) + (fp_line + (start -25.212855 6.089683) + (end -25.267831 6.186987) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "dd84b79d-a8e0-4d5e-938f-b64b29cdd7bf") + ) + (fp_line + (start -25.189339 7.009083) + (end -25.110734 7.069448) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "89412dd4-67d8-4e32-9bea-753f8bcfe187") + ) + (fp_line + (start -25.148406 5.990405) + (end -25.212855 6.089683) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "3f870b5c-1233-4310-93ca-45cd359bf056") + ) + (fp_line + (start -25.110734 7.069448) + (end -25.018578 7.123931) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7f5979af-2716-4a52-a457-b14159656641") + ) + (fp_line + (start -25.07499 5.889326) + (end -25.148406 5.990405) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "2934a5fc-1504-440a-82f5-d749ad590375") + ) + (fp_line + (start -25.018578 7.123931) + (end -24.912767 7.171996) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "136e9854-830f-4b99-a3ed-288f77e0c13f") + ) + (fp_line + (start -24.993116 5.786622) + (end -25.07499 5.889326) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "a0b33aed-f6b1-4e3d-9d1b-e6c037e0c61f") + ) + (fp_line + (start -24.912767 7.171996) + (end -24.793194 7.213107) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "d0dd870e-a0a6-4f47-bb19-c1bdc0b082f9") + ) + (fp_line + (start -24.90329 5.682469) + (end -24.993116 5.786622) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "fb6b4d86-4f8c-4938-b624-b6dcd9c8a7b7") + ) + (fp_line + (start -24.88693 -9.981071) + (end -25.369121 -10.545923) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "5ae22048-0b38-41c2-9e80-00def1f63efd") + ) + (fp_line + (start -24.806021 5.577039) + (end -24.90329 5.682469) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1b882222-1dbc-4e59-ad58-faaa5d71807b") + ) + (fp_line + (start -24.793194 7.213107) + (end -24.659753 7.246726) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "0e675e93-95ff-4038-9adf-581fa45eaef0") + ) + (fp_line + (start -24.701812 5.47051) + (end -24.806021 5.577039) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "26f51224-bdb6-49f7-8d19-467e88bffd79") + ) + (fp_line + (start -24.659753 7.246726) + (end -24.512337 7.272316) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "b8827885-d9d3-462c-9bc8-d1f105bdedde") + ) + (fp_line + (start -24.591173 5.363055) + (end -24.701812 5.47051) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "4bf7b52b-4ebe-4c19-bcba-30a487299ce3") + ) + (fp_line + (start -24.512337 7.272316) + (end -24.350844 7.289343) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "fc1f41a4-e5a1-4448-9f66-24305c043901") + ) + (fp_line + (start -24.47461 5.254849) + (end -24.591173 5.363055) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "63f286ad-b584-4bf3-841d-039f62373600") + ) + (fp_line + (start -24.352631 5.146067) + (end -24.47461 5.254849) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "b767000d-c5cf-4ba3-88a8-41776949bcc1") + ) + (fp_line + (start -24.350844 7.289343) + (end -24.175164 7.297269) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "008508b6-cb8b-415b-8301-833655063df0") + ) + (fp_line + (start -24.175164 7.297269) + (end -23.985193 7.295556) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "a29668ce-16ba-4390-b2aa-3c06412f72b0") + ) + (fp_line + (start -24.094707 4.927181) + (end -24.352631 5.146067) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8adc3414-5d63-404f-8413-d9a7b808eb46") + ) + (fp_line + (start -23.985193 7.295556) + (end -23.780826 7.283668) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ec6da4db-6aa4-498c-bde1-621b65fc6054") + ) + (fp_line + (start -23.957437 -8.873829) + (end -24.88693 -9.981071) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "3302e484-c68c-4f86-813d-e36adfb27f9a") + ) + (fp_line + (start -23.822722 4.70631) + (end -24.094707 4.927181) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "20bca956-f673-448f-89d7-cf3c836ead68") + ) + (fp_line + (start -23.780826 7.283668) + (end -23.561956 7.26107) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "73762b6f-bef7-48aa-a4ba-fde3ae930f28") + ) + (fp_line + (start -23.561956 7.26107) + (end -23.328478 7.227223) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ff23f610-a69b-4c8a-a762-c5a8c3e27b88") + ) + (fp_line + (start -23.52033 -8.360979) + (end -23.957437 -8.873829) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "cffeeffe-7bbe-4fbb-ad23-b2ebd6bd6cde") + ) + (fp_line + (start -23.328478 7.227223) + (end -23.080575 7.181808) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "beb8fc20-3322-49d4-b384-86af11ed1c35") + ) + (fp_line + (start -23.258879 4.257073) + (end -23.822722 4.70631) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "36e8b989-c7ef-429d-bfc7-e89d4b5674ba") + ) + (fp_line + (start -23.108446 -7.895002) + (end -23.52033 -8.360979) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "9d0e19d4-9fd8-4dec-b567-ff6a792e7599") + ) + (fp_line + (start -23.080575 7.181808) + (end -22.819586 7.125367) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "63b7e153-35ff-4a78-95d5-996d83ba0e32") + ) + (fp_line + (start -22.978174 4.027936) + (end -23.258879 4.257073) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8ddb65ed-ef3c-4144-b428-e00cf62b0803") + ) + (fp_line + (start -22.913399 -7.683797) + (end -23.108446 -7.895002) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "15d5cfcb-4c38-41c6-b1b4-4cc589d63ebf") + ) + (fp_line + (start -22.819586 7.125367) + (end -22.547138 7.058658) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "82c0bb1f-fc76-4073-8938-4c3baf9da153") + ) + (fp_line + (start -22.725634 -7.487382) + (end -22.913399 -7.683797) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "839e4d60-cc41-44b0-8c23-71e2b107bbe1") + ) + (fp_line + (start -22.705714 3.795271) + (end -22.978174 4.027936) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "139181b7-5ea6-44a4-9fd5-ee44cdd07150") + ) + (fp_line + (start -22.574318 3.677496) + (end -22.705714 3.795271) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "4b75acab-9e12-4943-bd70-60003c9f3140") + ) + (fp_line + (start -22.547138 7.058658) + (end -22.264856 6.982438) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1763acfd-0545-4acd-a6fd-ae11809d675f") + ) + (fp_line + (start -22.544844 -7.305138) + (end -22.725634 -7.487382) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "b1a75aa1-3f0b-45dd-b3ec-7752f804b47c") + ) + (fp_line + (start -22.447075 3.558695) + (end -22.574318 3.677496) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7c4428a7-b7b9-4bc9-85d6-626ef60c42e0") + ) + (fp_line + (start -22.370731 -7.136441) + (end -22.544844 -7.305138) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "87b15bbe-5fe6-48f4-80b7-d03a2b40621c") + ) + (fp_line + (start -22.324681 3.438821) + (end -22.447075 3.558695) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1d9054d0-2666-4217-8b96-5fbb6dffeb9e") + ) + (fp_line + (start -22.264856 6.982438) + (end -21.677296 6.804503) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "83c50e2f-0ac0-4d0d-a745-3892cb672d1d") + ) + (fp_line + (start -22.207835 3.317823) + (end -22.324681 3.438821) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "9678c950-b0ff-431f-aba6-15083d734721") + ) + (fp_line + (start -22.202989 -6.980669) + (end -22.370731 -7.136441) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "da9b19fe-e0db-483c-9c52-efeb16f77dc1") + ) + (fp_line + (start -22.097051 3.195674) + (end -22.207835 3.317823) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "d4d71f97-98c4-4671-acfe-0a36c6830942") + ) + (fp_line + (start -22.041318 -6.837201) + (end -22.202989 -6.980669) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ee092155-7dd4-4ba4-b92c-138fe8879a1a") + ) + (fp_line + (start -21.992122 3.072428) + (end -22.097051 3.195674) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "cf6fca82-de25-4a41-aafc-1d74ef565a6c") + ) + (fp_line + (start -21.966816 6.868792) + (end -20.630921 7.062591) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "aaa67c9c-2f50-4c9c-9d7b-62bc8352a699") + ) + (fp_line + (start -21.892656 2.948159) + (end -21.992122 3.072428) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ca19286a-7ead-49fb-ba83-c1645c409edd") + ) + (fp_line + (start -21.885414 -6.705415) + (end -22.041318 -6.837201) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "878398bc-f9dc-4179-bb9e-889ebdb4b322") + ) + (fp_line + (start -21.798265 2.822937) + (end -21.892656 2.948159) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "36165888-0131-45ac-8656-a3cb1ba585b7") + ) + (fp_line + (start -21.734974 -6.584689) + (end -21.885414 -6.705415) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "b1566884-e708-4d85-bf0b-99e4a858b532") + ) + (fp_line + (start -21.708557 2.696839) + (end -21.798265 2.822937) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "3783380d-cde2-45c2-9b60-c39c9f56e361") + ) + (fp_line + (start -21.677296 6.804503) + (end -21.069916 6.597628) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ae6449a2-ec64-4812-9f38-6d76d798b98a") + ) + (fp_line + (start -21.623143 2.569934) + (end -21.708557 2.696839) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "a93fc178-56ec-4d87-ab28-54c2f2c75164") + ) + (fp_line + (start -21.589695 -6.474399) + (end -21.734974 -6.584689) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "85dc0e8a-c5ec-47f4-bc96-023e5beb9ef7") + ) + (fp_line + (start -21.541631 2.442298) + (end -21.623143 2.569934) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "c16dd71e-b7fc-48c8-bd20-8af7f445a341") + ) + (fp_line + (start -21.463632 2.314002) + (end -21.541631 2.442298) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "a835df25-b442-466f-8945-55cf07f56da4") + ) + (fp_line + (start -21.449277 -6.373926) + (end -21.589695 -6.474399) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "e85755ce-026e-4e13-9320-dfe15cf890fd") + ) + (fp_line + (start -21.316609 2.055727) + (end -21.463632 2.314002) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "678aeb9b-72e4-49d0-97c0-f5242c41e1bd") + ) + (fp_line + (start -21.313415 -6.282646) + (end -21.449277 -6.373926) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "5567b19d-6a4e-410c-a7d8-99e95d9e2c14") + ) + (fp_line + (start -21.181807 -6.199938) + (end -21.313415 -6.282646) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "304c95e4-0007-4637-a548-d03a2160e74a") + ) + (fp_line + (start -21.178952 1.795691) + (end -21.316609 2.055727) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "97f6ca1b-a6fe-42b3-abc9-15bd1fcc869a") + ) + (fp_line + (start -21.069916 6.597628) + (end -20.455725 6.36788) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "46c52b6e-2255-4e2e-ac29-d4c898f4cec9") + ) + (fp_line + (start -21.054151 -6.125179) + (end -21.181807 -6.199938) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "fddf5e36-f1cc-462e-8b07-29e55c5e2bf3") + ) + (fp_line + (start -21.047537 1.534479) + (end -21.178952 1.795691) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "b45f7293-971e-40dd-80c8-05c45eee4725") + ) + (fp_line + (start -20.930143 -6.057748) + (end -21.054151 -6.125179) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "4101f47b-4883-488e-b71e-c2b4ad3e4e3c") + ) + (fp_line + (start -20.919242 1.272675) + (end -21.047537 1.534479) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "593db6b7-1af5-4b90-b57e-538d56d54e57") + ) + (fp_line + (start -20.809482 -5.997022) + (end -20.930143 -6.057748) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "d4ff9d4f-a9a9-4dc2-870d-3978063dd3f7") + ) + (fp_line + (start -20.691864 -5.942381) + (end -20.809482 -5.997022) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "586a6e26-3647-416d-89b4-4d99916fe594") + ) + (fp_line + (start -20.630921 7.062591) + (end -19.303611 7.229361) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "3503e220-8b19-4121-a4be-3d3c64f41abc") + ) + (fp_line + (start -20.576897 -5.893243) + (end -20.691864 -5.942381) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "341ccf79-b3c9-4179-b0ad-1a86fafbc321") + ) + (fp_line + (start -20.463827 -5.849196) + (end -20.576897 -5.893243) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "be6f7052-82f8-4e68-b749-ac89c46569c1") + ) + (fp_line + (start -20.455725 6.36788) + (end -19.847734 6.121324) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "e6385bcf-cc8f-4292-9f6e-9e54306e3666") + ) + (fp_line + (start -20.351808 -5.809867) + (end -20.463827 -5.849196) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "9dd20efe-4c35-4170-8b1e-8d66c668024d") + ) + (fp_line + (start -20.239994 -5.774886) + (end -20.351808 -5.809867) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "b6de1a9c-08b4-46bc-a00e-197105c61eb2") + ) + (fp_line + (start -20.127542 -5.743881) + (end -20.239994 -5.774886) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "76652bea-55de-4d28-a02d-33f81fb6f450") + ) + (fp_line + (start -20.013604 -5.71648) + (end -20.127542 -5.743881) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8ba5b918-fc6f-4fea-b0a1-58fe2e095d5e") + ) + (fp_line + (start -19.897338 -5.69231) + (end -20.013604 -5.71648) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7c80ea41-5a2e-422f-9284-fff5f6fbbeb7") + ) + (fp_line + (start -19.847734 6.121324) + (end -19.258951 5.864027) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "063d5899-19ca-4e40-85ca-83801d12a137") + ) + (fp_line + (start -19.777894 -5.671001) + (end -19.897338 -5.69231) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "120d16ca-365d-4305-bf27-9f41b1da7934") + ) + (fp_line + (start -19.654431 -5.652181) + (end -19.777894 -5.671001) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "d51dfcf8-d8b3-4d6b-8e15-fa70874f51cf") + ) + (fp_line + (start -19.526101 -5.635478) + (end -19.654431 -5.652181) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "0b57c984-0856-4a71-aa6a-8192d0f75e38") + ) + (fp_line + (start -19.303611 7.229361) + (end -17.993614 7.363997) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "adf994d6-f540-4632-9bfa-bd16abdbf3d4") + ) + (fp_line + (start -19.258951 5.864027) + (end -18.702384 5.602056) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "59d3175b-4286-47e8-b112-27ba4cb34529") + ) + (fp_line + (start -19.251462 -5.606936) + (end -19.526101 -5.635478) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "18fe4df3-5c2b-47f3-b940-63894eba6af5") + ) + (fp_line + (start -18.947215 -5.582403) + (end -19.251462 -5.606936) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "6ecaa803-fe57-41d4-9ca5-5cd30019e6b1") + ) + (fp_line + (start -18.702384 5.602056) + (end -18.43986 5.471084) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "40db1550-06dd-41ea-a7a5-10adf105a5f4") + ) + (fp_line + (start -18.606596 -5.558902) + (end -18.947215 -5.582403) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "a1b74c4e-ad9f-407a-8752-e4f9a5cf3a92") + ) + (fp_line + (start -18.43986 5.471084) + (end -18.187939 5.340439) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ec8597cb-6a35-43d1-a48e-a6924c19a3d5") + ) + (fp_line + (start -18.187939 5.340439) + (end -17.945914 5.210098) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "f0843ed7-e153-4009-9ea9-c8f0d4abed9b") + ) + (fp_line + (start -17.993614 7.363997) + (end -16.70966 7.461395) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "cb5e4325-40c3-4e42-b55c-93e96ada0d95") + ) + (fp_line + (start -17.945914 5.210098) + (end -17.713077 5.08004) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "745f63ec-5522-4bb3-9f36-5ff57c610c0d") + ) + (fp_line + (start -17.790642 -5.504258) + (end -18.606596 -5.558902) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "70efa2d6-767b-4092-becc-219b7c854afc") + ) + (fp_line + (start -17.713077 5.08004) + (end -17.27214 4.820686) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "a8d80d48-8b46-4217-b717-a3505319baee") + ) + (fp_line + (start -17.27214 4.820686) + (end -16.859477 4.562201) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7da6da15-2512-44ef-be71-8970ab5d32a7") + ) + (fp_line + (start -16.859477 4.562201) + (end -16.469428 4.304412) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "4d6aee41-b273-4fce-b631-01a491175c32") + ) + (fp_line + (start -16.756642 -5.424952) + (end -17.790642 -5.504258) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1a408239-69a4-4296-81a2-aeb495c6c54e") + ) + (fp_line + (start -16.70966 7.461395) + (end -15.460477 7.51645) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "9074c856-f04e-4b9e-be49-c951ec1bb346") + ) + (fp_line + (start -16.469428 4.304412) + (end -16.096341 4.047142) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "a7788e7d-fff4-4509-91b0-5a5d63e2cd72") + ) + (fp_line + (start -16.143642 -5.370767) + (end -16.756642 -5.424952) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "07e38084-9e38-420e-b595-7bc620468300") + ) + (fp_line + (start -16.096341 4.047142) + (end -15.378426 3.533464) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "2a5f5539-cbc0-4218-a63e-f5f2a752ad4f") + ) + (fp_line + (start -15.460477 7.51645) + (end -14.851539 7.526647) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "50d4f9f6-009c-4a2d-8b3b-350c4c2c5849") + ) + (fp_line + (start -15.459047 -5.304079) + (end -16.143642 -5.370767) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "482995b7-59fd-4c2d-a1ef-94561192fbee") + ) + (fp_line + (start -14.851539 7.526647) + (end -14.253874 7.5252) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "559d2ceb-8b16-48b8-83e0-86c4095af383") + ) + (fp_line + (start -14.697166 -5.222771) + (end -15.459047 -5.304079) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "fc8e5354-fa0b-44f7-a4e2-bf4e599e7ef5") + ) + (fp_line + (start -14.253874 7.5252) + (end -13.667871 7.512325) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "84aec70f-3da8-44a1-8c35-16b6651ed112") + ) + (fp_line + (start -13.852303 -5.124731) + (end -14.697166 -5.222771) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "fd272323-3551-4dae-b391-3670c632cc0c") + ) + (fp_line + (start -13.667871 7.512325) + (end -13.09392 7.488241) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "67520d27-a8a4-459b-968a-727fbb0b05d9") + ) + (fp_line + (start -13.09392 7.488241) + (end -12.532413 7.453164) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "5c82855b-45e2-4821-819f-6f320dd4e347") + ) + (fp_line + (start -12.532413 7.453164) + (end -11.98374 7.407312) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "afb4e518-fe7e-4a99-8748-4afbfcc0f354") + ) + (fp_line + (start -11.98374 7.407312) + (end -11.448291 7.350902) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "fa8d563d-d5c2-4c5f-be25-e61a9e4b4897") + ) + (fp_line + (start -11.9285 -4.874222) + (end -13.852303 -5.124731) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "5f607e59-1c2e-47b5-a86d-910d57c0a535") + ) + (fp_line + (start -11.448291 7.350902) + (end -10.926454 7.284153) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "02f2a3e9-2dd5-4ec6-b100-79cfe21fffec") + ) + (fp_line + (start -10.926454 7.284153) + (end -10.418622 7.207282) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7465b461-dae2-4846-9e18-fdc855bc0c4d") + ) + (fp_line + (start -10.889867 -4.723315) + (end -11.9285 -4.874222) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1bc7e7c2-3478-44c1-874e-42da7e68fdf3") + ) + (fp_line + (start -10.418622 7.207282) + (end -9.925185 7.120505) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "120c7e83-4de9-4e78-845d-87fc69acc9a9") + ) + (fp_line + (start -9.925185 7.120505) + (end -9.446534 7.02404) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "9e9949f6-8d9f-432a-a0b3-a60ff1a8edb4") + ) + (fp_line + (start -9.830073 -4.5567) + (end -10.889867 -4.723315) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "770d5473-7c95-45d5-99a9-b154e63f271e") + ) + (fp_line + (start -9.446534 7.02404) + (end -8.983056 6.918105) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "710ed681-58c1-4661-a008-2ea3debc6aa7") + ) + (fp_line + (start -8.983056 6.918105) + (end -8.535144 6.802917) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "fda1b959-ee18-4143-946f-a09faf524069") + ) + (fp_line + (start -8.771613 -4.37542) + (end -9.830073 -4.5567) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "110c6a08-6340-42b8-8c6a-b85bd7dfb02f") + ) + (fp_line + (start -8.535144 6.802917) + (end -8.103187 6.678694) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "91eb57f9-2db0-40ac-a1ae-a2c1c2fc847c") + ) + (fp_line + (start -8.103187 6.678694) + (end -7.687578 6.545651) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7dbc8d0a-a240-4567-a46a-6910c4ffcc3b") + ) + (fp_line + (start -7.736985 -4.180521) + (end -8.771613 -4.37542) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "83fc8ff2-9169-4291-a90f-9135176d4eab") + ) + (fp_line + (start -7.687578 6.545651) + (end -7.288703 6.404009) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "04d1c37c-358d-4cca-9764-eaf79cc7de63") + ) + (fp_line + (start -7.288703 6.404009) + (end -6.906795 6.25409) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7379a7dd-9389-4b66-9f0d-6902dab279c9") + ) + (fp_line + (start -6.906795 6.25409) + (end -6.541435 6.096643) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "ceb5ea73-8bde-4fc9-91d8-c9219da3236d") + ) + (fp_line + (start -6.748684 -3.973048) + (end -7.736985 -4.180521) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "5f30cdbf-609b-44d9-aa0a-63125ae8d2cf") + ) + (fp_line + (start -6.541435 6.096643) + (end -6.192035 5.932524) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7175245b-1530-4946-ba88-1b5f649edd3d") + ) + (fp_line + (start -6.192035 5.932524) + (end -5.858011 5.762587) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "a7d8be38-109c-4188-a759-95e1b2478dae") + ) + (fp_line + (start -5.858011 5.762587) + (end -5.538777 5.587687) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "657b42c5-a444-4071-81d0-d58910ff6b63") + ) + (fp_line + (start -5.829205 -3.754043) + (end -6.748684 -3.973048) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "cedf5a0d-e969-4cf4-bd05-c699f1d09035") + ) + (fp_line + (start -5.538777 5.587687) + (end -5.233747 5.408678) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "82639c65-3e2d-4896-a087-1b119c659870") + ) + (fp_line + (start -5.401725 -3.640573) + (end -5.829205 -3.754043) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "56bc952d-801a-423f-adbc-0494b2667a5f") + ) + (fp_line + (start -5.233747 5.408678) + (end -4.942336 5.226415) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "67ee2553-2326-4474-ac52-653d4c0c48c3") + ) + (fp_line + (start -4.996398 -3.524787) + (end -5.401725 -3.640573) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "0aa2499c-d942-46bb-a76d-803131b45611") + ) + (fp_line + (start -4.942336 5.226415) + (end -4.663958 5.041754) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "b3870f0d-e7af-4111-9e57-8acba7072aad") + ) + (fp_line + (start -4.663958 5.041754) + (end -4.398028 4.855547) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "c502301c-85ff-41d6-96d6-4af24af700ce") + ) + (fp_line + (start -4.612543 -3.406987) + (end -4.996398 -3.524787) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "4d607729-64a3-489d-8ddc-1b002c115a76") + ) + (fp_line + (start -4.398028 4.855547) + (end -4.143959 4.668651) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "6ef0b07a-314f-486f-b746-b9a8e228c176") + ) + (fp_line + (start -4.249477 -3.287476) + (end -4.612543 -3.406987) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "be6c8015-a9ee-4c29-83ca-f869559203e8") + ) + (fp_line + (start -4.143959 4.668651) + (end -3.901166 4.48192) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8bce67c7-13ea-4ca1-97fc-69802676f328") + ) + (fp_line + (start -3.906517 -3.16656) + (end -4.249477 -3.287476) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "9ace4990-a13c-4113-b7ad-6921e151220d") + ) + (fp_line + (start -3.901166 4.48192) + (end -3.669064 4.296209) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8be22a5b-b313-418c-9bf4-9d3c2d4f05d6") + ) + (fp_line + (start -3.669064 4.296209) + (end -3.234589 3.931263) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "db2ca2e7-34d1-4fc6-a7b7-7ad3413363ee") + ) + (fp_line + (start -3.58298 -3.044541) + (end -3.906517 -3.16656) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "0dc55766-0225-450c-99e8-5143ca91e893") + ) + (fp_line + (start -3.234589 3.931263) + (end -2.835848 3.580654) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "d4ded607-05ce-4477-8f4f-30312298f640") + ) + (fp_line + (start -2.991447 -2.798405) + (end -3.58298 -3.044541) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "22fc1fd4-0c95-495a-9017-1e644aac802f") + ) + (fp_line + (start -2.835848 3.580654) + (end -2.468731 3.249825) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "a24d9729-e893-43af-93c3-49a30c7ff8e0") + ) + (fp_line + (start -2.469414 -2.551497) + (end -2.991447 -2.798405) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "bb75af66-7714-4774-b812-5b62f93ebb1d") + ) + (fp_line + (start -2.468731 3.249825) + (end -2.131402 2.938647) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "f6f77970-6473-43f0-b811-38b615600218") + ) + (fp_line + (start -2.131402 2.938647) + (end -1.822588 2.645589) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "2be1c155-2ee1-44b5-9e0f-ee7368fc405c") + ) + (fp_line + (start -2.011421 -2.306241) + (end -2.469414 -2.551497) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "d84ac002-5d9d-4c65-99fc-b003c1dcd6c6") + ) + (fp_line + (start -1.822588 2.645589) + (end -1.541018 2.36912) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "6d91b45e-5b0d-4d78-8e92-4583c0ad6b2d") + ) + (fp_line + (start -1.612009 -2.065066) + (end -2.011421 -2.306241) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "188fb4d8-4663-4515-b7d7-f35e48894bc6") + ) + (fp_line + (start -1.541018 2.36912) + (end -1.285421 2.10771) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "07eb2ed0-1096-4d22-9067-38d8960211a5") + ) + (fp_line + (start -1.285421 2.10771) + (end -1.054526 1.859829) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8f3e6632-43ad-4dbf-ad37-28560c93cb29") + ) + (fp_line + (start -1.265714 -1.830397) + (end -1.612009 -2.065066) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "6fc4c9a5-b5a2-4a4a-89c6-426466dcdfcb") + ) + (fp_line + (start -1.110841 -1.716192) + (end -1.265714 -1.830397) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7801419d-dbe5-4ed4-b3af-0afc4f085863") + ) + (fp_line + (start -1.054526 1.859829) + (end -0.84706 1.623948) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "36e50dad-8ebf-4f13-a6f4-0ef4743f5a1d") + ) + (fp_line + (start -0.967575 -1.604102) + (end -1.110841 -1.716192) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "279bd8ca-eaa4-4662-b3d8-5dd33341fe57") + ) + (fp_line + (start -0.84706 1.623948) + (end -0.751716 1.510029) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "c5ccdfc3-42b2-44c1-9278-52eb10ff5b1f") + ) + (fp_line + (start -0.835605 -1.494006) + (end -0.967575 -1.604102) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "e71038f4-fa51-4d35-bc84-ff0e7b8806e6") + ) + (fp_line + (start -0.751716 1.510029) + (end -0.661752 1.398535) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "77c8f002-94ff-4b48-8e1b-02e2b1c2817c") + ) + (fp_line + (start -0.714617 -1.385786) + (end -0.835605 -1.494006) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "6ee6ff68-1b8c-4e40-9897-b61da019c055") + ) + (fp_line + (start -0.661752 1.398535) + (end -0.577055 1.289283) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "2722834f-dfa8-4042-bf06-377206fd18e4") + ) + (fp_line + (start -0.604301 -1.279318) + (end -0.714617 -1.385786) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "3621f3aa-2646-435d-b2a4-a7aa94698393") + ) + (fp_line + (start -0.577055 1.289283) + (end -0.497688 1.182106) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "5c0938c7-263a-4ef1-82bf-8746db55e271") + ) + (fp_line + (start -0.504347 -1.174485) + (end -0.604301 -1.279318) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1a1ba6fd-ebbe-4096-a83b-7f029bbed2dc") + ) + (fp_line + (start -0.497688 1.182106) + (end -0.423758 1.076847) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "db5c3dcb-f705-4b2e-8dd2-4d232573ad8d") + ) + (fp_line + (start -0.423758 1.076847) + (end -0.355372 0.973344) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "814481a8-7c5f-40b9-abd0-94866c93f249") + ) + (fp_line + (start -0.414441 -1.071164) + (end -0.504347 -1.174485) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "8244ba27-f947-45d2-9a52-9788161f78ca") + ) + (fp_line + (start -0.355372 0.973344) + (end -0.292638 0.871442) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "6d22a9fd-1cb7-4c18-9889-1c100ce135b8") + ) + (fp_line + (start -0.334273 -0.969236) + (end -0.414441 -1.071164) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "7a3c1b86-3d8e-4138-b7b3-a7d1f886e7ff") + ) + (fp_line + (start -0.292638 0.871442) + (end -0.235662 0.770977) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "eec2f13d-b3f4-49ad-ba53-1279717779e6") + ) + (fp_line + (start -0.263533 -0.868579) + (end -0.334273 -0.969236) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "2c57d7e6-9239-40f1-be68-50b7f06a1416") + ) + (fp_line + (start -0.235662 0.770977) + (end -0.184551 0.671795) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "03bbf57e-03d8-4811-a118-6ca803b99d06") + ) + (fp_line + (start -0.201909 -0.769075) + (end -0.263533 -0.868579) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "6322b25e-f134-4ce9-8f03-ce0e683157f0") + ) + (fp_line + (start -0.184551 0.671795) + (end -0.139413 0.573733) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "54e65b7f-1573-4b43-a12a-0b5159288dc0") + ) + (fp_line + (start -0.149089 -0.670602) + (end -0.201909 -0.769075) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "20b78e35-6e9c-4da7-8dcf-8499b511e4f9") + ) + (fp_line + (start -0.139413 0.573733) + (end -0.100353 0.476634) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "02ef16ab-42e7-4dc8-817b-7b755ec7decd") + ) + (fp_line + (start -0.104763 -0.57304) + (end -0.149089 -0.670602) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "24e3d0a4-f3fb-4813-9520-dd8c0eb69dff") + ) + (fp_line + (start -0.100353 0.476634) + (end -0.067482 0.380337) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "1bcf3ea6-eadc-46de-83b4-9aec4ce24b58") + ) + (fp_line + (start -0.068619 -0.476267) + (end -0.104763 -0.57304) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "e37f0f3c-c6ed-4f80-b846-4497e2fd8f11") + ) + (fp_line + (start -0.067482 0.380337) + (end -0.040902 0.284685) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "114b5161-043f-497d-9ea2-ecf98476b78d") + ) + (fp_line + (start -0.040902 0.284685) + (end -0.020725 0.189516) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "34190f9b-2d50-40cc-83ec-ef3cbe6e1423") + ) + (fp_line + (start -0.040345 -0.380166) + (end -0.068619 -0.476267) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "9622fc91-01dc-472d-975e-4f92b4daf903") + ) + (fp_line + (start -0.020725 0.189516) + (end -0.007055 0.094674) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "5568dcca-7cd1-4732-bce5-7217610e8159") + ) + (fp_line + (start -0.019629 -0.284613) + (end -0.040345 -0.380166) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "c516968f-7b70-4e26-b511-53dc2ccdd5a6") + ) + (fp_line + (start -0.007055 0.094674) + (end 0 0) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "0c1aeb9b-8336-4959-884f-0b8b20ebbe42") + ) + (fp_line + (start -0.006163 -0.18949) + (end -0.019629 -0.284613) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "78e0e622-d477-4a8a-8a36-eb19d48931e8") + ) + (fp_line + (start 0 0) + (end 0.000333 -0.09467) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "590047b4-0252-46f8-828d-e1cbb912b4a8") + ) + (fp_line + (start 0.000333 -0.09467) + (end -0.006163 -0.18949) + (stroke + (width 0.12) + (type default) + ) + (layer "F.SilkS") + (uuid "d22243d6-0147-46ad-9e7e-6a6d27412efe") + ) + (fp_circle + (center -8.186388 2.155) + (end -8.296388 2.21) + (stroke + (width 0.1) + (type default) + ) + (fill no) + (layer "F.SilkS") + (uuid "d182c82b-8cb3-4876-a37c-62f15b164e13") + ) + (fp_poly + (pts + (xy -27.636659 3.781217) (xy -27.930187 3.797349) (xy -28.204311 3.820619) (xy -28.461003 3.850078) + (xy -28.702233 3.884782) (xy -28.929976 3.923786) (xy -29.146202 3.966145) (xy -29.551994 4.057147) + (xy -30.31216 4.237818) (xy -30.502205 4.277444) (xy -30.691781 4.314356) (xy -31.058493 4.382204) + (xy -31.390231 4.445707) (xy -31.536089 4.477185) (xy -31.66493 4.509206) (xy -31.773994 4.542312) + (xy -31.820247 4.559441) (xy -31.860523 4.577045) (xy -31.894475 4.595191) (xy -31.921759 4.613948) + (xy -31.942031 4.633384) (xy -31.954945 4.653566) (xy -31.960157 4.674563) (xy -31.957322 4.696441) + (xy -31.946096 4.719268) (xy -31.926132 4.743114) (xy -31.897087 4.768045) (xy -31.858617 4.79413) + (xy -31.810374 4.821435) (xy -31.752017 4.850029) (xy -31.416454 4.977516) (xy -30.926958 5.124263) + (xy -30.296956 5.287845) (xy -29.539879 5.465837) (xy -28.669155 5.655815) (xy -27.698215 5.855351) + (xy -25.509401 6.273405) (xy -25.25474 6.319452) (xy -25.251501 6.310773) (xy -25.248378 6.302156) + (xy -25.24517 6.29352) (xy -25.24347 6.289167) (xy -25.241671 6.284779) (xy -25.231402 6.261142) + (xy -25.2205 6.237303) (xy -25.214809 6.225327) (xy -25.208958 6.213326) (xy -25.202946 6.201306) + (xy -25.19677 6.189276) (xy -25.190424 6.177234) (xy -25.183912 6.165166) (xy -25.170411 6.140939) + (xy -25.156304 6.116581) (xy -25.141626 6.09208) (xy -25.134064 6.079789) (xy -25.126329 6.067494) + (xy -25.110381 6.042859) (xy -25.093855 6.018107) (xy -25.076825 5.993168) (xy -25.059308 5.968048) + (xy -25.041251 5.942798) (xy -25.02265 5.917437) (xy -25.003499 5.89199) (xy -24.983809 5.866434) + (xy -24.963601 5.840742) (xy -24.942879 5.814954) (xy -24.921649 5.789107) (xy -24.89992 5.763216) + (xy -24.877703 5.737262) (xy -24.855005 5.711223) (xy -24.831834 5.685079) (xy -24.808202 5.658783) + (xy -24.784126 5.632357) (xy -24.759603 5.605858) (xy -24.734627 5.579347) (xy -24.683355 5.526247) + (xy -24.630407 5.472941) (xy -24.575851 5.419405) (xy -24.519757 5.36561) (xy -24.462242 5.311567) + (xy -24.403378 5.257329) (xy -24.34316 5.202946) (xy -24.28158 5.148467) (xy -24.218699 5.093917) + (xy -24.154649 5.039267) (xy -24.089548 4.984505) (xy -24.023507 4.929619) (xy -23.956565 4.874651) + (xy -23.888777 4.819612) (xy -23.751224 4.709061) (xy -23.187331 4.259425) (xy -23.161192 4.238194) + (xy -23.135252 4.216839) (xy -23.109343 4.195459) (xy -23.083304 4.174153) (xy -23.083297 4.174151) + (xy -23.955184 4.055577) (xy -24.776221 3.951021) (xy -25.537232 3.866227) (xy -25.892363 3.833038) + (xy -26.229049 3.806942) (xy -26.61992 3.785081) (xy -26.983496 3.774137) (xy -27.321752 3.773163) + ) + (stroke + (width 0.12) + (type solid) + ) + (fill yes) + (layer "F.SilkS") + (uuid "63d52148-22d2-422e-8221-a778984f51e7") + ) + (fp_poly + (pts + (xy -8.10601 1.757261) (xy -8.180109 1.763809) (xy -8.251629 1.774459) (xy -8.320194 1.788991) (xy -8.38543 1.80719) + (xy -8.446961 1.828838) (xy -8.504412 1.853716) (xy -8.557409 1.88161) (xy -8.605575 1.9123) (xy -8.648536 1.94557) + (xy -8.685918 1.981203) (xy -8.702398 1.999837) (xy -8.717344 2.01898) (xy -8.730705 2.038606) (xy -8.742439 2.058687) + (xy -8.752495 2.079194) (xy -8.760828 2.100103) (xy -8.767391 2.121386) (xy -8.772137 2.143014) (xy -8.775019 2.164961) + (xy -8.77599 2.187201) (xy -8.775019 2.209441) (xy -8.772137 2.231388) (xy -8.767391 2.253016) (xy -8.760828 2.274299) + (xy -8.752495 2.295208) (xy -8.742439 2.315715) (xy -8.730705 2.335796) (xy -8.717344 2.355422) (xy -8.702398 2.374565) + (xy -8.685918 2.393199) (xy -8.667948 2.411297) (xy -8.648536 2.428833) (xy -8.62773 2.445776) (xy -8.605575 2.462102) + (xy -8.58212 2.477784) (xy -8.557409 2.492792) (xy -8.531491 2.507102) (xy -8.504412 2.520686) (xy -8.47622 2.533515) + (xy -8.446961 2.545565) (xy -8.416682 2.556805) (xy -8.38543 2.567211) (xy -8.353251 2.576756) (xy -8.320194 2.58541) + (xy -8.286304 2.593148) (xy -8.251629 2.599943) (xy -8.216214 2.605766) (xy -8.180109 2.610592) (xy -8.143358 2.614393) + (xy -8.10601 2.617142) (xy -8.06811 2.61881) (xy -8.029707 2.619372) (xy -7.953404 2.617142) (xy -7.879304 2.610592) + (xy -7.807786 2.599943) (xy -7.739219 2.58541) (xy -7.673984 2.567211) (xy -7.612453 2.545565) (xy -7.555001 2.520686) + (xy -7.502005 2.492792) (xy -7.453839 2.462102) (xy -7.410878 2.428833) (xy -7.373497 2.393199) (xy -7.357015 2.374565) + (xy -7.342071 2.355422) (xy -7.328708 2.335796) (xy -7.316975 2.315715) (xy -7.306919 2.295208) (xy -7.298586 2.274299) + (xy -7.292023 2.253016) (xy -7.287278 2.231388) (xy -7.284396 2.209441) (xy -7.283424 2.187201) (xy -7.284396 2.164961) + (xy -7.287278 2.143014) (xy -7.292023 2.121386) (xy -7.298586 2.100103) (xy -7.306919 2.079194) (xy -7.316975 2.058687) + (xy -7.328708 2.038606) (xy -7.342071 2.01898) (xy -7.357015 1.999837) (xy -7.373497 1.981203) (xy -7.391466 1.963105) + (xy -7.410878 1.94557) (xy -7.431685 1.928626) (xy -7.453839 1.9123) (xy -7.477295 1.896618) (xy -7.502005 1.88161) + (xy -7.527924 1.8673) (xy -7.555001 1.853716) (xy -7.583194 1.840887) (xy -7.612453 1.828838) (xy -7.642732 1.817597) + (xy -7.673984 1.80719) (xy -7.706162 1.797646) (xy -7.739219 1.788991) (xy -7.773109 1.781254) (xy -7.807786 1.774459) + (xy -7.843199 1.768636) (xy -7.879304 1.763809) (xy -7.916055 1.760008) (xy -7.953404 1.757261) (xy -7.991303 1.755592) + (xy -8.029707 1.755029) + ) + (stroke + (width 0.12) + (type solid) + ) + (fill no) + (layer "F.SilkS") + (uuid "e36da28a-1120-409d-9925-eeaa18cc4b65") + ) + (fp_poly + (pts + (xy -1.971388 2.54) (xy -2.0021 2.542246) (xy -2.036893 2.546718) (xy -2.075851 2.55345) (xy -2.119053 2.562474) + (xy -2.166582 2.57382) (xy -2.218517 2.587523) (xy -2.274942 2.603614) (xy -2.650987 2.727994) (xy -3.146378 2.907647) + (xy -4.455247 3.378765) (xy -5.248748 3.643228) (xy -6.12164 3.90896) (xy -7.063936 4.162459) (xy -7.557989 4.280402) + (xy -8.065648 4.390224) (xy -9.112729 4.580286) (xy -10.203517 4.73172) (xy -11.332731 4.844758) + (xy -12.495093 4.919632) (xy -13.685325 4.956575) (xy -14.898148 4.955819) (xy -16.128283 4.917595) + (xy -17.370451 4.842135) (xy -17.551317 4.950055) (xy -17.643553 5.004056) (xy -17.737664 5.058143) + (xy -17.853091 5.123193) (xy -17.970725 5.188315) (xy -18.09061 5.253363) (xy -18.212882 5.318487) + (xy -18.33751 5.38382) (xy -18.4647 5.44923) (xy -18.59464 5.514557) (xy -18.727319 5.57997) (xy -18.862718 5.645631) + (xy -19.00074 5.71128) (xy -19.141172 5.776749) (xy -19.283824 5.842023) (xy -19.428441 5.907019) + (xy -19.574865 5.971626) (xy -19.723096 6.035866) (xy -19.872729 6.099525) (xy -20.023435 6.162437) + (xy -20.175137 6.224583) (xy -20.327469 6.285882) (xy -20.480392 6.346227) (xy -20.633779 6.405348) + (xy -20.78735 6.463328) (xy -20.941225 6.52027) (xy -21.094877 6.57588) (xy -21.247817 6.629791) + (xy -21.400129 6.682177) (xy -21.551568 6.733337) (xy -21.626895 6.758321) (xy -21.70197 6.782791) + (xy -21.765884 6.803144) (xy -21.829531 6.822992) (xy -21.956063 6.861804) (xy -20.3253 7.089436) + (xy -19.505136 7.189791) (xy -18.686084 7.27909) (xy -17.871369 7.355771) (xy -17.064216 7.418271) + (xy -16.267854 7.465027) (xy -15.485504 7.494479) (xy -14.876564 7.504676) (xy -14.278894 7.503228) + (xy -13.692886 7.490353) (xy -13.118927 7.466268) (xy -12.55741 7.431191) (xy -12.008725 7.38534) + (xy -11.473264 7.328931) (xy -10.951415 7.262182) (xy -10.443571 7.185311) (xy -9.950122 7.098534) + (xy -9.47146 7.002069) (xy -9.007972 6.896135) (xy -8.560052 6.780946) (xy -8.12809 6.656723) (xy -7.712476 6.523682) + (xy -7.3136 6.38204) (xy -7.11468 6.305759) (xy -6.920309 6.22739) (xy -6.7304 6.147068) (xy -6.544868 6.06493) + (xy -6.363623 5.981111) (xy -6.18658 5.89575) (xy -6.013651 5.808982) (xy -5.84475 5.720944) (xy -5.848904 5.722312) + (xy -5.853024 5.723611) (xy -5.861168 5.72605) (xy -5.87715 5.730608) (xy -5.884979 5.732796) (xy -5.892675 5.734843) + (xy -5.900282 5.736761) (xy -5.907847 5.738565) (xy -5.915438 5.740288) (xy -5.923044 5.74193) (xy -5.930584 5.743454) + (xy -5.937974 5.744818) (xy -5.945182 5.746) (xy -5.952277 5.747029) (xy -5.959325 5.747947) (xy -5.966395 5.748799) + (xy -5.97352 5.74963) (xy -5.980656 5.750422) (xy -5.987768 5.751113) (xy -5.991303 5.7514) (xy -5.994817 5.751639) + (xy -6.0018 5.752045) (xy -6.008752 5.752393) (xy -6.015701 5.752649) (xy -6.022671 5.752776) (xy -6.029632 5.75277) + (xy -6.036563 5.752661) (xy -6.043512 5.752466) (xy -6.050525 5.752208) (xy -6.057675 5.751891) (xy -6.064943 5.751506) + (xy -6.072251 5.751045) (xy -6.079516 5.750501) (xy -6.086707 5.749888) (xy -6.093891 5.749213) (xy -6.101136 5.748473) + (xy -6.108506 5.747661) (xy -6.116037 5.746763) (xy -6.123692 5.745786) (xy -6.139202 5.743681) (xy -6.147017 5.742512) + (xy -6.154913 5.741221) (xy -6.162914 5.73988) (xy -6.171035 5.738565) (xy -6.204639 5.733165) (xy -6.240385 5.727197) + (xy -6.278767 5.720803) (xy -6.319966 5.714123) (xy -6.341695 5.710731) (xy -6.364203 5.70735) (xy -6.411485 5.700479) + (xy -6.461799 5.693376) (xy -6.514941 5.686269) (xy -6.570481 5.679118) (xy -6.599197 5.675544) (xy -6.62863 5.672058) + (xy -6.689678 5.665429) (xy -6.753118 5.658984) (xy -6.818539 5.652592) (xy -6.886133 5.646479) (xy -6.920841 5.643592) + (xy -6.956051 5.640793) (xy -6.991625 5.638185) (xy -7.027674 5.635678) (xy -7.064115 5.633064) (xy -7.101004 5.630561) + (xy -7.138595 5.628227) (xy -7.176607 5.626014) (xy -7.214779 5.623957) (xy -7.253346 5.622035) (xy -7.292385 5.620257) + (xy -7.33179 5.618625) (xy -7.37143 5.617133) (xy -7.411372 5.615782) (xy -7.451914 5.614588) (xy -7.492659 5.613507) + (xy -7.574118 5.611647) (xy -7.655801 5.610099) (xy -7.976402 5.604413) (xy -8.053359 5.60285) (xy -8.128175 5.601003) + (xy -8.164613 5.599918) (xy -8.200367 5.598729) (xy -8.235434 5.597659) (xy -8.252685 5.597113) (xy -8.269717 5.596454) + (xy -8.303127 5.594827) (xy -8.335656 5.593045) (xy -8.367126 5.591146) (xy -8.397617 5.589064) (xy -8.427145 5.586895) + (xy -8.441499 5.58575) (xy -8.455596 5.584518) (xy -8.469496 5.58319) (xy -8.483187 5.581792) (xy -8.496582 5.580335) + (xy -8.5096 5.578832) (xy -8.522182 5.577242) (xy -8.534381 5.575541) (xy -8.557916 5.572012) (xy -8.569329 5.570241) + (xy -8.580444 5.568428) (xy -8.591239 5.566561) (xy -8.601686 5.564622) (xy -8.611824 5.562587) (xy -8.621677 5.560463) + (xy -8.631197 5.558287) (xy -8.64034 5.556095) (xy -8.644745 5.554985) (xy -8.649037 5.553848) (xy -8.657394 5.551549) + (xy -8.665524 5.549299) (xy -8.669467 5.548167) (xy -8.67331 5.547) (xy -8.68059 5.544749) (xy -8.684076 5.543635) + (xy -8.685801 5.543057) (xy -8.687522 5.542454) (xy -8.690919 5.541199) (xy -8.694235 5.539917) (xy -8.697462 5.538625) + (xy -8.700595 5.537337) (xy -8.706743 5.534799) (xy -8.708242 5.534164) (xy -8.709713 5.533524) (xy -8.711145 5.532877) + (xy -8.712532 5.532222) (xy -8.713205 5.531887) (xy -8.713862 5.531545) (xy -8.715133 5.530845) (xy -8.716357 5.530127) + (xy -8.717546 5.529399) (xy -8.719869 5.527944) (xy -8.721026 5.527231) (xy -8.722196 5.526538) (xy -8.723382 5.525873) + (xy -8.724572 5.525235) (xy -8.726928 5.523999) (xy -8.728076 5.523382) (xy -8.729193 5.522753) (xy -8.730268 5.522103) + (xy -8.730786 5.521766) (xy -8.731292 5.521421) (xy -8.731782 5.52107) (xy -8.732259 5.520718) (xy -8.733174 5.520013) + (xy -8.734047 5.519307) (xy -8.734889 5.518597) (xy -8.735706 5.517886) (xy -8.73651 5.517171) (xy -8.738112 5.515737) + (xy -8.738932 5.514998) (xy -8.739767 5.514226) (xy -8.740603 5.513433) (xy -8.741428 5.512628) (xy -8.74223 5.51182) + (xy -8.742995 5.51102) (xy -8.743711 5.510238) (xy -8.744365 5.509485) (xy -8.744964 5.508758) (xy -8.745523 5.508049) + (xy -8.746049 5.507352) (xy -8.746546 5.506658) (xy -8.747019 5.505963) (xy -8.747474 5.505259) (xy -8.747914 5.504539) + (xy -8.748345 5.503799) (xy -8.748768 5.503037) (xy -8.749182 5.502262) (xy -8.749581 5.501478) (xy -8.74996 5.500688) + (xy -8.750315 5.499896) (xy -8.750641 5.499106) (xy -8.750933 5.498322) (xy -8.751064 5.497933) (xy -8.751186 5.497547) + (xy -8.751294 5.497162) (xy -8.751385 5.496774) (xy -8.751461 5.496387) (xy -8.751524 5.495998) (xy -8.751575 5.495608) + (xy -8.751614 5.495218) (xy -8.751668 5.494436) (xy -8.751755 5.491294) (xy -8.751954 5.488181) (xy -8.751972 5.487403) + (xy -8.751967 5.487013) (xy -8.751953 5.486621) (xy -8.751925 5.486229) (xy -8.751884 5.485834) (xy -8.751828 5.485438) + (xy -8.751755 5.48504) (xy -8.751668 5.484642) (xy -8.751572 5.484249) (xy -8.751467 5.483858) (xy -8.751352 5.48347) + (xy -8.751102 5.482698) (xy -8.75082 5.481928) (xy -8.750514 5.481157) (xy -8.750186 5.480379) (xy -8.74948 5.478787) + (xy -8.749092 5.477963) (xy -8.748662 5.477117) (xy -8.748194 5.476257) (xy -8.747696 5.475389) (xy -8.747172 5.47452) + (xy -8.746628 5.473656) (xy -8.746069 5.472802) (xy -8.745501 5.471967) (xy -8.744352 5.470286) (xy -8.743761 5.469429) + (xy -8.743151 5.468567) (xy -8.742514 5.467704) (xy -8.741846 5.466842) (xy -8.741497 5.466414) (xy -8.741139 5.465989) + (xy -8.740768 5.465565) (xy -8.740386 5.465146) (xy -8.73999 5.464732) (xy -8.739581 5.464329) (xy -8.73916 5.463934) + (xy -8.738728 5.463546) (xy -8.737831 5.462782) (xy -8.736902 5.462029) (xy -8.73497 5.460508) (xy -8.733984 5.459719) + (xy -8.732996 5.458894) (xy -8.731003 5.457196) (xy -8.729985 5.456345) (xy -8.728944 5.455491) (xy -8.727878 5.454638) + (xy -8.726781 5.453782) (xy -8.725645 5.452926) (xy -8.724469 5.45207) (xy -8.722052 5.450366) (xy -8.719569 5.448669) + (xy -8.71829 5.44782) (xy -8.716977 5.446969) (xy -8.715629 5.446112) (xy -8.714238 5.445249) (xy -8.708202 5.441563) + (xy -8.706607 5.440613) (xy -8.704991 5.439672) (xy -8.703364 5.438752) (xy -8.701732 5.437861) (xy -8.69846 5.436142) + (xy -8.69513 5.434457) (xy -8.691692 5.432768) (xy -8.688089 5.431039) (xy -8.686216 5.430169) (xy -8.684299 5.429316) + (xy -8.680354 5.427634) (xy -8.672173 5.424218) (xy -8.663587 5.420528) (xy -8.659112 5.418652) (xy -8.65684 5.417731) + (xy -8.654552 5.416826) (xy -8.645115 5.413138) (xy -8.640223 5.411266) (xy -8.635224 5.409438) (xy -8.632689 5.408558) + (xy -8.63013 5.407702) (xy -8.624937 5.406031) (xy -8.614192 5.402617) (xy -8.603056 5.398924) (xy -8.597334 5.397059) + (xy -8.591454 5.395227) (xy -8.579235 5.391656) (xy -8.566503 5.388126) (xy -8.539727 5.381017) (xy -8.511322 5.373623) + (xy -8.496468 5.369898) (xy -8.481177 5.366236) (xy -8.465457 5.362658) (xy -8.449321 5.359119) (xy -8.415807 5.352025) + (xy -8.380781 5.3449) (xy -8.344182 5.337816) (xy -8.305989 5.330681) (xy -8.286341 5.327122) (xy -8.266306 5.323602) + (xy -8.245837 5.32015) (xy -8.224945 5.316746) (xy -8.182177 5.309961) (xy -8.138216 5.303094) (xy -8.092932 5.296319) + (xy -8.046371 5.289729) (xy -7.998572 5.283245) (xy -7.949694 5.276931) (xy -7.899662 5.27074) (xy -7.848469 5.264417) + (xy -7.796206 5.258233) (xy -7.742697 5.252471) (xy -7.688202 5.246863) (xy -7.632947 5.241379) (xy -7.576789 5.236064) + (xy -7.519786 5.230855) (xy -7.461963 5.225832) (xy -7.403213 5.221183) (xy -7.343727 5.216736) (xy -7.283798 5.212078) + (xy -7.253615 5.209781) (xy -7.223218 5.207642) (xy -7.161827 5.203829) (xy -7.099866 5.200252) (xy -7.037557 5.196722) + (xy -6.974809 5.193432) (xy -6.911558 5.190472) (xy -6.848048 5.187746) (xy -6.784423 5.185361) (xy -6.720717 5.1832) + (xy -6.657003 5.181101) (xy -6.593386 5.179219) (xy -6.529867 5.177411) (xy -6.466624 5.17581) (xy -6.403869 5.174574) + (xy -6.341567 5.173535) (xy -6.279859 5.172873) (xy -6.218784 5.172398) (xy -6.158124 5.171741) (xy -6.098274 5.171261) + (xy -6.039515 5.171175) (xy -5.981744 5.171261) (xy -5.92517 5.171466) (xy -5.86976 5.17183) (xy -5.815656 5.172323) + (xy -5.762894 5.172966) (xy -5.711258 5.173748) (xy -5.661143 5.174672) (xy -5.612829 5.175742) (xy -5.566213 5.176947) + (xy -5.521505 5.178305) (xy -5.478673 5.179787) (xy -5.43757 5.181435) (xy -5.398524 5.1832) (xy -5.361595 5.184851) + (xy -5.343941 5.185683) (xy -5.326901 5.186608) (xy -5.310525 5.187671) (xy -5.294784 5.188827) (xy -5.26494 5.191157) + (xy -5.237137 5.193366) (xy -5.224049 5.194505) (xy -5.211506 5.195703) (xy -5.1995 5.196939) (xy -5.188017 5.198187) + (xy -5.177052 5.199473) (xy -5.1666 5.20082) (xy -5.161558 5.201534) (xy -5.156633 5.202286) (xy -5.14714 5.203863) + (xy -5.138139 5.205482) (xy -5.129651 5.207073) (xy -5.125621 5.207799) (xy -5.12174 5.208471) (xy -5.117976 5.209154) + (xy -5.116131 5.209521) (xy -5.114302 5.209916) (xy -5.110721 5.210749) (xy -5.107251 5.211598) (xy -5.103898 5.212458) + (xy -5.10066 5.213325) (xy -5.099081 5.21378) (xy -5.09752 5.214265) (xy -5.095981 5.214772) (xy -5.094467 5.215291) + (xy -5.088723 5.217305) (xy -5.087365 5.217751) (xy -5.086019 5.218173) (xy -5.083389 5.218984) (xy -5.082112 5.21939) + (xy -5.080868 5.219808) (xy -5.079659 5.220246) (xy -5.078491 5.220715) (xy -5.077374 5.221202) (xy -5.076308 5.221692) + (xy -5.075288 5.222184) (xy -5.0743 5.222679) (xy -5.07334 5.223176) (xy -5.072398 5.223677) (xy -5.070533 5.224695) + (xy -5.069605 5.225224) (xy -5.06869 5.225781) (xy -5.067792 5.226355) (xy -5.066917 5.226941) (xy -5.066066 5.22753) + (xy -5.065247 5.228115) (xy -5.063712 5.229241) (xy -5.062993 5.229765) (xy -5.062292 5.230259) (xy -5.061611 5.230734) + (xy -5.060955 5.231202) (xy -5.060322 5.231674) (xy -5.060016 5.231914) (xy -5.059717 5.232161) (xy -5.059426 5.232412) + (xy -5.059141 5.232672) (xy -5.058865 5.232942) (xy -5.058596 5.233222) (xy -5.058336 5.233512) (xy -5.058081 5.233813) + (xy -5.057835 5.234122) (xy -5.057594 5.234438) (xy -5.057361 5.23476) (xy -5.057133 5.235087) (xy -5.056698 5.235749) + (xy -5.056286 5.236414) (xy -5.055897 5.237074) (xy -5.055185 5.238337) (xy -5.054872 5.238924) (xy -5.05473 5.239208) + (xy -5.054598 5.239488) (xy -5.054473 5.239763) (xy -5.054357 5.240035) (xy -5.054248 5.240307) (xy -5.054146 5.240579) + (xy -5.053958 5.241126) (xy -5.053787 5.241687) (xy -5.05363 5.24227) (xy -5.05348 5.242886) (xy -5.053338 5.243542) + (xy -5.053212 5.244236) (xy -5.053104 5.244957) (xy -5.053015 5.245694) (xy -5.052949 5.246434) (xy -5.052908 5.247167) + (xy -5.052895 5.247883) (xy -5.052899 5.24823) (xy -5.052911 5.248569) (xy -5.052932 5.248899) (xy -5.052963 5.249224) + (xy -5.053002 5.249542) (xy -5.053048 5.249856) (xy -5.053103 5.250168) (xy -5.053163 5.250477) (xy -5.053305 5.251093) + (xy -5.053469 5.251713) (xy -5.053651 5.252347) (xy -5.054049 5.253686) (xy -5.054263 5.254387) (xy -5.054495 5.255088) + (xy -5.054746 5.255789) (xy -5.055017 5.256493) (xy -5.055308 5.257201) (xy -5.055622 5.257916) (xy -5.05596 5.258638) + (xy -5.056323 5.25937) (xy -5.057866 5.26246) (xy -5.058287 5.263256) (xy -5.058736 5.264052) (xy -5.059216 5.264842) + (xy -5.05947 5.265234) (xy -5.059733 5.265623) (xy -5.05987 5.265824) (xy -5.060009 5.266035) (xy -5.060291 5.266473) + (xy -5.06058 5.266912) (xy -5.060725 5.267124) (xy -5.06087 5.267328) (xy -4.896656 5.162645) (xy -4.737021 5.057582) + (xy -4.581875 4.952335) (xy -4.431129 4.847102) (xy -4.142473 4.637464) (xy -3.870338 4.43024) (xy -3.614004 4.227001) + (xy -3.372753 4.029323) (xy -2.932627 3.656935) (xy -2.657355 3.420099) (xy -2.530998 3.310005) (xy -2.413184 3.205888) + (xy -2.304679 3.108073) (xy -2.206249 3.016878) (xy -2.11866 2.932627) (xy -2.042679 2.855642) (xy -2.009281 2.819975) + (xy -1.979073 2.786246) (xy -1.952149 2.754493) (xy -1.928606 2.724758) (xy -1.908541 2.69708) (xy -1.892047 2.6715) + (xy -1.879221 2.648059) (xy -1.87016 2.626797) (xy -1.86496 2.607753) (xy -1.863714 2.590968) (xy -1.864605 2.583435) + (xy -1.866521 2.576482) (xy -1.869473 2.570114) (xy -1.873475 2.564336) (xy -1.878536 2.559153) (xy -1.884671 2.554569) + (xy -1.891891 2.55059) (xy -1.900207 2.547222) (xy -1.920177 2.542336) (xy -1.944678 2.539949) (xy -1.957538 2.539703) + ) + (stroke + (width 0.12) + (type solid) + ) + (fill yes) + (layer "F.SilkS") + (uuid "ae1bad8b-7c47-48a8-8af5-1e6d79f71488") + ) + (fp_text user "${REFERENCE}" + (at -12 -0.25 0) + (unlocked yes) + (layer "F.Fab") + (hide yes) + (uuid "6cf5e634-0bb3-4775-90e4-6ef6696d8f55") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (dimension + (type aligned) + (layer "User.2") + (uuid "5a6ff977-53c6-4f36-9f80-a0b8f1c6699c") + (pts + (xy 0 0) (xy -56 0) + ) + (height 15.25) + (format + (prefix "") + (suffix "") + (units 3) + (units_format 1) + (precision 4) + ) + (style + (thickness 0.1) + (arrow_length 1.27) + (text_position_mode 0) + (arrow_direction outward) + (extension_height 0.58642) + (extension_offset 0.5) + (keep_text_aligned yes) + ) + (gr_text "56.0000 mm" + (at -28 -16.4 0) + (layer "User.2") + (uuid "5a6ff977-53c6-4f36-9f80-a0b8f1c6699c") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + ) + (dimension + (type leader) + (layer "User.2") + (uuid "0ef799ac-5237-47c6-af33-b39d7edf1fea") + (pts + (xy -25.369121 -10.545923) (xy -19.5 -12.5) + ) + (format + (prefix "") + (suffix "") + (units 0) + (units_format 0) + (precision 4) + (override_value "Antenna") + ) + (style + (thickness 0.1) + (arrow_length 1.27) + (text_position_mode 0) + (text_frame 0) + (extension_offset 0.5) + ) + (gr_text "Antenna" + (at -14.5 -12.5 0) + (layer "User.2") + (uuid "0ef799ac-5237-47c6-af33-b39d7edf1fea") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + ) + (dimension + (type leader) + (layer "User.2") + (uuid "430bd48d-5f4f-404d-ab84-873bf8d3af80") + (pts + (xy -51.5 -6) (xy -47.25 -8.25) + ) + (format + (prefix "") + (suffix "") + (units 0) + (units_format 0) + (precision 4) + (override_value "Flosse") + ) + (style + (thickness 0.1) + (arrow_length 1.27) + (text_position_mode 0) + (text_frame 0) + (extension_offset 0.5) + ) + (gr_text "Flosse" + (at -42.25 -8.25 0) + (layer "User.2") + (uuid "430bd48d-5f4f-404d-ab84-873bf8d3af80") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + ) + (dimension + (type leader) + (layer "User.2") + (uuid "4d861637-9ea5-4bf9-99cf-016362f0a69b") + (pts + (xy -6.25 5.5) (xy 1 7.25) + ) + (format + (prefix "") + (suffix "") + (units 0) + (units_format 0) + (precision 4) + (override_value "Teethies") + ) + (style + (thickness 0.1) + (arrow_length 1.27) + (text_position_mode 0) + (text_frame 0) + (extension_offset 0.5) + ) + (gr_text "Teethies" + (at 6 7.25 0) + (layer "User.2") + (uuid "4d861637-9ea5-4bf9-99cf-016362f0a69b") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + ) + (dimension + (type leader) + (layer "User.2") + (uuid "9800137c-8da3-4742-b1a6-12d8bcd3dc03") + (pts + (xy 0 0) (xy 2.25 -4) + ) + (format + (prefix "") + (suffix "") + (units 0) + (units_format 0) + (precision 4) + (override_value "Boopsnoot") + ) + (style + (thickness 0.1) + (arrow_length 1.27) + (text_position_mode 0) + (text_frame 0) + (extension_offset 0.5) + ) + (gr_text "Boopsnoot" + (at 8.25 -4 0) + (layer "User.2") + (uuid "9800137c-8da3-4742-b1a6-12d8bcd3dc03") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + ) + (embedded_fonts no) + (model "${KICAD9_3DMODEL_DIR}/Symbol.3dshapes/Smolhaj_Scale_0.1.step" + (offset + (xyz 0 0 0) + ) + (scale + (xyz 1 1 1) + ) + (rotate + (xyz 0 0 0) + ) + ) +)