├── .gitignore
├── LICENSE
├── README.md
├── book.toml
└── src
    ├── SUMMARY.md
    ├── built-in-constants.md
    ├── built-in-defer.md
    ├── built-in-make-and-new.md
    ├── built-in-panic.md
    ├── built-in-recover.md
    ├── built-in.md
    ├── bytes-buffers.md
    ├── bytes-compare.md
    ├── bytes-index.md
    ├── bytes-intro.md
    ├── context-details.md
    ├── context-intro.md
    ├── cover.md
    ├── errors-As-Is.md
    ├── errors-great-again.md
    ├── errors-intro.md
    ├── errors-unwrap.md
    ├── favicon.png
    ├── img
        └── cover.svg
    ├── io-intro.md
    ├── io-pipe-in-depth.md
    ├── io-reader-and-writer.md
    ├── notes-about-godocs.md
    ├── preface.md
    ├── sync-cond.md
    ├── sync-do.md
    ├── sync-intro.md
    ├── sync-mutex.md
    ├── sync-pool.md
    └── sync-waitgroup.md


/.gitignore:
--------------------------------------------------------------------------------
1 | book
2 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | This is free and unencumbered software released into the public domain.
 2 | 
 3 | Anyone is free to copy, modify, publish, use, compile, sell, or
 4 | distribute this software, either in source code form or as a compiled
 5 | binary, for any purpose, commercial or non-commercial, and by any
 6 | means.
 7 | 
 8 | In jurisdictions that recognize copyright laws, the author or authors
 9 | of this software dedicate any and all copyright interest in the
10 | software to the public domain. We make this dedication for the benefit
11 | of the public at large and to the detriment of our heirs and
12 | successors. We intend this dedication to be an overt act of
13 | relinquishment in perpetuity of all present and future rights to this
14 | software under copyright law.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 | OTHER DEALINGS IN THE SOFTWARE.
23 | 
24 | For more information, please refer to <https://unlicense.org>
25 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Spaceship Go
 2 | 
 3 | ![](./controllers_brief.svg)
 4 | <img src="./src/img/cover.svg">
 5 | 
 6 | To view the book, click [here](https://blasrodri.github.io/spaceship-go-gh-pages/)
 7 | 
 8 | ## Notes from the author
 9 | 
10 | This is a set of notes I gathered on my way to understanding how things worked
11 | in Go. The Standard Library is one of the best places to find answers. Especially
12 | for Go, since it comes with _batteries included_. And its source code is
13 | wonderfully documented.
14 | 
15 | There is official documentation, which I made extensive usage of. And some
16 | blog posts from the Go team that helped me build my understanding. But no
17 | matter how good these resources are, it can be difficult for a non-expert
18 | developer to try to find some answers there. And this is what this book is
19 | about: it serves as a bridge between these learners, and some amazing
20 | resources that perhaps look a bit intimidating.
21 | 
22 | I expect that there will be errors and things that could be better explained. For
23 | that is that I have made this repository public. I intend to use it as an
24 | exchange of ideas and suggestions. PRs and issues are more than welcome. And
25 | they will be included in the book as soon as they're merged to master.
26 | 
27 | Writing is challenging. But I found it enormously helpful, as an exercise towards
28 | building a deeper understanding of how things work. If one can explain something,
29 | it means that one understands it. And this is the purpose of these notes. I hope
30 | I've learned, and I also hope you too!
31 | 
32 | ## Building
33 | 
34 | To build the book:
35 | 
36 | 1. [Install `mdbook`](https://rust-lang.github.io/mdBook/guide/installation.html)
37 | 2. Clone the repository (`git clone https://github.com/blasrodri/spaceship-go.git`)
38 | 3. Run `mdbook`
39 | 
40 | To optionally build the epub file format, install `mdbook-epub`:
41 | 
42 | ```
43 | cargo install mdbook-epub --version 0.4.14-alpha.0
44 | # Then run mdbook
45 | mdbook
46 | ```
47 | 
48 | Output will be saved as `book/Spaceship Go.epub`.
49 | 


--------------------------------------------------------------------------------
/book.toml:
--------------------------------------------------------------------------------
 1 | [book]
 2 | authors = ["Blas Rodriguez Irizar"]
 3 | language = "en"
 4 | multilingual = false
 5 | src = "src"
 6 | title = "Spaceship Go"
 7 | 
 8 | [output.epub]
 9 | cover-image = "img/cover.svg"
10 | additional-resources = ["img/cover.svg"]
11 | optional = true
12 | 


--------------------------------------------------------------------------------
/src/SUMMARY.md:
--------------------------------------------------------------------------------
 1 | # Summary
 2 | 
 3 | - [Cover](./cover.md)
 4 | - [Preface](./preface.md)
 5 | - [Notes About Go Docs](./notes-about-godocs.md)
 6 | - [Built in](./built-in.md)
 7 |   - [Constants](./built-in-constants.md)
 8 |   - [make and new](./built-in-make-and-new.md)
 9 |   - [defer](./built-in-defer.md)
10 |   - [panic](./built-in-panic.md)
11 |   - [recover](./built-in-recover.md)
12 | - [Bytes](./bytes-intro.md)
13 |   - [Compare](./bytes-compare.md)
14 |   - [Index](./bytes-index.md)
15 |   - [Buffers](./bytes-buffers.md)
16 | - [Context](./context-intro.md)
17 |   - [In detail](./context-details.md)
18 | - [Errors](./errors-intro.md)
19 |   - [As and Is](./errors-As-Is.md)
20 |   - [Unwrap](./errors-unwrap.md)
21 |   - [Making error great again](./errors-great-again.md)
22 | - [Sync](./sync-intro.md)
23 |   - [Cond](./sync-cond.md)
24 |   - [Mutex](./sync-mutex.md)
25 |   - [Do](./sync-do.md)
26 |   - [Pool](./sync-pool.md)
27 |   - [WaitGroup](./sync-waitgroup.md)
28 | - [IO](./io-intro.md)
29 |   - [Reader and Writer](./io-reader-and-writer.md)
30 |   - [Pipe in depth](./io-pipe-in-depth.md)
31 | 


--------------------------------------------------------------------------------
/src/built-in-constants.md:
--------------------------------------------------------------------------------
 1 | ## Constants
 2 | 
 3 | Booleans true and false are defined here. And in a very smart and concise way:
 4 | ```go
 5 | const (
 6 |     true = 0 == 0 // this is always true!
 7 |     false = 0 != 0 // this is always false!
 8 | )
 9 | ```
10 | Iota (view https://github.com/golang/go/wiki/Iota and https://golang.org/ref/spec#Iota)
11 | represents successive untyped integer constants.
12 | ```go
13 | const iota = 0 // Untyped int.
14 | ```
15 | These two examples, describe how iota can be useful:
16 | ```go
17 | const (
18 | 	c0 = iota  // c0 == 0
19 | 	c1 = iota  // c1 == 1
20 | 	c2 = iota  // c2 == 2
21 | )
22 | 
23 | const (
24 | 	a = 1 << iota  // a == 1  (iota == 0)
25 | 	b = 1 << iota  // b == 2  (iota == 1)
26 | 	c = 3          // c == 3  (iota == 2, unused)
27 | 	d = 1 << iota  // d == 8  (iota == 3)
28 | )
29 | ```
30 | Note: The `<<` is a left shift operand, which shift lefts the operand by an integer
31 | (in this case `iota` value). So, for instance `1 << 2` equals `1 * 2 * 2`.
32 | 
33 | `nil` is a widely used variable. It is defined as:
34 | ```go
35 | var nil Type
36 | ```
37 | It represents the zero value of a type, within these classes: slices, pointer,
38 | map, func, interface, or channel.
39 | 


--------------------------------------------------------------------------------
/src/built-in-defer.md:
--------------------------------------------------------------------------------
 1 | ## defer
 2 | 
 3 | This function is not defined in the built-in package. But since it is used in
 4 | the example for `recover` I wanted to mention it.
 5 | 
 6 | `defer` is used to ensure that a function will be executed right before the 
 7 | function that calls it terminates. As [Go By example](https://gobyexample.com/defer)
 8 | mentions, other languages provide the construct _finally_ in some contexts.
 9 | 
10 | The syntax is simple:
11 | ```go
12 | defer func() { // ... 
13 | }()
14 | ```
15 | 
16 | Or directly
17 | 
18 | ```go
19 | defer closeFile(f)
20 | ```
21 | 
22 | `defer` takes a closure as argument. Which means that it is possible to include a wide
23 | range of elements inside it.
24 | 
25 | As noted in the [recover](./built-in-recover.md) section, if we call `defer` multiple times, the order in which
26 | these functions will be executed is **last in, first out**. So, for instance:
27 | 
28 | ```go
29 | import (
30 |     "fmt"
31 | )
32 | func main() {
33 |     fmt.Println("Let's count backwards:")
34 |     defer func() {
35 |         fmt.Println(1)
36 |     }()
37 |     defer func() {
38 |         fmt.Println(2)
39 |     }()
40 |     defer func() {
41 |         fmt.Println(3)
42 |     }()
43 | }
44 | ```
45 | This will output
46 | 
47 | ```
48 | Let's count backwards:
49 | 3
50 | 2
51 | 1
52 | ```
53 | 


--------------------------------------------------------------------------------
/src/built-in-make-and-new.md:
--------------------------------------------------------------------------------
 1 | # make and new
 2 | 
 3 | ## make
 4 | 
 5 | `make` is a very singular function. Its purpose is to allocate and initialize
 6 | an object of type slice, map, or chan (only). The output depends on the type
 7 | it's operating upon. You can see the differences, depending upon the type in the
 8 | excerpt below:
 9 | 
10 | ```go
11 | // from src/go/cmd/compile/internal/gc/builtin/runtime.go
12 | func makemap64(mapType *byte, hint int64, mapbuf *any) (hmap map[any]any)
13 | func makemap(mapType *byte, hint int, mapbuf *any) (hmap map[any]any)
14 | func makemap_small() (hmap map[any]any)
15 | func makechan64(chanType *byte, size int64) (hchan chan any)
16 | func makechan(chanType *byte, size int) (hchan chan any)
17 | func makeslice(typ *byte, len int, cap int) unsafe.Pointer
18 | func makeslice64(typ *byte, len int64, cap int64) unsafe.Pointer
19 | func makeslicecopy(typ *byte, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer
20 | ```
21 | 
22 | ## new
23 | 
24 | It can be thought as a `make` alternative, but with a size equal to zero and
25 | always initializing the value to its zero value.
26 | 


--------------------------------------------------------------------------------
/src/built-in-panic.md:
--------------------------------------------------------------------------------
 1 | ## panic
 2 | 
 3 | It's a function that stops the normal execution of the goroutine. All the
 4 | deferred functions are still being called, and once they complete this goroutine
 5 | returns to the caller. To the caller, the panic on the callee triggers a
 6 | termination on itself. This is a recursive mechanism that can eventually terminate
 7 | in the program exiting with a non-zero code. However, it's possible to control it
 8 | using recover. `panic` has different variants, and some are implemented in assembly,
 9 | while some other purely in Go.
10 | 
11 | ```go
12 | // Some are implemented in go
13 | 
14 | func panicshift()
15 | func panicdivide()
16 | ```
17 | 
18 | ```go
19 | // Some others are implemented in assembly
20 | 
21 | func panicIndex(x, y int)
22 | func panicIndexU(x uint, y int)
23 | ```
24 | 


--------------------------------------------------------------------------------
/src/built-in-recover.md:
--------------------------------------------------------------------------------
  1 | ## recover
  2 | 
  3 | Recover is a built-in function allows a program to manage behavior of a panicking
  4 | goroutine. It is useful only **inside a deferred function**. It stops the panicking
  5 | sequence by restoring normal execution and retrieves the error value passed to the
  6 | call of panic. If recover is called outside the deferred function it will not stop
  7 | a panicking sequence. In this case, or when the goroutine is not panicking, or if
  8 | the argument supplied to panic was nil, recover returns nil. Thus the return value
  9 | from recover reports whether the goroutine is panicking.
 10 | 
 11 | An example (https://blog.golang.org/defer-panic-and-recover) of the mechanisms of
 12 | panic and defer:
 13 | 
 14 | ```go
 15 | package main
 16 | 
 17 | import "fmt"
 18 | 
 19 | func main() {
 20 |     f()
 21 |     fmt.Println("Returned normally from f.")
 22 | }
 23 | 
 24 | func f() {
 25 |     defer func() {
 26 |         if r := recover(); r != nil {
 27 |             fmt.Println("Recovered in f", r)
 28 |         }
 29 |     }()
 30 |     fmt.Println("Calling g.")
 31 |     g(0)
 32 |     fmt.Println("Returned normally from g.")
 33 | }
 34 | 
 35 | func g(i int) {
 36 |     if i > 3 {
 37 |         fmt.Println("Panicking!")
 38 |         panic(fmt.Sprintf("%v", i))
 39 |     }
 40 |     defer fmt.Println("Defer in g", i)
 41 |     fmt.Println("Printing in g", i)
 42 |     g(i + 1)
 43 | }
 44 | 
 45 | // outputs
 46 | // Calling g.
 47 | // Printing in g 0
 48 | // Printing in g 1
 49 | // Printing in g 2
 50 | // Printing in g 3
 51 | // Panicking!
 52 | // Defer in g 3
 53 | // Defer in g 2
 54 | // Defer in g 1
 55 | // Defer in g 0
 56 | // Recovered in f 4
 57 | // Returned normally from f.
 58 | ```
 59 | 
 60 | Note that the call to referred functions goes in the opposite direction.
 61 | This is because the defer statement places the goroutine in the goroutine stack.
 62 | And thus, they get popped in LIFO order.
 63 | 
 64 | The same example, but without calling `recover` inside a defer is presented below:
 65 | 
 66 | ```go
 67 | package main
 68 | 
 69 | import "fmt"
 70 | 
 71 | func main() {
 72 |     f()
 73 |     fmt.Println("Returned normally from f.")
 74 | }
 75 | 
 76 | func f() {
 77 | //    defer func() {
 78 | //        if r := recover(); r != nil {
 79 | //            fmt.Println("Recovered in f", r)
 80 | //       }
 81 | //    }()
 82 |     fmt.Println("Calling g.")
 83 |     g(0)
 84 |     fmt.Println("Returned normally from g.")
 85 | }
 86 | 
 87 | func g(i int) {
 88 |     if i > 3 {
 89 |         fmt.Println("Panicking!")
 90 |         panic(fmt.Sprintf("%v", i))
 91 |     }
 92 |     defer fmt.Println("Defer in g", i)
 93 |     fmt.Println("Printing in g", i)
 94 |     g(i + 1)
 95 | }
 96 | 
 97 | // outputs
 98 | // Calling g.
 99 | // Printing in g 0
100 | // Printing in g 1
101 | // Printing in g 2
102 | // Printing in g 3
103 | // Panicking!
104 | // Defer in g 3
105 | // Defer in g 2
106 | // Defer in g 1
107 | // Defer in g 0
108 | 
109 | // AND NOW, this is different!
110 | 
111 | // panic: 4
112 | // panic PC=0x2a9cd8
113 | // [stack trace omitted]
114 | ```
115 | 


--------------------------------------------------------------------------------
/src/built-in.md:
--------------------------------------------------------------------------------
 1 | # Built in
 2 | 
 3 | >Package builtin provides documentation for Go's predeclared identifiers.
 4 | >The items documented here are not actually in package builtin (...)
 5 | >
 6 | > *Built in package overview*
 7 | 
 8 | Even though none of the items are defined in the built in package, it serves as a
 9 | compilation of highly used items that every Go developer needs to be aware of.
10 | The goal of this chapter is to cover some of these elements, with special focus
11 | on how they are implemented.
12 | 


--------------------------------------------------------------------------------
/src/bytes-buffers.md:
--------------------------------------------------------------------------------
 1 | ## Working with buffers
 2 | 
 3 | Sometimes our program needs to manipulate bytes. And we might or might not know
 4 | what's the size of this stream of bytes coming. Or perhaps we need to work with
 5 | chunks... who knows!
 6 | 
 7 | Buffers can help you, when you find yourself in these waters. But wait. What's a buffer?
 8 | Think of it as a variable sized array of bytes. It's a data structure that can be
 9 | resized to accommodate more or less bytes. It lets you write (`WriteByte`) new bytes to it,
10 | read bytes from it (`ReadByte`), remove some bytes (`Truncate`), remove all (`Reset`), etc.
11 | 
12 | To create a Buffer, we need to call either `NewBuffer` or `NewBufferString`.
13 | The difference is in the input that they take. The former accepts a byte slice `[]byte`
14 | while the latter expects a string.
15 | 
16 | For testing purposes let's say we create a buffer with some bytes:
17 | 
18 | ```go
19 | // we call
20 | b := bytes.NewBuffer([]byte("some bytes"))
21 | ```
22 | 
23 | To get the slice back, the `Bytes` method that can be used:
24 | 
25 | ```go
26 | b.Bytes() // [115 111 109 101 32 98 121 116 101 115]
27 | ```
28 | 
29 | We can read a fixed amount of bytes by using `Next(n int)`. It's important to note
30 | that calling this method will actually **read the bytes**. And thus, the buffer
31 | will have a new length of the previous one minus `n`. In case the buffer's length
32 | was less than n, then the method will return the entire buffer.
33 | 
34 | Alternatively, buffers can grow, be truncated and reset. For that, we have:
35 | 
36 | ```go
37 | func (b *Buffer) Grow(n int) // increases the buffer's capacity
38 | func (b *Buffer) Truncate(n int)
39 | func (*Buffer) Reset() // same as Truncate(0)
40 | ```
41 | 
42 | `Truncate(n int)` will discard all the bytes from the buffer, except for the first n ones.
43 | It does not shrink the capacity of the buffer. So this means that the buffer can still
44 | accommodate the same amount of elements without having to perform a memory allocation.
45 | If n < 0 or n > b.Len() then it panics.
46 | 
47 | If you want to shrink a buffer, Go does not offer a built in way of doing it.
48 | An alternative of achieving it would be:
49 | 
50 | ```go
51 | // https://stackoverflow.com/questions/16748330/does-go-have-no-real-way-to-shrink-a-slice-is-that-an-issue
52 | b = append([]T(nil), b[:newSize]...)
53 | ```
54 | 
55 | It is possible to work with the `Reader` interface. But it won't be covered in this chapter.
56 | 


--------------------------------------------------------------------------------
/src/bytes-compare.md:
--------------------------------------------------------------------------------
 1 | ## Compare
 2 | 
 3 | First, we can compare two bytes. That is, having a function that tells us whether
 4 | these two bytes are the same or not.
 5 | 
 6 | ```go
 7 | func Compare(a, b []byte) int
 8 | ```
 9 | The function Compare does this for us. It checks whether two **byte slices** are
10 | the same, and returns the result as an integer. The function performs a
11 | [lexicographic comparison](https://en.wikipedia.org/wiki/Lexicographical_order)
12 | and returns 0 if they are the same, -1 if a < b and +1 if a > b.
13 | 
14 | It's interesting to note how this function is implemented. Diving into Go's source code
15 | we can see the following:
16 | 
17 | ```go
18 | func Compare(a, b []byte) int {
19 | 
20 | 	return bytealg.Compare(a, b)
21 | 
22 | }
23 | ```
24 | Something as _simple_ as just comparing bytes, involves going down to assembly language.
25 | The function Compare calls the function Compare in the package `bytealg`, which defines 
26 | `Compare` like this:
27 | 
28 | ```go
29 | //go:noescape
30 | 
31 | func Compare(a, b []byte) int
32 | ```
33 | 
34 | The directive `//go:noespace` tells the compiler that the values passed to the function
35 | must be stored in the stack. And additionally that the function implementation is not written
36 | in Go. This means that the byte comparison function is implemented in a lower language, like
37 | assembly.
38 | 
39 | Check [Compiler directives](https://golang.org/cmd/compile/#hdr-Compiler_Directives) if you
40 | want to get more details in this topic.
41 | 


--------------------------------------------------------------------------------
/src/bytes-index.md:
--------------------------------------------------------------------------------
 1 | # Index
 2 | 
 3 | Let's say we have some bytes, represented as a slice of byte, which in Go lingo means
 4 | `[]byte`. If we want to verify whether these bytes contain a certain subset of bytes,
 5 | and we're particularly interested in knowing where in the slice they are located
 6 | we can use the function `Index`, provided in the package **bytes**.
 7 | 
 8 | ```go
 9 | func Index(s, sep []byte) int
10 | ```
11 | 
12 | The way it is implemented is as follows:
13 | 
14 | - If the length of the separator is 0, then it returns 0. Nothing more to do
15 | - If it is 1, it calls another function called IndexByte to do the work.
16 |   This is also an assembly function. One of its variants can be found [here](https://golang.org/src/internal/bytealg/indexbyte_amd64.s)
17 | - If the sizes between sep and s match, then it checks whether they are equal or not. For that, it calls Equal, which we have already mentioned.
18 | - If the separator length is bigger than one, then it's no longer a byte. It then goes to a more complex logic involving `bytealg.Index`.
19 | 
20 | Besides the full implementation, sometimes it's useful to follow how things work under the hood.
21 | And in such a low level package, we can find the need of working with assembly and targeting
22 | the different architectures. Check [bytealg package](https://golang.org/src/internal/bytealg/) for an overview.
23 | 


--------------------------------------------------------------------------------
/src/bytes-intro.md:
--------------------------------------------------------------------------------
 1 | # Bytes
 2 | 
 3 | Bytes are program's building blocks.
 4 | 
 5 | In Go, a byte is a type alias of `uint8`, and thus it is defined as:
 6 | 
 7 | ```go
 8 | type byte = uint8
 9 | ```
10 | 
11 | And thus, when talking about **bytes**, we mean a slice of `byte`, namely: `[]byte`.
12 | 
13 | ## Why and when use bytes?
14 | 
15 | Bytes are pervasive, especially when working in systems programming. If you want
16 | to work on an application related to networking, operating systems, databases,
17 | you will likely end up working with bytes. And that is why it's very important
18 | to understand what tools are available off the shelf.
19 | 
20 | In the following sections, we will address some operations Go allows us to
21 | perform on bytes.
22 | 


--------------------------------------------------------------------------------
/src/context-details.md:
--------------------------------------------------------------------------------
  1 | # Context details
  2 | 
  3 | The `Context` carries a deadline, a cancellation signal, `Done` and other values
  4 | across processes and APIs. It is defined as an interface:
  5 | 
  6 | ```go
  7 | type Context interface {
  8 |     Deadline() (deadline time.Time, ok bool)
  9 |     Done() <-chan struct{}
 10 |     Err() error
 11 |     Value(key interface{}) interface{}
 12 | }
 13 | ```
 14 | 
 15 | Note: these methods may be called by multiple goroutines simultaneously.
 16 | 
 17 | The package provides different types of contexts, with different _service levels_:
 18 | 
 19 | - emptyCtx: it's one that is never cancelled, has no values and no deadline
 20 | - cancelCtx: is one that can be cancelled. When cancelled, it also cancels all
 21 |   its children that implement cancel.
 22 | - valueCtx: carries a key-value pair. Delegates all other calls (such as cancel) to its
 23 |   embedded context.
 24 | - timerCtx: carries a timer and a deadline. It embeds `cancelCtx` to implement `Done` and `Err`.
 25 |   `cancel` is implementing by stopping its timer and delegating the call to `cancelCtx`
 26 | 
 27 | It's important to note that as a user of the package, we only have access to these types through
 28 | 
 29 | ```go
 30 | func WithCancel(parent Context) (ctx Context, cancel CancelFunc)
 31 | func WithDeadline(parent Context, d time.Time) (Context, CancelFunc)
 32 | func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
 33 | ```
 34 | 
 35 | ## CancelFunc
 36 | 
 37 | ```go
 38 | type CancelFunc func()
 39 | ```
 40 | 
 41 | When creating a context, there are some factory functions. And all of them return a `CancelFunc` type.
 42 | This is, as its name indicates, a function. It tells an operation to abandon its work. It's async, and
 43 | it can be called by multiple goroutines simultaneously. After the first call, the subsequent calls are
 44 | no-ops.
 45 | 
 46 | As an example, for the `cancelCtx`, `cancel` method exists. It closes the `done` channel and cancels
 47 | all of its children, plus some other cleaning tasks.
 48 | 
 49 | ## Examples
 50 | 
 51 | This is an extension of the original example provided in the std library.
 52 | It depicts the usage of context within several goroutines that form a tree.
 53 | 
 54 | Once the main goroutine triggers the `cancel` function, all the others
 55 | are also cancelled.
 56 | 
 57 | ```go
 58 | package main
 59 | 
 60 | import (
 61 | 	"context"
 62 | 	"fmt"
 63 | 	"time"
 64 | )
 65 | 
 66 | func main() {
 67 | 	// gen generates integers in a separate goroutine and
 68 | 	// sends them to the returned channel.
 69 | 	// The callers of gen need to cancel the context once
 70 | 	// they are done consuming generated integers not to leak
 71 | 	// the internal goroutine started by gen.
 72 | 	gen := func(ctx context.Context) <-chan int {
 73 | 		ctx2, cancel := context.WithCancel(ctx)
 74 | 		defer cancel()
 75 | 		// propagating the cancel context to a new goroutine
 76 | 		go doStuff(ctx2)
 77 | 		dst := make(chan int)
 78 | 		n := 1
 79 | 		go func() {
 80 | 			for {
 81 | 				select {
 82 | 				case <-ctx.Done():
 83 | 					fmt.Println("Closing gen")
 84 | 					fmt.Println(n)
 85 | 					return // returning not to leak the goroutine
 86 | 				case dst <- n:
 87 | 					n++
 88 | 				}
 89 | 			}
 90 | 		}()
 91 | 		return dst
 92 | 	}
 93 | 
 94 | 	ctx, cancel := context.WithCancel(context.Background())
 95 | 	//	defer cancel() // cancel when we are finished consuming integers
 96 | 	for n := range gen(ctx) {
 97 | 		fmt.Println(n)
 98 | 		if n == 5 {
 99 | 			break
100 | 		}
101 | 	}
102 | 	cancel()
103 | 	for {
104 | 		time.Sleep(3 * time.Second)
105 | 		break
106 | 	}
107 | }
108 | func doStuff(ctx context.Context) {
109 | 	fmt.Println("Starting child")
110 | 	for {
111 | 		select {
112 | 		case <-ctx.Done():
113 | 			fmt.Println("Closing child")
114 | 			return
115 | 		}
116 | 	}
117 | }
118 | 
119 | ```
120 | 
121 | A plausible output (it's non-deterministic):
122 | 
123 | ```
124 | 1
125 | 2
126 | 3
127 | 4
128 | 5
129 | Closing gen
130 | 6
131 | Starting child
132 | Closing child
133 | ```
134 | 
135 | ### Using WithTimeout
136 | 
137 | This example is rather simple. But it shows how to propagate a timeout into a tree.
138 | Here we show how the main goroutine receives a `Done` signal after 50 milliseconds. This
139 | triggers (through `cancel`) subsequent `Done` signals to all the goroutines that
140 | where created with the `WithTimeout` method.
141 | 
142 | ```go
143 | package main
144 | 
145 | import (
146 | 	"context"
147 | 	"fmt"
148 | 	"time"
149 | )
150 | 
151 | func main() {
152 | 	// Pass a context with a timeout to tell a blocking function that it
153 | 	// should abandon its work after the timeout elapses.
154 | 	ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
155 | 	ctx2, cancel2 := context.WithTimeout(context.Background(), 50*time.Millisecond)
156 | 
157 | 	func(ctx2 context.Context) {
158 | 		select {
159 | 		case <-ctx2.Done():
160 | 			fmt.Println(ctx2.Err()) // prints "context deadline exceeded"
161 | 			return
162 | 		case <-time.After(100 * time.Millisecond):
163 | 			fmt.Println("overslept 2")
164 | 		}
165 | 
166 | 	}(ctx2)
167 | 
168 | 	defer cancel()
169 | 	defer cancel2()
170 | 
171 | 	select {
172 | 	case <-time.After(100 * time.Millisecond):
173 | 		fmt.Println("overslept")
174 | 	case <-ctx.Done():
175 | 		fmt.Println(ctx.Err()) // prints "context deadline exceeded"
176 | 	}
177 | 
178 | }
179 | ```
180 | 
181 | ## Context being used in the real world
182 | 
183 | These are some libraries making heavy use of this pattern:
184 | 
185 | 1. [kubernetes](https://github.com/kubernetes/kubernetes)
186 | 2. [gRPC](https://github.com/grpc/grpc-go)
187 | 3. [dgraph](https://github.com/dgraph-io/dgraph)
188 | 


--------------------------------------------------------------------------------
/src/context-intro.md:
--------------------------------------------------------------------------------
 1 | # Context
 2 | 
 3 | Package context defines the Context type. A context can include deadlines,
 4 | cancellation signals, and other request-scoped values across API boundaries
 5 | and between processes. A key feature of this pattern is that it allows signals
 6 | to be propagated. So for instance, when a context is cancelled then all the
 7 | contexts derived from it are cancelled as well.
 8 | 
 9 | Context is a very singular pattern, that I have not seen implemented in the
10 | standard libraries of other languages. And since it's widely adopted in different
11 | projects, I thought it was worth covering it.
12 | 
13 | Go proposes an interface to work with `Context`, which is
14 | 
15 | > Programs that use Contexts should follow these rules to keep interfaces
16 | > consistent across packages and enable static analysis tools to check context propagation:
17 | >
18 | > Do not store Contexts inside a struct type; instead, pass a Context explicitly to each function that needs it.
19 | > The Context should be the first parameter, typically named ctx:
20 | 
21 | ```go
22 | func DoSomething(ctx context.Context, arg Arg) error {
23 | 	// ... use ctx ...
24 | }
25 | ```
26 | 
27 | Next, we describe some different functionalities offered by the package
28 | and show alternatives of how it can be used. Much of it has been taken from
29 | [this blog post](https://blog.golang.org/context) by Sameer Ajmani.
30 | 


--------------------------------------------------------------------------------
/src/cover.md:
--------------------------------------------------------------------------------
1 | ![Cover Image](./img/cover.svg)
2 | 


--------------------------------------------------------------------------------
/src/errors-As-Is.md:
--------------------------------------------------------------------------------
 1 | ## As
 2 | 
 3 | `As` finds the **first error in err's chain that matches target**. If it
 4 | succeeds, it sets target to that error value and returns true. Otherwise,
 5 | it returns false.
 6 | 
 7 | `As` panics if target is not a non-nil pointer to either a type that implements
 8 | error, or to any interface type.
 9 | 
10 | ```go
11 | var e *QueryError
12 | if errors.As(err, &e) {
13 |     // err is a *QueryError, and e is set to the error's value
14 | }
15 | ```
16 | 
17 | ## Is
18 | 
19 | `Is` reports whether **any error** (as opposed to finding the first with `As`)
20 | in err's chain matches target.
21 | 
22 | The chain consists of err itself followed by the **sequence of errors obtained**
23 | **by repeatedly calling Unwrap**.
24 | 
25 | ```go
26 | if errors.Is(err, ErrPermission) {
27 |     // ...
28 | }
29 | ```
30 | 
31 | This equivalent to the following:
32 | 
33 | ```go
34 | if e, ok := err.(*QueryError); ok && e.Err == ErrPermission {
35 |     // ...
36 | }
37 | ```
38 | 
39 | ## Remarks
40 | 
41 | One of the biggest advantages of having these two methods, is when working with
42 | highly nested errors. They bring all the necessary machinery to unwrap as much
43 | as needed until a match is found. Or if there is no match, we are sure that all
44 | the inner errors were also compared.
45 | 


--------------------------------------------------------------------------------
/src/errors-great-again.md:
--------------------------------------------------------------------------------
 1 | ## Making error great again
 2 | 
 3 | The following is a canonical example of how horrible error handling
 4 | can become in Go:
 5 | 
 6 | ```go
 7 | _, err = fd.Write(p0[a:b])
 8 | if err != nil {
 9 |     return err
10 | }
11 | _, err = fd.Write(p1[c:d])
12 | if err != nil {
13 |     return err
14 | }
15 | _, err = fd.Write(p2[e:f])
16 | if err != nil {
17 |     return err
18 | }
19 | // and so on
20 | ```
21 | 
22 | An improvement, using a helper function:
23 | 
24 | ```go
25 | var err error
26 | write := func(buf []byte) {
27 |     if err != nil {
28 |         return
29 |     }
30 |     _, err = w.Write(buf)
31 | }
32 | write(p0[a:b])
33 | write(p1[c:d])
34 | write(p2[e:f])
35 | // and so on
36 | if err != nil {
37 |     return err
38 | }
39 | ```
40 | 
41 | However, here we need to be sure that `err` is being captured by `write`
42 | every time we call this function. We could actually do better, by creating a
43 | new type, and adding a method for it that does what `write` is doing here. Then,
44 | we will not need to have any closure, nor ensure that the value is being closed
45 | by the function.
46 | 
47 | This is even a much better way of working with errors. And in some ways, it
48 | brings to the table some of Haskell's/FP approach to error handling:
49 | 
50 | ```go
51 | type errWriter struct {
52 |     w   io.Writer
53 |     err error
54 | }
55 | 
56 | func (ew *errWriter) write(buf []byte) {
57 |     if ew.err != nil {
58 |         return
59 |     }
60 |     _, ew.err = ew.w.Write(buf)
61 | }
62 | ```
63 | 
64 | ```go
65 | ew := &errWriter{w: fd}
66 | ew.write(p0[a:b])
67 | ew.write(p1[c:d])
68 | ew.write(p2[e:f])
69 | // and so on
70 | if ew.err != nil {
71 |     return ew.err
72 | }
73 | ```
74 | 
75 | Here, `write` checks whether `errWriter` have failed before. If it
76 | did, then it won't do anything again; we are an _abnormal state_ already.
77 | Otherwise, it's free to do some work.
78 | 
79 | ### References:
80 | 
81 | - https://blog.golang.org/errors-are-values
82 | - http://jxck.hatenablog.com/entry/golang-error-handling-lesson-by-rob-pike
83 | 


--------------------------------------------------------------------------------
/src/errors-intro.md:
--------------------------------------------------------------------------------
 1 | ## Errors
 2 | 
 3 | Error handling is a very important topic in software engineering. There are
 4 | plenty different schools of thought. Go's approach to it is very simple.
 5 | It treats [**errors as values**](https://blog.golang.org/errors-are-values),
 6 | and to some people is insufficient. But we won't get into this discussion here.
 7 | 
 8 | The `error` type is used to indicate an _abnormal state_. When this happens,
 9 | there are several ways to act. In this chapter, we will only focus on the
10 | availability of tools that Go provides the developer to characterize and respond
11 | to these _anomalies_.
12 | 
13 | `error` is defined in the `built-in` package as:
14 | 
15 | ```go
16 | type error interface {
17 |     Error() string
18 | }
19 | ```
20 | 
21 | However, this package provides nothing else than this interface. Most of the
22 | surrounding infrastructure is provided within the `errors` package instead.
23 | 


--------------------------------------------------------------------------------
/src/errors-unwrap.md:
--------------------------------------------------------------------------------
 1 | ## Unwrap
 2 | 
 3 | _(feature added in Go 1.13)_
 4 | 
 5 | This is an interesting feature, when building errors that
 6 | **contain other errors**.
 7 | 
 8 | `Unwrap` is actually defined as follows:
 9 | 
10 | ```go
11 | func Unwrap(err error) error {
12 | 
13 | 	u, ok := err.(interface {
14 | 		Unwrap() error
15 | 	})
16 | 	if !ok {
17 | 		return nil
18 | 	}
19 | 	return u.Unwrap()
20 | 
21 | }
22 | ```
23 | 
24 | It first checks whether `err` has itself the `Unwrap` method. If it doesn't, then
25 | nothing else can be done. There is nothing to unwrap. Nada. But if the method
26 | is defined, it calls it and returns its value, which is an `error` itself.
27 | 
28 | This is a very useful way of composing errors, and thus adding much more
29 | information. We could think of the following scenario:
30 | 
31 | ```go
32 | package main
33 | 
34 | import (
35 | 	"fmt"
36 | 	"log"
37 | 	"errors"
38 | )
39 | type databaseError struct {
40 |     err error
41 | }
42 | 
43 | type queryMissingParamsError struct {
44 |     params string
45 | }
46 | 
47 | func (de *databaseError) Unwrap() error {
48 |     return de.err
49 | }
50 | 
51 | func (de *databaseError) Error() string {
52 |     return fmt.Sprintf("Database error. %s", de.err)
53 | }
54 | 
55 | func (qmp *queryMissingParamsError) Error() string {
56 |     return fmt.Sprintf("Some parameter were missing: %s", qmp.params)
57 | }
58 | 
59 | // bogus query
60 | type Query struct {}
61 | 
62 | func (q *Query) Check() error {
63 |     return &databaseError {
64 |         err: &queryMissingParamsError {
65 |             params: "name",
66 |         },
67 |     }
68 | }
69 | 
70 | func handleDatabaseQuery(query *Query) error {
71 |     err := query.Check()
72 |     if err == nil {
73 |         return nil
74 |     }
75 |     log.Print(err)
76 |     return errors.Unwrap(err)
77 | }
78 | func main() {
79 | 	q := &Query{}
80 | 	err := handleDatabaseQuery(q)
81 | 	fmt.Println(err)
82 | }
83 | 
84 | ```
85 | 
86 | In this example, we can see how an error can pack and unpack other errors. And
87 | we can choose to define a strategy for the different scenarios. So, in this
88 | particular example, we could ask the user to make the query again and remind
89 | her not to forget to include _name_ as a parameter.
90 | 


--------------------------------------------------------------------------------
/src/favicon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/blasrodri/spaceship-go/089000aae4f32d5b2aad1d025aef20442cdb894b/src/favicon.png


--------------------------------------------------------------------------------
/src/img/cover.svg:
--------------------------------------------------------------------------------
 1 | <svg width="350" height="500" viewBox="0 0 350 500" fill="none" xmlns="http://www.w3.org/2000/svg">
 2 | <rect width="350" height="500" fill="black"/>
 3 | <path d="M133.574 121.014C128.08 121.148 122.53 121.039 117.073 121.435C112.684 124.122 108.945 128.059 104.766 131.178C100.321 132.124 95.5286 131.66 90.9604 131.969C88.854 131.418 85.4672 132.911 87.0249 135.591C90.9891 138.916 95.3468 141.874 99.7433 144.577C100.767 145.38 102.645 144.897 102.318 146.783C103.919 166.652 104.751 186.859 106.144 206.885C107.075 219.626 107.556 232.437 108.951 245.122C110.682 248.785 113.3 251.868 115.457 255.245C113.197 254.771 110.787 257.472 112.767 259.476C113.545 260.774 117.124 261.958 115.961 263.428C114.38 264.686 112.39 267.387 114.658 269.058C116.378 269.481 116.996 269.71 115.579 271.391C112.673 276.701 108.931 281.554 106.634 287.215C106.359 290.649 110.461 290.437 112.624 291.056C117.933 291.926 123.247 293.207 128.562 293.627C136.611 292.717 144.712 291.766 152.616 289.904C155.292 288.392 153.202 285.344 152.124 283.49C149.479 278.777 146.71 274.143 143.835 269.587C146.164 270.317 148.309 267.206 146.268 265.402C145.49 264.245 142.782 262.841 145.131 261.791C146.831 260.508 150.205 258.132 147.723 255.873C145.555 255.352 144.573 255.204 146.477 253.157C149.353 249.452 151.89 245.187 152.044 240.224C154.592 208.586 156.253 176.872 158.152 145.184C162.33 141.747 167.079 139.055 171.179 135.605C172.82 133.237 169.719 131.342 167.666 131.996C163.879 131.647 159.954 132.422 156.33 131.411C151.433 128.358 147.595 123.378 142.227 121.21C139.356 120.91 136.456 121.045 133.574 121.014V121.014Z" fill="#636363"/>
 4 | <path d="M134.709 326.802C136.063 320.362 143.106 320.773 150.15 312.395C157.193 304.018 157.193 296.506 132.141 266.462C107.088 296.506 107.088 304.018 114.131 312.395C121.175 320.773 128.218 320.362 129.572 326.802C130.927 333.242 132.141 343.56 132.141 343.56C132.141 343.56 133.354 333.242 134.709 326.802V326.802Z" fill="#FBFD9B" stroke="#2CD7FF" stroke-width="0.462418" stroke-linecap="round"/>
 5 | <path d="M133.946 319.477C134.898 310.764 139.85 310.698 144.802 304.807C149.754 298.917 149.754 293.636 132.14 272.513C114.527 293.636 114.527 298.917 119.479 304.807C124.431 310.698 129.383 310.764 130.335 319.477C131.287 328.191 132.14 329.963 132.14 329.963C132.14 329.963 132.994 328.191 133.946 319.477V319.477Z" fill="#FCFEC0"/>
 6 | <path d="M133.232 312.729C133.808 303.757 136.801 304.116 139.795 299.336C142.788 294.555 131.103 287.818 132.14 266.384C131.549 286.695 121.493 294.555 124.486 299.336C127.48 304.116 130.473 303.757 131.049 312.729C131.625 321.701 132.14 323.803 132.14 323.803C132.14 323.803 132.656 321.701 133.232 312.729Z" fill="#DAF8FF"/>
 7 | <path d="M130.284 123.183L117.824 123.36L103.963 134.804L108.436 211.58L110.908 244.775L123.445 262.774L108.069 287.934L128.659 291.654L152.498 287.934L137.122 262.774L149.66 244.775L152.132 211.58L156.605 134.804L142.744 123.36L130.284 123.183Z" fill="#CECECE" stroke="#E5E5E5" stroke-width="0.462418" stroke-linecap="round"/>
 8 | <path d="M124.579 123.263L117.824 123.359L103.963 134.803L108.436 211.579L110.908 244.774L123.446 262.774L108.07 287.934L119.371 289.976L128.658 263.01L121.074 245.389L114.3 137.343C114.3 137.343 119.59 130.166 124.579 123.263V123.263Z" fill="#B0B0B0" stroke="#E5E5E5" stroke-width="0.462418" stroke-linecap="round"/>
 9 | <path d="M134.944 122.961L141.12 137.054L139.764 245.388L132.18 262.722L137.529 289.98L149.234 288.154L134.619 262.722L145.182 244.812L149.788 135.321L139.735 123.028L134.944 122.961Z" fill="#DCDCDC" stroke="#E5E5E5" stroke-width="0.462418" stroke-linecap="round"/>
10 | <path d="M113.706 257.353L119.882 262.748L115.096 267.513H145.472L140.686 262.748L146.862 257.353H113.706Z" fill="#CECECE" stroke="#E5E5E5" stroke-width="0.462418" stroke-linecap="round"/>
11 | <path d="M113.706 257.353L119.882 262.748L115.096 267.513H125.239L127.811 262.967L123.84 257.353H113.706Z" fill="#B0B0B0" stroke="#E5E5E5" stroke-width="0.462418" stroke-linecap="round"/>
12 | <path d="M137.015 257.353L133.168 262.701L134.72 267.513H141.422L136.878 262.701L142.063 257.353H137.015Z" fill="#DCDCDC" stroke="#E5E5E5" stroke-width="0.462418" stroke-linecap="round"/>
13 | <path d="M101.186 143.274L88.3566 134.068H169.773L156.944 143.274H101.186Z" fill="#CECECE" stroke="#E5E5E5" stroke-width="0.462418" stroke-linecap="round"/>
14 | <path d="M101.186 143.274L88.3566 134.068H115.544L122.437 142.85L101.186 143.274Z" fill="#B0B0B0" stroke="#E5E5E5" stroke-width="0.462418" stroke-linecap="round"/>
15 | <path d="M136.795 143.366L140.955 134.068H158.917L146.737 143.366H136.795Z" fill="#DCDCDC" stroke="#E5E5E5" stroke-width="0.462418" stroke-linecap="round"/>
16 | <path d="M225.335 121.014C219.84 121.148 214.29 121.039 208.834 121.435C204.444 124.122 200.705 128.059 196.527 131.178C192.081 132.124 187.289 131.66 182.721 131.969C180.614 131.418 177.228 132.911 178.785 135.591C182.749 138.916 187.107 141.874 191.504 144.577C192.527 145.38 194.406 144.897 194.078 146.783C195.68 166.652 196.512 186.859 197.905 206.885C198.835 219.626 199.316 232.437 200.711 245.122C202.442 248.785 205.06 251.868 207.217 255.245C204.957 254.771 202.547 257.472 204.527 259.476C205.305 260.774 208.885 261.958 207.721 263.428C206.14 264.686 204.15 267.387 206.418 269.058C208.138 269.481 208.756 269.71 207.339 271.391C204.433 276.701 200.691 281.554 198.394 287.215C198.12 290.649 202.222 290.437 204.384 291.056C209.693 291.926 215.007 293.207 220.323 293.627C228.371 292.717 236.473 291.766 244.376 289.904C247.052 288.392 244.962 285.344 243.885 283.49C241.239 278.777 238.47 274.143 235.595 269.587C237.925 270.317 240.07 267.206 238.028 265.402C237.25 264.245 234.542 262.841 236.891 261.791C238.591 260.508 241.965 258.132 239.484 255.873C237.316 255.352 236.333 255.204 238.237 253.157C241.113 249.452 243.651 245.187 243.804 240.224C246.353 208.586 248.014 176.872 249.913 145.184C254.091 141.747 258.839 139.055 262.939 135.605C264.58 133.237 261.479 131.342 259.426 131.996C255.639 131.647 251.715 132.422 248.091 131.411C243.193 128.358 239.355 123.378 233.987 121.21C231.116 120.91 228.216 121.045 225.335 121.014V121.014Z" fill="#636363"/>
17 | <path d="M226.49 327.14C227.74 320.019 234.867 320.688 241.91 312.394C248.953 304.101 248.953 296.506 223.901 266.462C198.848 296.506 198.848 304.018 205.892 312.395C212.935 320.773 219.895 320.071 221.353 327.176C222.812 334.281 224.211 342.233 224.211 342.233C224.211 342.233 225.239 334.261 226.49 327.14V327.14Z" fill="#FBFD9B" stroke="#2CD7FF" stroke-width="0.462418" stroke-linecap="round"/>
18 | <path d="M225.706 319.172C226.659 310.957 231.611 310.698 236.563 304.807C241.515 298.917 241.515 293.636 223.901 272.513C206.287 293.636 206.287 298.917 211.239 304.807C216.191 310.698 221.143 310.964 222.095 319.185C223.048 327.407 224.009 330.298 224.009 330.298C224.009 330.298 224.754 327.387 225.706 319.172V319.172Z" fill="#FCFEC0"/>
19 | <path d="M224.992 312.679C225.568 303.888 228.561 304.116 231.555 299.336C234.549 294.555 222.864 287.818 223.901 266.384C223.31 286.695 213.253 294.555 216.247 299.336C219.24 304.116 222.234 303.886 222.809 312.682C223.385 321.477 223.901 323.715 223.901 323.715C223.901 323.715 224.417 321.47 224.992 312.679Z" fill="#DAF8FF"/>
20 | <path d="M222.044 123.183L209.585 123.36L195.723 134.804L200.196 211.58L202.669 244.775L215.206 262.774L199.83 287.934L220.419 291.654L244.259 287.934L228.883 262.774L241.42 244.775L243.892 211.58L248.365 134.804L234.504 123.36L222.044 123.183Z" fill="#CECECE" stroke="#E5E5E5" stroke-width="0.462418" stroke-linecap="round"/>
21 | <path d="M216.339 123.263L209.585 123.359L195.723 134.803L200.197 211.579L202.669 244.774L215.206 262.774L199.83 287.934L211.131 289.976L220.419 263.01L212.834 245.389L206.061 137.343C206.061 137.343 211.35 130.166 216.339 123.263V123.263Z" fill="#B0B0B0" stroke="#E5E5E5" stroke-width="0.462418" stroke-linecap="round"/>
22 | <path d="M226.704 122.961L232.88 137.054L231.525 245.388L223.94 262.722L229.289 289.98L240.995 288.154L226.379 262.722L236.943 244.812L241.548 135.321L231.495 123.028L226.704 122.961Z" fill="#DCDCDC" stroke="#E5E5E5" stroke-width="0.462418" stroke-linecap="round"/>
23 | <path d="M205.467 257.353L211.643 262.748L206.856 267.513H237.233L232.446 262.748L238.622 257.353H205.467Z" fill="#CECECE" stroke="#E5E5E5" stroke-width="0.462418" stroke-linecap="round"/>
24 | <path d="M205.467 257.353L211.643 262.748L206.856 267.513H217L219.571 262.967L215.601 257.353H205.467Z" fill="#B0B0B0" stroke="#E5E5E5" stroke-width="0.462418" stroke-linecap="round"/>
25 | <path d="M228.775 257.353L224.928 262.701L226.48 267.513H233.182L228.638 262.701L233.823 257.353H228.775Z" fill="#DCDCDC" stroke="#E5E5E5" stroke-width="0.462418" stroke-linecap="round"/>
26 | <path d="M192.946 143.274L180.117 134.068H261.534L248.705 143.274H192.946Z" fill="#CECECE" stroke="#E5E5E5" stroke-width="0.462418" stroke-linecap="round"/>
27 | <path d="M192.946 143.274L180.117 134.068H207.304L214.197 142.85L192.946 143.274Z" fill="#B0B0B0" stroke="#E5E5E5" stroke-width="0.462418" stroke-linecap="round"/>
28 | <path d="M228.555 143.366L232.715 134.068H250.678L238.498 143.366H228.555Z" fill="#DCDCDC" stroke="#E5E5E5" stroke-width="0.462418" stroke-linecap="round"/>
29 | <path fill-rule="evenodd" clip-rule="evenodd" d="M214.59 142.685C217.805 136.349 220.897 130.641 227.587 129.376C230.484 128.828 233.262 129.52 235.169 131.849C237.379 134.547 237.572 137.692 236.644 141.154C235.607 145.02 231.282 145.091 229.015 145.5C223.023 146.58 219.504 146.156 216.485 145.99C215.263 145.923 213.606 144.623 214.59 142.685V142.685Z" fill="#554539"/>
30 | <path fill-rule="evenodd" clip-rule="evenodd" d="M215.772 142.154C218.638 136.505 221.235 131.354 227.2 130.226C229.783 129.737 232.418 130.417 234.119 132.494C236.089 134.899 236.261 137.702 235.434 140.789C234.509 144.236 230.653 144.299 228.632 144.664C223.29 145.627 220.153 145.249 217.461 145.101C216.372 145.041 214.895 143.882 215.772 142.154Z" fill="#35DBFF" fill-opacity="0.71"/>
31 | <path fill-rule="evenodd" clip-rule="evenodd" d="M227.824 135.71C228.354 135.623 228.782 135.62 229.123 135.657C229.463 135.694 229.714 135.771 229.884 135.844C230.054 135.917 230.163 136.001 230.163 136.001C230.485 136.261 230.051 136.437 229.729 136.177C229.729 136.177 229.708 136.154 229.59 136.104C229.473 136.054 229.281 135.973 228.996 135.961C227.994 135.919 227.364 136.077 225.949 136.64C222.851 137.872 221.8 141.568 221.8 141.568C221.673 142.004 221.055 141.772 221.226 141.353C221.226 141.353 222.516 137.616 225.922 136.261C226.664 135.965 227.295 135.796 227.824 135.71V135.71Z" fill="#554539"/>
32 | <path fill-rule="evenodd" clip-rule="evenodd" d="M224.526 139.699C224.939 139.685 225.314 139.71 225.629 139.805C225.944 139.9 226.246 140.101 226.316 140.454C226.399 140.869 226.178 140.5 226.068 140.38C224.893 139.104 222.374 140.486 222.111 140.766C221.718 140.886 221.553 140.274 221.945 140.154C222.729 139.914 223.701 139.726 224.526 139.699Z" fill="#554539"/>
33 | <path fill-rule="evenodd" clip-rule="evenodd" d="M132.802 137.994C128.525 132.502 124.481 127.598 117.699 127.851C114.763 127.96 112.164 129.258 110.709 131.965C109.023 135.102 109.392 138.227 110.917 141.412C112.62 144.97 116.872 144.075 119.166 143.97C125.23 143.692 128.603 142.492 131.533 141.656C132.718 141.317 134.11 139.673 132.802 137.994V137.994Z" fill="#554539"/>
34 | <path fill-rule="evenodd" clip-rule="evenodd" d="M131.549 137.737C127.736 132.841 124.276 128.372 118.23 128.597C115.612 128.694 113.15 129.948 111.853 132.363C110.35 135.159 110.679 137.945 112.038 140.785C113.557 143.957 117.347 143.159 119.393 143.065C124.798 142.817 127.806 141.747 130.418 141.002C131.474 140.7 132.715 139.234 131.549 137.737Z" fill="#35DBFF" fill-opacity="0.71"/>
35 | <path fill-rule="evenodd" clip-rule="evenodd" d="M118.598 134.105C118.12 134.103 117.64 134.103 117.167 134.178C116.837 134.23 116.494 134.278 116.196 134.439C116.101 134.49 115.923 134.547 115.95 134.654C115.99 134.811 116.257 134.772 116.407 134.73C116.457 134.716 116.482 134.651 116.53 134.628C116.782 134.503 117.069 134.471 117.345 134.448C118.43 134.354 119.115 134.363 120.601 134.6C123.856 135.117 125.544 138.504 125.544 138.504C125.745 138.903 126.311 138.538 126.068 138.166C126.068 138.166 124.139 134.791 120.56 134.222C119.78 134.098 119.253 134.108 118.598 134.105V134.105Z" fill="#554539"/>
36 | <path fill-rule="evenodd" clip-rule="evenodd" d="M122.551 137.303C122.144 137.381 121.78 137.488 121.489 137.65C121.197 137.813 120.937 138.077 120.931 138.438C120.924 138.863 121.075 138.453 121.161 138.311C122.084 136.802 124.801 137.6 125.109 137.816C125.515 137.848 125.568 137.212 125.162 137.18C124.351 137.117 123.365 137.148 122.551 137.303Z" fill="#554539"/>
37 | <path fill-rule="evenodd" clip-rule="evenodd" d="M227.266 150.971C213.157 131.874 190.496 125.113 168.374 126.707C149.092 128.097 128.446 133.074 116.526 150.406C108.606 161.921 111.103 172.201 115.346 186.066C119.624 200.046 127.039 215.473 123.207 230.637C120.561 241.107 121.917 250.883 123.026 260.789C124.412 273.158 129.292 285.105 140.002 291.099C152.265 297.963 167.477 298.947 181.776 298.082C195.58 297.246 210.371 292.181 218.462 278.205C224.597 267.607 228.189 254.939 227.425 242.936C226.661 230.952 226.662 225.341 229.977 213.115C233.889 198.681 234.264 183.817 233.288 168.943C232.885 162.791 230.899 155.89 227.266 150.971V150.971Z" fill="#554539"/>
38 | <path fill-rule="evenodd" clip-rule="evenodd" d="M225.389 153.606C214.502 138.338 194.252 130.235 176.271 129.784C155.487 129.263 130.048 136.116 118.347 154.441C111.554 165.079 115.467 173.221 119.517 187.675C122.489 198.279 127.11 213.756 127.214 224.822C127.315 235.49 125.919 245.918 126.134 256.601C126.34 266.819 128.223 272.248 133.405 278.749C138.595 285.261 146.948 289.686 155.49 291.28C171.154 294.203 189.514 294.823 204.053 286.846C212.655 282.126 218.613 271.657 222.155 261.242C226.565 248.278 223.391 240.224 224.939 226.518C226.298 214.478 230.763 202.819 230.868 190.693C230.976 178.179 232.492 163.568 225.389 153.606H225.389Z" fill="#35DBFF" fill-opacity="0.71"/>
39 | <path fill-rule="evenodd" clip-rule="evenodd" d="M122.508 211.245C116.32 214.967 107.324 206.283 99.1548 204.806C97.1481 204.444 94.7604 207.057 94.6253 209.204C94.3705 213.253 98.5864 216.724 102.068 218.406C109.692 222.088 121.728 225.933 127.177 223.837C129.399 222.983 127.997 218.687 127.125 216.394C126.29 214.198 124.476 210.061 122.508 211.245Z" fill="#554539"/>
40 | <path fill-rule="evenodd" clip-rule="evenodd" d="M98.8899 206.703C95.1742 207.232 96.3052 212.119 98.7286 214.097C104.487 218.797 111.395 221.475 118.485 222.729C121.26 223.22 128.766 223.215 130.827 221.357C130.804 217.994 128.107 213.98 125.611 211.83C117.626 216.265 110.766 210.876 105.543 208.515C103.608 207.64 101.01 206.402 98.8899 206.703L98.8899 206.703Z" fill="#35DBFF" fill-opacity="0.71"/>
41 | <path fill-rule="evenodd" clip-rule="evenodd" d="M229.265 212.365C235.991 214.632 243.263 204.115 251.006 200.846C252.908 200.044 255.713 202.072 256.227 204.145C257.196 208.057 253.682 212.399 250.568 214.824C243.752 220.133 232.64 226.584 226.928 225.746C224.599 225.405 225.209 220.882 225.656 218.44C226.084 216.102 227.126 211.644 229.265 212.365Z" fill="#554539"/>
42 | <path fill-rule="evenodd" clip-rule="evenodd" d="M251.599 202.622C255.334 202.312 255.095 207.353 253.072 209.832C248.265 215.721 241.929 219.769 235.247 222.692C232.928 223.706 226.218 224.304 223.811 223.251C223.235 219.95 224.142 216.16 226.207 213.497C235.259 217.479 240.66 209.392 245.401 205.879C247.14 204.59 249.467 202.799 251.599 202.622V202.622Z" fill="#35DBFF" fill-opacity="0.71"/>
43 | <path fill-rule="evenodd" clip-rule="evenodd" d="M191.145 290.107C197.044 293.262 191.667 302.47 193.13 308.73C193.489 310.268 196.93 311.099 199.103 310.491C203.203 309.344 205.131 305.225 205.549 302.211C206.465 295.614 205.963 285.843 201.939 282.677C200.298 281.387 196.547 283.786 194.589 285.155C192.714 286.465 189.269 289.103 191.145 290.107Z" fill="#554539"/>
44 | <path fill-rule="evenodd" clip-rule="evenodd" d="M195.046 308.31C196.903 310.768 201.35 308.361 202.445 305.994C205.047 300.37 205.229 294.598 203.932 289.164C203.424 287.037 200.728 281.723 198.144 280.873C194.813 281.996 191.794 285.225 190.555 287.7C197.822 291.897 194.93 298.528 194.459 303.002C194.284 304.66 193.987 306.908 195.046 308.31L195.046 308.31Z" fill="#35DBFF" fill-opacity="0.71"/>
45 | <path fill-rule="evenodd" clip-rule="evenodd" d="M152.677 288.123C146.779 291.278 152.155 300.486 150.693 306.746C150.334 308.284 146.893 309.116 144.719 308.507C140.619 307.36 138.692 303.241 138.274 300.228C137.357 293.63 137.86 283.86 141.884 280.694C143.524 279.403 147.275 281.803 149.234 283.171C151.109 284.481 154.554 287.12 152.677 288.123Z" fill="#554539"/>
46 | <path fill-rule="evenodd" clip-rule="evenodd" d="M148.777 306.327C146.92 308.785 142.473 306.377 141.378 304.01C138.775 298.387 138.594 292.614 139.891 287.18C140.398 285.053 143.095 279.739 145.679 278.89C149.01 280.012 152.028 283.241 153.268 285.716C146.001 289.913 148.892 296.544 149.364 301.019C149.538 302.677 149.836 304.924 148.777 306.327L148.777 306.327Z" fill="#35DBFF" fill-opacity="0.71"/>
47 | <path d="M169.494 186.346L176.658 185.872C177.762 185.799 178.906 186.683 178.916 187.856C178.937 190.485 179.268 192.006 178.682 196.259C178.53 197.367 177.332 198.512 176.226 198.533L171.299 198.627C170.193 198.649 169.006 197.749 169.078 196.569C169.339 192.307 168.335 190.94 167.766 188.593C167.488 187.448 168.39 186.419 169.494 186.346L169.494 186.346Z" fill="#554539"/>
48 | <path d="M170.215 187.445L176.105 187.056C177.013 186.995 177.92 187.724 177.961 188.687C178.061 191 178.569 193.02 178.045 195.781C177.853 196.794 177.473 197.281 176.624 197.629C174.842 198.36 173.219 197.926 171.531 197.966C170.622 197.988 169.616 197.304 169.675 196.335C169.845 193.547 169.29 191.449 168.794 189.293C168.578 188.349 169.308 187.505 170.215 187.445L170.215 187.445Z" fill="white"/>
49 | <path d="M161.445 184.737C161.837 190.112 167.312 191.113 173.887 190.417C180.462 189.721 185.446 187.496 185.124 183.155C184.7 177.436 179.001 174.029 172.426 174.725C165.852 175.421 160.953 177.985 161.445 184.737Z" fill="#554539"/>
50 | <path d="M163.605 184.475C163.934 188.987 168.53 189.828 174.049 189.243C179.568 188.659 183.752 186.791 183.482 183.147C183.126 178.347 178.342 175.487 172.823 176.071C167.304 176.656 163.192 178.808 163.605 184.475Z" fill="#CEC4AD"/>
51 | <path d="M165.421 176.508C165.549 177.89 166.475 179.131 167.993 179.957C169.512 180.783 171.499 181.128 173.518 180.914C174.517 180.808 175.494 180.568 176.394 180.209C177.293 179.849 178.096 179.376 178.758 178.818C179.42 178.259 179.927 177.625 180.251 176.952C180.574 176.279 180.708 175.581 180.644 174.896C180.516 173.514 179.59 172.274 178.072 171.447C176.553 170.621 174.566 170.277 172.547 170.491C170.528 170.704 168.643 171.458 167.307 172.587C165.97 173.715 165.292 175.126 165.421 176.508Z" fill="#554539"/>
52 | <path d="M188.542 164.364C188.068 171.52 190.875 178.422 195.569 183.718C200.262 189.013 206.858 192.687 214.232 193.265C221.606 193.843 228.368 191.203 233.358 186.623C238.347 182.044 241.54 175.556 242.012 168.405C242.483 161.254 240.244 154.788 236.213 150.028C232.182 145.269 226.271 142.216 218.884 141.67C211.498 141.124 204.052 143.144 198.414 147.154C192.777 151.164 189.017 157.208 188.542 164.364Z" fill="#554539"/>
53 | <path d="M191.392 163.487C190.885 170.01 193.373 176.321 197.604 181.17C201.834 186.019 207.817 189.394 214.52 189.965C221.223 190.536 227.383 188.184 231.953 184.051C236.523 179.917 239.486 174.027 239.99 167.508C240.493 160.99 238.522 155.076 234.88 150.705C231.239 146.335 225.852 143.502 219.139 142.957C212.425 142.413 205.669 144.227 200.523 147.854C195.377 151.481 191.899 156.964 191.392 163.487V163.487Z" fill="white"/>
54 | <path d="M107.195 166.333C107.032 173.672 109.946 180.173 114.729 184.942C119.511 189.711 126.164 192.752 133.558 193.047C140.952 193.343 147.691 190.833 152.605 186.444C157.519 182.055 160.6 175.788 160.759 168.453C160.919 161.118 158.161 154.045 153.56 148.622C148.959 143.199 142.483 139.49 135.075 139.198C127.668 138.906 120.749 142.082 115.669 147.118C110.589 152.154 107.359 158.994 107.195 166.333V166.333Z" fill="#554539"/>
55 | <path d="M109.607 165.515C109.433 172.413 112.13 178.536 116.575 183.034C121.021 187.532 127.216 190.41 134.106 190.71C140.996 191.01 147.278 188.672 151.868 184.562C156.457 180.451 159.347 174.567 159.519 167.671C159.692 160.775 157.142 154.125 152.861 149.036C148.581 143.947 142.542 140.474 135.639 140.178C128.737 139.882 122.291 142.815 117.549 147.51C112.808 152.206 109.78 158.616 109.607 165.515V165.515Z" fill="white"/>
56 | <path d="M127.106 170.538C123.188 170.98 119.712 167.99 119.342 163.859C118.971 159.729 121.847 156.022 125.765 155.579C129.683 155.137 133.159 158.127 133.529 162.258C133.9 166.389 131.024 170.096 127.106 170.538Z" fill="#554539"/>
57 | <path d="M130.662 164.894C127.924 165.203 125.494 163.113 125.235 160.226C124.976 157.339 126.986 154.748 129.725 154.439C132.463 154.13 134.892 156.22 135.151 159.107C135.41 161.994 133.4 164.585 130.662 164.894Z" fill="white"/>
58 | <path d="M224.1 170.288C220.182 170.73 216.706 167.74 216.336 163.609C215.965 159.478 218.841 155.771 222.759 155.329C226.677 154.887 230.153 157.877 230.523 162.008C230.894 166.138 228.018 169.846 224.1 170.288Z" fill="#554539"/>
59 | <path d="M227.518 165.077C224.78 165.386 222.35 163.296 222.092 160.409C221.833 157.522 223.843 154.931 226.581 154.622C229.319 154.313 231.749 156.403 232.008 159.29C232.266 162.177 230.256 164.768 227.518 165.077Z" fill="white"/>
60 | <path d="M135.105 140.058C135.173 139.929 135.248 139.804 135.309 139.672C135.525 139.209 135.669 138.796 135.825 138.297C136.067 137.521 136.256 136.827 136.395 136.015C136.477 135.54 136.521 135.058 136.584 134.58C136.605 134.062 136.651 133.545 136.646 133.027C136.621 130.677 136.124 128.324 135.277 126.157C135.025 125.513 134.718 124.895 134.439 124.264C133.455 122.514 133.221 121.982 132.03 120.339C131.541 119.664 131.003 119.031 130.49 118.377C130.416 118.269 128.993 119.385 129.067 119.492C129.572 120.104 130.098 120.696 130.582 121.326C131.75 122.846 132.003 123.353 132.988 124.965C133.271 125.542 133.584 126.104 133.838 126.696C134.68 128.66 135.175 130.888 135.243 133.046C135.258 133.527 135.228 134.008 135.22 134.488C135.178 134.937 135.15 135.387 135.094 135.834C134.934 137.109 134.633 138.36 134.306 139.595C134.276 139.655 135.075 140.118 135.105 140.058H135.105Z" fill="#554539"/>
61 | <path d="M120.612 144.1C118.739 142.461 116.489 140.058 114.594 137.387C113.167 135.318 112.749 134.544 111.721 132.388C111.022 130.922 110.375 129.464 109.852 128.119C109.295 126.685 109.28 126.446 108.969 125.245C108.947 125.146 107.678 125.57 107.701 125.669C107.991 127.028 108.006 127.332 108.572 128.948C109.652 132.029 111.21 135.485 113.43 138.517C114.862 140.373 116.487 142.088 118.056 143.413C118.578 143.853 119.126 144.273 119.646 144.602C119.767 144.679 119.893 144.741 120.015 144.809C120.069 144.854 120.667 144.147 120.612 144.1V144.1Z" fill="#554539"/>
62 | <path d="M110.802 153.637C110.699 153.583 110.595 153.534 110.494 153.475C109.999 153.187 109.635 152.936 109.146 152.588C108.349 152.021 107.515 151.402 106.767 150.768C106.29 150.363 105.835 149.93 105.369 149.512C103.438 147.701 101.658 145.693 100.272 143.373C99.4127 141.933 99.3454 141.638 98.6992 140.119C98.0618 138.172 98.3247 139.136 97.8965 137.232C97.8749 137.129 96.5075 137.455 96.5291 137.558C96.9231 139.647 96.6754 138.589 97.2861 140.729C97.518 141.314 97.7206 141.913 97.9816 142.484C98.8467 144.375 99.9914 146.137 101.306 147.703C102.381 148.984 103.061 149.572 104.252 150.711C104.76 151.127 105.255 151.564 105.777 151.961C106.622 152.603 107.483 153.153 108.401 153.662C108.859 153.915 109.505 154.235 110.018 154.415C110.145 154.46 110.277 154.48 110.407 154.512C110.465 154.542 110.86 153.667 110.802 153.637V153.637Z" fill="#554539"/>
63 | <path d="M240.519 159.545C241.713 159.638 242.906 159.29 244.016 158.854C244.531 158.652 245.041 158.434 245.535 158.182C246.072 157.909 246.582 157.582 247.105 157.282C247.612 156.926 248.14 156.602 248.625 156.213C250.536 154.683 252.058 152.666 252.831 150.231C253.016 149.649 253.106 149.036 253.243 148.439C253.273 148.319 251.693 147.86 251.662 147.979C251.552 148.494 251.486 149.022 251.331 149.522C250.66 151.685 249.251 153.446 247.566 154.797C247.111 155.161 246.62 155.47 246.146 155.807C245.665 156.101 245.191 156.41 244.702 156.688C243.341 157.46 241.891 158.162 240.356 158.413C240.281 158.425 240.444 159.557 240.52 159.545H240.519Z" fill="#554539"/>
64 | <path d="M236.934 151.3C238.022 150.996 239.046 150.483 240.037 149.925C240.417 149.711 240.798 149.496 241.168 149.263C241.566 149.013 241.951 148.739 242.342 148.476C243.349 147.682 243.772 147.415 244.654 146.443C245.846 145.128 246.789 143.551 247.496 141.89C247.769 141.246 247.977 140.572 248.217 139.913C248.952 137.135 248.644 138.534 249.145 135.717C249.173 135.587 247.448 135.161 247.419 135.291C246.949 137.938 247.229 136.622 246.58 139.238C246.057 140.819 245.978 141.267 245.237 142.719C244.29 144.574 243.013 145.977 241.397 147.179C241.029 147.437 240.666 147.703 240.294 147.953C239.063 148.778 237.787 149.528 236.491 150.23C236.42 150.263 236.863 151.333 236.934 151.3V151.3Z" fill="#554539"/>
65 | <path d="M228.589 144.687C229.564 142.958 230.575 141.252 231.531 139.51C233.747 135.275 235.293 130.691 236.874 126.158C236.93 126.002 238.996 126.844 238.94 127C238.548 128.024 238.171 129.056 237.763 130.074C236.353 133.6 234.75 137.043 232.869 140.311C231.832 142.062 230.783 143.824 229.487 145.374C229.441 145.442 228.543 144.755 228.589 144.687V144.687Z" fill="#554539"/>
66 | <g opacity="0.07">
67 | <path d="M161.668 130.423C158.609 130.807 155.572 131.386 152.58 132.221C146.898 133.69 141.09 135.371 136.076 138.649C135.757 139.8 137.682 139.521 138.325 139.841C140.511 140.198 142.618 140.898 144.605 141.877C149.119 138.168 154.777 134.348 161.668 130.423ZM120.528 189.389C120.32 189.408 120.146 189.521 120.031 189.784C121.719 197.033 124.224 204.114 125.169 211.527C127.583 213.167 128.255 212.913 127.345 214.73C126.551 216.317 124.168 216.217 119.933 216.878C115.698 217.539 107.798 214.729 102.667 212.415C99.324 210.908 96.7783 208.804 97.4584 206.812C96.0188 207.886 96.1371 210.662 97.1935 212.124C100.06 216.267 104.814 218.228 109.076 220.28C114.864 222.901 121.218 223.55 127.446 223.17C128.046 223.113 127.093 224.315 127.295 224.918C126.637 234.456 126.21 244.023 125.9 253.582C125.711 261.584 126.858 270.071 131.596 276.561C133.735 279.579 136.236 282.505 139.303 284.436C140.556 284.218 140.472 282.185 141.586 281.596C141.992 281.172 143.085 280.282 143.4 280.593C139.914 284.798 138.689 290.555 139.118 296.048C139.497 299.924 140.19 304.808 143.796 306.781C145.342 307.644 147.607 308.111 148.699 306.229C150.138 304.223 149.175 301.422 149.133 299.115C148.465 295.185 147.973 290.399 151.211 287.52C151.677 286.777 153.37 285.8 152.968 287.48C152.474 288.419 150.487 288.865 150.859 290.138C153.331 291.381 156.255 291.421 158.917 292.057C167.055 293.412 175.365 293.582 183.575 293.046C186.514 292.597 189.585 292.453 192.389 291.387C193 290.089 189.781 289.911 190.991 288.543C193.334 289.326 194.729 292.153 195.155 294.638C195.734 299.079 193.268 303.73 195.001 308.053C196.651 310.779 200.333 309.224 201.941 307.24C205.101 302.646 205.014 296.493 204.376 291.084C203.971 288.448 202.525 285.867 201.225 283.733C201.457 284.964 201.628 286.184 202.152 287.13C203.425 289.427 204.472 304.446 201.531 306.386C199.392 307.797 197.064 307.931 197.967 304.485C199.099 300.169 198.974 289.527 197.734 287.378C196.728 285.634 195.925 286.393 193.92 284.666C184.344 287.399 173.431 287.565 161.07 283.108C142.767 276.508 139.369 256.459 139.807 246.874C140.246 237.29 145.069 230.511 143.315 212.979C142.631 206.143 140.544 199.207 138.256 192.49C132.953 192.993 127.534 192.624 122.669 190.172C122.084 190.113 121.151 189.332 120.528 189.389V189.389ZM217.949 271.452C212.896 275.577 207.209 279.391 200.858 282.165C200.906 282.322 200.949 282.482 200.989 282.643C202.531 283.298 203.196 285.173 204.235 286.413C205.74 286.74 206.906 284.982 208.112 284.237C212.164 280.685 215.388 276.285 217.949 271.452V271.452ZM149.661 282.681C151.468 282.711 151.684 283.977 151.863 285.211C152.082 286.71 149.891 288.017 149.014 288.601C148.137 289.186 147.59 293.16 147.918 296.783C148.247 300.406 148.685 302.393 148.247 304.263C147.808 306.133 146.493 304.848 145.397 303.679C144.301 302.51 142.438 295.965 142.438 291.524C142.438 287.082 145.617 283.458 148.138 282.874C148.743 282.734 149.244 282.674 149.661 282.681V282.681Z" fill="black"/>
68 | <path d="M135.332 139.993C135.01 139.987 134.688 139.989 134.365 139.999C121.618 140.143 109.71 151.81 109.469 165.597C109.082 176.057 116.246 185.513 125.253 188.958C130.562 191.341 136.505 191.084 142.065 190.043C146.131 189.003 149.924 186.741 152.945 183.653C150.136 185.157 148.771 185.945 142.553 187.042C128.725 189.483 119.149 181.423 116.669 171.34C113.853 159.894 116.612 146.662 136.956 140.241C136.517 140.204 135.775 140.001 135.332 139.993V139.993Z" fill="black"/>
69 | <path d="M210.849 143.315C203.444 144.797 196.438 149.354 193.001 156.613C189.43 164.442 191.544 174.247 196.906 180.555C203.391 188.671 214.457 192.345 224.027 188.966C228.565 187.472 232.531 184.35 235.402 180.343C230.774 182.198 225.028 183.941 219.279 184.233C206.259 184.894 198.686 176.491 197.889 164.893C197.317 156.571 200.667 147.207 210.849 143.315V143.315Z" fill="black"/>
70 | <path d="M138.054 234.017C138.821 233.9 151.516 229.228 158.33 231.212C159.106 231.438 160.751 231.39 161.509 231.68C164.897 232.976 168.284 232.663 171.805 232.719C175.43 232.777 179.19 233.17 182.771 232.147C183.831 231.845 184.543 230.606 185.621 230.394C190.86 229.363 196.233 231.715 201.404 233.082C207.134 234.597 213.024 236.08 218.173 239.16C220.661 240.649 222.118 243.827 224.749 245.004C225.088 245.156 225.584 245.397 225.845 245.121C227.851 243.001 225.845 236.121 225.078 236.121C224.311 236.121 198.116 227.355 195.047 226.654C191.978 225.953 176.962 224.667 174.99 224.55C173.017 224.433 161.299 224.02 154.494 224.667C149.618 225.13 144.439 225.095 140.027 227.355C139.28 227.738 138.163 228.641 138.163 229.108C138.163 229.576 136.564 233.622 138.054 234.017C138.054 234.017 131.061 235.083 138.054 234.017V234.017Z" fill="black"/>
71 | <path d="M141.561 219.991L158.878 223.965C158.878 223.965 193.293 224.433 193.951 224.433C194.608 224.433 211.049 223.264 216.529 220.927C222.009 218.589 230.448 213.68 230.448 213.68L229.133 213.095C229.133 213.095 234.832 211.693 213.241 213.446C191.649 215.199 179.483 220.108 170.167 220.108C160.851 220.108 156.029 220.225 151.973 219.524C147.918 218.823 137.396 215.901 137.396 215.901L141.561 219.991Z" fill="black"/>
72 | <path d="M254.301 204.737C253.489 204.956 252.724 205.379 252.026 205.87C250.657 206.985 249.551 208.415 248.266 209.633C246.295 211.525 244.127 213.151 241.904 214.688C240.059 215.913 238.215 217.115 236.206 218.01C233.895 218.968 231.4 219.35 229.01 220.122C227.859 220.501 226.716 221.073 225.944 222.095C225.601 222.55 225.211 223.059 225.157 223.659C225.257 224.127 225.809 223.987 226.138 224.064C228.977 224.224 231.858 224.094 234.622 223.34C236.378 222.705 238.056 221.844 239.722 220.982C244.88 218.219 249.732 214.605 253.446 209.85C254.399 208.49 254.883 206.731 254.696 205.04C254.651 204.855 254.483 204.718 254.301 204.737V204.737Z" fill="black"/>
73 | <path d="M118.371 128.201C116.034 128.197 113.636 129.21 112.176 131.203C110.759 133.099 110.28 135.696 110.819 138.041C111.091 139.207 111.498 140.356 112.088 141.382C112.849 142.639 114.206 143.339 115.572 143.493C117.147 143.695 118.732 143.446 120.308 143.391C121.266 143.313 122.243 143.293 123.183 143.101C124.071 142.358 124.914 141.561 125.827 140.857C125.953 140.755 126.083 140.659 126.21 140.559C124.451 140.477 122.721 140.479 121.241 140.636C115.39 141.256 114.112 139.686 113.065 137.909C112.141 136.339 112.527 132.125 118.371 128.201Z" fill="black"/>
74 | <path d="M225.506 130.286C223.691 130.913 222.022 132.031 220.711 133.511C219.008 135.395 217.724 137.658 216.588 139.962C216.475 140.409 216.992 140.599 217.229 140.861C217.569 141.138 217.902 141.424 218.235 141.71L218.697 141.669L220.63 141.884C220.251 140.996 220.213 139.866 220.287 138.942C220.383 137.742 220.674 136.544 220.79 135.594C220.865 134.982 222.268 132.927 225.506 130.286V130.286ZM235.961 139.786C234.997 139.828 234.107 141.17 232.842 141.876C231.017 142.894 228.967 142.867 226.72 143.239C226.599 143.259 226.505 143.272 226.389 143.291L229.833 144.899C230.19 144.841 230.548 144.782 230.904 144.723C232.343 144.479 233.824 143.952 234.815 142.754C235.521 141.944 235.776 140.856 235.961 139.786V139.786Z" fill="black"/>
75 | </g>
76 | <path fill-rule="evenodd" clip-rule="evenodd" d="M183.977 215.817C183.977 215.817 197.877 215.3 205.196 213.819C212.75 212.291 221.241 209.461 228.502 206.762C230.115 206.162 231.623 205.364 231.807 205.081C232.394 205.03 232.736 205.139 233.053 205.631C233.513 206.345 233.266 207.776 233.154 208.781C232.981 210.337 232.181 212.544 232.181 212.544C232.181 212.544 227.156 215.212 224.603 216.107C217.51 218.593 210.336 221.04 202.955 222.244C196.729 223.26 184.076 223.126 184.076 223.126L183.977 215.817Z" fill="#4B2E2C"/>
77 | <path fill-rule="evenodd" clip-rule="evenodd" d="M161.049 222.316C161.049 222.316 140.724 226.199 133.278 228.019C129.518 228.938 128.009 229.973 124.378 232.818C122.681 234.148 120.646 237.003 120.519 239.463C120.431 241.179 120.143 242.968 120.755 244.446C122.786 244.848 124.838 239.905 126.982 238.183C131.355 234.672 132.075 233.611 138.017 232.035C144.707 230.26 161.68 229.091 161.68 229.091L162.481 225.322L161.049 222.316Z" fill="#4B2E2C"/>
78 | <path d="M182.766 214.424C175.045 214.564 168.544 214.574 162.661 214.519C161.35 214.506 160.547 215.679 160.305 217.054C159.731 220.312 159.92 224.238 160.352 228.376C160.497 229.766 161.421 230.797 162.729 230.889C169.477 231.363 176.206 231.618 182.834 230.795C184.136 230.633 184.87 229.616 185.19 228.26C186.07 224.526 186.43 220.769 185.143 216.937C184.701 215.62 184.077 214.4 182.766 214.424L182.766 214.424Z" fill="#4B2E2C"/>
79 | <path d="M181.551 216.053C174.833 216.228 169.177 216.291 164.059 216.297C162.919 216.298 162.212 217.233 161.991 218.323C161.467 220.907 161.603 224.013 161.948 227.285C162.064 228.383 162.86 229.192 163.997 229.254C169.865 229.572 175.717 229.717 181.489 229.01C182.623 228.871 183.269 228.06 183.558 226.984C184.351 224.022 184.692 221.045 183.601 218.022C183.226 216.984 182.692 216.023 181.551 216.053H181.551Z" fill="#7A4B47"/>
80 | <path fill-rule="evenodd" clip-rule="evenodd" d="M162.254 214.79C163.007 216.569 144.343 214.661 129.984 207.066C125.927 204.92 123.738 202.824 120.197 201.093C119.536 201.185 119.15 201.65 119.117 202.304C119.038 203.892 119.249 207.307 121.742 210.977C126.009 212.937 132.761 215.516 139 218.143C145.257 220.567 161.114 223.011 161.114 223.011L162.254 214.79Z" fill="#4B2E2C"/>
81 | <path fill-rule="evenodd" clip-rule="evenodd" d="M184.284 222.856C184.284 222.856 203.223 224.872 212.212 227.963C217.736 229.862 228.695 236.237 228.695 236.237C228.695 236.237 229.405 237.494 229.648 239.14C229.876 240.688 230.26 243.823 229.141 244.839C228.66 245.276 228.138 245.579 227.507 245.377C227.1 244.152 225.211 242.135 224.055 241.471C220.542 239.454 217.189 237.291 213.52 235.764C208.193 233.547 202.606 232.046 197.006 230.813C192.734 229.872 184.037 228.961 184.037 228.961L184.284 222.856Z" fill="#4B2E2C"/>
82 | <path d="M171.868 222.517C172.091 222.495 172.21 222.579 172.224 222.771L172.537 226.824C172.202 226.976 171.824 227.107 171.403 227.218C170.991 227.327 170.539 227.407 170.047 227.457C169.323 227.531 168.705 227.51 168.191 227.394C167.686 227.278 167.267 227.056 166.933 226.728C166.608 226.392 166.354 225.951 166.172 225.406C165.999 224.861 165.882 224.192 165.821 223.4C165.757 222.566 165.773 221.858 165.868 221.277C165.972 220.686 166.164 220.2 166.443 219.818C166.722 219.437 167.093 219.147 167.554 218.948C168.015 218.742 168.579 218.604 169.247 218.536C169.721 218.488 170.136 218.479 170.494 218.509C170.86 218.531 171.129 218.566 171.301 218.616C171.416 218.646 171.489 218.689 171.522 218.745C171.563 218.8 171.588 218.885 171.597 219.002L171.641 219.565C171.369 219.559 171.038 219.564 170.646 219.578C170.263 219.584 169.905 219.604 169.571 219.638C169.098 219.686 168.702 219.773 168.385 219.897C168.066 220.014 167.819 220.203 167.643 220.465C167.467 220.727 167.349 221.075 167.289 221.51C167.238 221.944 167.239 222.498 167.291 223.174C167.347 223.908 167.444 224.495 167.58 224.935C167.717 225.366 167.896 225.697 168.12 225.926C168.342 226.147 168.61 226.284 168.923 226.336C169.244 226.387 169.614 226.391 170.032 226.349C170.245 226.327 170.444 226.303 170.629 226.275C170.823 226.239 170.993 226.2 171.139 226.16L170.949 223.696L169.752 223.818C169.669 223.826 169.597 223.808 169.538 223.764C169.478 223.72 169.445 223.652 169.438 223.56L169.377 222.772L171.868 222.517L171.868 222.517Z" fill="#4B2E2C"/>
83 | <path d="M176.976 226.814C175.929 226.921 175.148 226.732 174.634 226.247C174.13 225.761 173.833 224.939 173.744 223.781C173.655 222.632 173.822 221.767 174.244 221.186C174.676 220.605 175.415 220.261 176.463 220.154C177.51 220.047 178.286 220.236 178.791 220.722C179.304 221.207 179.606 222.024 179.694 223.174C179.783 224.332 179.612 225.202 179.181 225.783C178.758 226.363 178.023 226.707 176.976 226.814ZM178.276 223.319C178.241 222.869 178.18 222.497 178.092 222.204C178.013 221.91 177.902 221.682 177.759 221.52C177.624 221.349 177.452 221.236 177.243 221.182C177.042 221.127 176.808 221.113 176.539 221.141C176.27 221.168 176.037 221.23 175.838 221.326C175.65 221.42 175.497 221.566 175.382 221.763C175.275 221.95 175.2 222.197 175.158 222.503C175.126 222.809 175.127 223.187 175.162 223.637C175.197 224.095 175.254 224.475 175.334 224.778C175.422 225.071 175.533 225.303 175.668 225.474C175.811 225.636 175.983 225.744 176.183 225.799C176.392 225.845 176.631 225.854 176.9 225.827C177.169 225.799 177.398 225.742 177.587 225.656C177.786 225.56 177.938 225.419 178.045 225.231C178.161 225.035 178.235 224.784 178.267 224.478C178.308 224.163 178.311 223.777 178.276 223.319Z" fill="#4B2E2C"/>
84 | <path d="M59.1592 50.6904C55.7822 49.7197 53.3213 48.5303 51.7764 47.1221C50.2451 45.7002 49.4795 43.9502 49.4795 41.8721C49.4795 39.5205 50.416 37.5791 52.2891 36.0479C54.1758 34.5029 56.623 33.7305 59.6309 33.7305C61.6816 33.7305 63.5068 34.127 65.1064 34.9199C66.7197 35.7129 67.9639 36.8066 68.8389 38.2012C69.7275 39.5957 70.1719 41.1201 70.1719 42.7744H66.2139C66.2139 40.9697 65.6396 39.5547 64.4912 38.5293C63.3428 37.4902 61.7227 36.9707 59.6309 36.9707C57.6895 36.9707 56.1719 37.4014 55.0781 38.2627C53.998 39.1104 53.458 40.293 53.458 41.8105C53.458 43.0273 53.9707 44.0596 54.9961 44.9072C56.0352 45.7412 57.792 46.5068 60.2666 47.2041C62.7549 47.9014 64.6963 48.6738 66.0908 49.5215C67.499 50.3555 68.5381 51.333 69.208 52.4541C69.8916 53.5752 70.2334 54.8945 70.2334 56.4121C70.2334 58.832 69.29 60.7734 67.4033 62.2363C65.5166 63.6855 62.9941 64.4102 59.8359 64.4102C57.7852 64.4102 55.8711 64.0205 54.0938 63.2412C52.3164 62.4482 50.9424 61.3682 49.9717 60.001C49.0146 58.6338 48.5361 57.082 48.5361 55.3457H52.4941C52.4941 57.1504 53.1572 58.5791 54.4834 59.6318C55.8232 60.6709 57.6074 61.1904 59.8359 61.1904C61.9141 61.1904 63.5068 60.7666 64.6143 59.9189C65.7217 59.0713 66.2754 57.916 66.2754 56.4531C66.2754 54.9902 65.7627 53.8623 64.7373 53.0693C63.7119 52.2627 61.8525 51.4697 59.1592 50.6904ZM93.4482 53.1514C93.4482 56.5283 92.6758 59.249 91.1309 61.3135C89.5859 63.3779 87.4941 64.4102 84.8555 64.4102C82.1621 64.4102 80.043 63.5557 78.498 61.8467V72.5312H74.7041V41.8105H78.1699L78.3545 44.2715C79.8994 42.3574 82.0459 41.4004 84.7939 41.4004C87.46 41.4004 89.5654 42.4053 91.1104 44.415C92.6689 46.4248 93.4482 49.2207 93.4482 52.8027V53.1514ZM89.6543 52.7207C89.6543 50.2188 89.1211 48.2432 88.0547 46.7939C86.9883 45.3447 85.5254 44.6201 83.666 44.6201C81.3691 44.6201 79.6465 45.6387 78.498 47.6758V58.2783C79.6328 60.3018 81.3691 61.3135 83.707 61.3135C85.5254 61.3135 86.9678 60.5957 88.0342 59.1602C89.1143 57.7109 89.6543 55.5645 89.6543 52.7207ZM111.987 64C111.769 63.5625 111.591 62.7832 111.454 61.6621C109.69 63.4941 107.585 64.4102 105.138 64.4102C102.95 64.4102 101.152 63.7949 99.7441 62.5645C98.3496 61.3203 97.6523 59.748 97.6523 57.8477C97.6523 55.5371 98.5273 53.7461 100.277 52.4746C102.041 51.1895 104.516 50.5469 107.701 50.5469H111.393V48.8037C111.393 47.4775 110.996 46.4248 110.203 45.6455C109.41 44.8525 108.241 44.4561 106.696 44.4561C105.343 44.4561 104.208 44.7979 103.292 45.4814C102.376 46.165 101.918 46.9922 101.918 47.9629H98.1035C98.1035 46.8555 98.4932 45.7891 99.2725 44.7637C100.065 43.7246 101.132 42.9043 102.472 42.3027C103.825 41.7012 105.309 41.4004 106.922 41.4004C109.479 41.4004 111.481 42.043 112.931 43.3281C114.38 44.5996 115.132 46.3564 115.187 48.5986V58.8115C115.187 60.8486 115.446 62.4688 115.966 63.6719V64H111.987ZM105.691 61.1084C106.881 61.1084 108.009 60.8008 109.075 60.1855C110.142 59.5703 110.914 58.7705 111.393 57.7861V53.2334H108.419C103.771 53.2334 101.446 54.5938 101.446 57.3145C101.446 58.5039 101.843 59.4336 102.636 60.1035C103.429 60.7734 104.447 61.1084 105.691 61.1084ZM130.034 61.3135C131.388 61.3135 132.57 60.9033 133.582 60.083C134.594 59.2627 135.154 58.2373 135.264 57.0068H138.853C138.784 58.2783 138.347 59.4883 137.54 60.6367C136.733 61.7852 135.653 62.7012 134.3 63.3848C132.96 64.0684 131.538 64.4102 130.034 64.4102C127.013 64.4102 124.606 63.4053 122.815 61.3955C121.038 59.3721 120.149 56.6104 120.149 53.1104V52.4746C120.149 50.3145 120.546 48.3936 121.339 46.7119C122.132 45.0303 123.267 43.7246 124.743 42.7949C126.233 41.8652 127.99 41.4004 130.014 41.4004C132.502 41.4004 134.566 42.1455 136.207 43.6357C137.861 45.126 138.743 47.0605 138.853 49.4395H135.264C135.154 48.0039 134.607 46.8281 133.623 45.9121C132.652 44.9824 131.449 44.5176 130.014 44.5176C128.086 44.5176 126.589 45.2148 125.522 46.6094C124.47 47.9902 123.943 49.9932 123.943 52.6182V53.3359C123.943 55.8926 124.47 57.8613 125.522 59.2422C126.575 60.623 128.079 61.3135 130.034 61.3135ZM152.326 64.4102C149.318 64.4102 146.871 63.4258 144.984 61.457C143.098 59.4746 142.154 56.8291 142.154 53.5205V52.8232C142.154 50.6221 142.571 48.6602 143.405 46.9375C144.253 45.2012 145.429 43.8477 146.933 42.877C148.45 41.8926 150.091 41.4004 151.854 41.4004C154.739 41.4004 156.981 42.3506 158.581 44.251C160.181 46.1514 160.98 48.8721 160.98 52.4131V53.9922H145.948C146.003 56.1797 146.639 57.9502 147.855 59.3037C149.086 60.6436 150.645 61.3135 152.531 61.3135C153.871 61.3135 155.006 61.04 155.936 60.4932C156.865 59.9463 157.679 59.2217 158.376 58.3193L160.693 60.124C158.834 62.9814 156.045 64.4102 152.326 64.4102ZM151.854 44.5176C150.323 44.5176 149.038 45.0781 147.999 46.1992C146.96 47.3066 146.317 48.8652 146.071 50.875H157.187V50.5879C157.077 48.6602 156.558 47.1699 155.628 46.1172C154.698 45.0508 153.44 44.5176 151.854 44.5176ZM178.31 58.1143C178.31 57.0889 177.92 56.2959 177.141 55.7354C176.375 55.1611 175.028 54.6689 173.101 54.2588C171.187 53.8486 169.662 53.3564 168.527 52.7822C167.406 52.208 166.572 51.5244 166.025 50.7314C165.492 49.9385 165.226 48.9951 165.226 47.9014C165.226 46.083 165.991 44.5449 167.522 43.2871C169.067 42.0293 171.036 41.4004 173.429 41.4004C175.944 41.4004 177.981 42.0498 179.54 43.3486C181.112 44.6475 181.898 46.3086 181.898 48.332H178.084C178.084 47.293 177.64 46.3975 176.751 45.6455C175.876 44.8936 174.769 44.5176 173.429 44.5176C172.048 44.5176 170.968 44.8184 170.188 45.4199C169.409 46.0215 169.02 46.8076 169.02 47.7783C169.02 48.6943 169.382 49.3848 170.106 49.8496C170.831 50.3145 172.137 50.7588 174.023 51.1826C175.924 51.6064 177.462 52.1123 178.638 52.7002C179.813 53.2881 180.682 53.999 181.242 54.833C181.816 55.6533 182.104 56.6582 182.104 57.8477C182.104 59.8301 181.311 61.4229 179.725 62.626C178.139 63.8154 176.081 64.4102 173.552 64.4102C171.774 64.4102 170.202 64.0957 168.835 63.4668C167.468 62.8379 166.395 61.9629 165.615 60.8418C164.85 59.707 164.467 58.4834 164.467 57.1709H168.261C168.329 58.4424 168.835 59.4541 169.778 60.2061C170.735 60.9443 171.993 61.3135 173.552 61.3135C174.987 61.3135 176.136 61.0264 176.997 60.4521C177.872 59.8643 178.31 59.085 178.31 58.1143ZM190.84 44.4971C192.521 42.4326 194.709 41.4004 197.402 41.4004C202.092 41.4004 204.457 44.0459 204.498 49.3369V64H200.704V49.3164C200.69 47.7168 200.321 46.5342 199.597 45.7686C198.886 45.0029 197.771 44.6201 196.254 44.6201C195.023 44.6201 193.943 44.9482 193.014 45.6045C192.084 46.2607 191.359 47.1221 190.84 48.1885V64H187.046V32.5H190.84V44.4971ZM214.301 64H210.507V41.8105H214.301V64ZM210.199 35.9248C210.199 35.3096 210.384 34.79 210.753 34.3662C211.136 33.9424 211.696 33.7305 212.435 33.7305C213.173 33.7305 213.733 33.9424 214.116 34.3662C214.499 34.79 214.69 35.3096 214.69 35.9248C214.69 36.54 214.499 37.0527 214.116 37.4629C213.733 37.873 213.173 38.0781 212.435 38.0781C211.696 38.0781 211.136 37.873 210.753 37.4629C210.384 37.0527 210.199 36.54 210.199 35.9248ZM239.136 53.1514C239.136 56.5283 238.363 59.249 236.818 61.3135C235.273 63.3779 233.182 64.4102 230.543 64.4102C227.85 64.4102 225.73 63.5557 224.186 61.8467V72.5312H220.392V41.8105H223.857L224.042 44.2715C225.587 42.3574 227.733 41.4004 230.481 41.4004C233.147 41.4004 235.253 42.4053 236.798 44.415C238.356 46.4248 239.136 49.2207 239.136 52.8027V53.1514ZM235.342 52.7207C235.342 50.2188 234.809 48.2432 233.742 46.7939C232.676 45.3447 231.213 44.6201 229.354 44.6201C227.057 44.6201 225.334 45.6387 224.186 47.6758V58.2783C225.32 60.3018 227.057 61.3135 229.395 61.3135C231.213 61.3135 232.655 60.5957 233.722 59.1602C234.802 57.7109 235.342 55.5645 235.342 52.7207ZM277.034 60.083C276.022 61.5322 274.607 62.6191 272.789 63.3438C270.984 64.0547 268.879 64.4102 266.473 64.4102C264.039 64.4102 261.879 63.8428 259.992 62.708C258.105 61.5596 256.643 59.9326 255.604 57.8271C254.578 55.7217 254.052 53.2812 254.024 50.5059V47.9014C254.024 43.4033 255.07 39.917 257.162 37.4424C259.268 34.9678 262.221 33.7305 266.021 33.7305C269.139 33.7305 271.647 34.5303 273.548 36.1299C275.448 37.7158 276.61 39.9717 277.034 42.8975H273.097C272.358 38.9463 270.007 36.9707 266.042 36.9707C263.403 36.9707 261.4 37.9004 260.033 39.7598C258.68 41.6055 257.996 44.2852 257.982 47.7988V50.2393C257.982 53.5889 258.748 56.2549 260.279 58.2373C261.811 60.2061 263.882 61.1904 266.493 61.1904C267.97 61.1904 269.262 61.0264 270.369 60.6982C271.477 60.3701 272.393 59.8164 273.117 59.0371V52.3311H266.206V49.1318H277.034V60.083ZM282.018 52.7002C282.018 50.5264 282.441 48.5713 283.289 46.835C284.15 45.0986 285.34 43.7588 286.857 42.8154C288.389 41.8721 290.132 41.4004 292.087 41.4004C295.108 41.4004 297.549 42.4463 299.408 44.5381C301.281 46.6299 302.218 49.4121 302.218 52.8848V53.1514C302.218 55.3115 301.801 57.2529 300.967 58.9756C300.146 60.6846 298.964 62.0176 297.419 62.9746C295.888 63.9316 294.124 64.4102 292.128 64.4102C289.12 64.4102 286.68 63.3643 284.807 61.2725C282.947 59.1807 282.018 56.4121 282.018 52.9668V52.7002ZM285.832 53.1514C285.832 55.6123 286.399 57.5879 287.534 59.0781C288.683 60.5684 290.214 61.3135 292.128 61.3135C294.056 61.3135 295.587 60.5615 296.722 59.0576C297.856 57.54 298.424 55.4209 298.424 52.7002C298.424 50.2666 297.843 48.2979 296.681 46.7939C295.532 45.2764 294.001 44.5176 292.087 44.5176C290.214 44.5176 288.703 45.2627 287.555 46.7529C286.406 48.2432 285.832 50.376 285.832 53.1514Z" fill="white"/>
85 | <path d="M94.0664 400.547H86.918L85.3125 405H82.9922L89.5078 387.938H91.4766L98.0039 405H95.6953L94.0664 400.547ZM87.5977 398.695H93.3984L90.4922 390.715L87.5977 398.695ZM108.152 392.32V406.465C108.152 408.902 107.047 410.121 104.836 410.121C104.359 410.121 103.918 410.051 103.512 409.91V408.176C103.762 408.238 104.09 408.27 104.496 408.27C104.98 408.27 105.348 408.137 105.598 407.871C105.855 407.613 105.984 407.16 105.984 406.512V392.32H108.152ZM105.762 388.957C105.762 388.613 105.867 388.32 106.078 388.078C106.297 387.828 106.613 387.703 107.027 387.703C107.449 387.703 107.77 387.824 107.988 388.066C108.207 388.309 108.316 388.605 108.316 388.957C108.316 389.309 108.207 389.602 107.988 389.836C107.77 390.07 107.449 390.188 107.027 390.188C106.605 390.188 106.289 390.07 106.078 389.836C105.867 389.602 105.762 389.309 105.762 388.957ZM111.082 398.543C111.082 397.301 111.324 396.184 111.809 395.191C112.301 394.199 112.98 393.434 113.848 392.895C114.723 392.355 115.719 392.086 116.836 392.086C118.562 392.086 119.957 392.684 121.02 393.879C122.09 395.074 122.625 396.664 122.625 398.648V398.801C122.625 400.035 122.387 401.145 121.91 402.129C121.441 403.105 120.766 403.867 119.883 404.414C119.008 404.961 118 405.234 116.859 405.234C115.141 405.234 113.746 404.637 112.676 403.441C111.613 402.246 111.082 400.664 111.082 398.695V398.543ZM113.262 398.801C113.262 400.207 113.586 401.336 114.234 402.188C114.891 403.039 115.766 403.465 116.859 403.465C117.961 403.465 118.836 403.035 119.484 402.176C120.133 401.309 120.457 400.098 120.457 398.543C120.457 397.152 120.125 396.027 119.461 395.168C118.805 394.301 117.93 393.867 116.836 393.867C115.766 393.867 114.902 394.293 114.246 395.145C113.59 395.996 113.262 397.215 113.262 398.801ZM133.172 403.746C132.328 404.738 131.09 405.234 129.457 405.234C128.105 405.234 127.074 404.844 126.363 404.062C125.66 403.273 125.305 402.109 125.297 400.57V392.32H127.465V400.512C127.465 402.434 128.246 403.395 129.809 403.395C131.465 403.395 132.566 402.777 133.113 401.543V392.32H135.281V405H133.219L133.172 403.746ZM144.715 394.266C144.387 394.211 144.031 394.184 143.648 394.184C142.227 394.184 141.262 394.789 140.754 396V405H138.586V392.32H140.695L140.73 393.785C141.441 392.652 142.449 392.086 143.754 392.086C144.176 392.086 144.496 392.141 144.715 392.25V394.266ZM148.77 392.32L148.84 393.914C149.809 392.695 151.074 392.086 152.637 392.086C155.316 392.086 156.668 393.598 156.691 396.621V405H154.523V396.609C154.516 395.695 154.305 395.02 153.891 394.582C153.484 394.145 152.848 393.926 151.98 393.926C151.277 393.926 150.66 394.113 150.129 394.488C149.598 394.863 149.184 395.355 148.887 395.965V405H146.719V392.32H148.77ZM165.223 405.234C163.504 405.234 162.105 404.672 161.027 403.547C159.949 402.414 159.41 400.902 159.41 399.012V398.613C159.41 397.355 159.648 396.234 160.125 395.25C160.609 394.258 161.281 393.484 162.141 392.93C163.008 392.367 163.945 392.086 164.953 392.086C166.602 392.086 167.883 392.629 168.797 393.715C169.711 394.801 170.168 396.355 170.168 398.379V399.281H161.578C161.609 400.531 161.973 401.543 162.668 402.316C163.371 403.082 164.262 403.465 165.34 403.465C166.105 403.465 166.754 403.309 167.285 402.996C167.816 402.684 168.281 402.27 168.68 401.754L170.004 402.785C168.941 404.418 167.348 405.234 165.223 405.234ZM164.953 393.867C164.078 393.867 163.344 394.188 162.75 394.828C162.156 395.461 161.789 396.352 161.648 397.5H168V397.336C167.938 396.234 167.641 395.383 167.109 394.781C166.578 394.172 165.859 393.867 164.953 393.867ZM176.672 401.824L179.625 392.32H181.945L176.848 406.957C176.059 409.066 174.805 410.121 173.086 410.121L172.676 410.086L171.867 409.934V408.176L172.453 408.223C173.188 408.223 173.758 408.074 174.164 407.777C174.578 407.48 174.918 406.938 175.184 406.148L175.664 404.859L171.141 392.32H173.508L176.672 401.824ZM192.199 405H190.031V392.32H192.199V405ZM189.855 388.957C189.855 388.605 189.961 388.309 190.172 388.066C190.391 387.824 190.711 387.703 191.133 387.703C191.555 387.703 191.875 387.824 192.094 388.066C192.312 388.309 192.422 388.605 192.422 388.957C192.422 389.309 192.312 389.602 192.094 389.836C191.875 390.07 191.555 390.188 191.133 390.188C190.711 390.188 190.391 390.07 190.172 389.836C189.961 389.602 189.855 389.309 189.855 388.957ZM197.73 392.32L197.801 393.914C198.77 392.695 200.035 392.086 201.598 392.086C204.277 392.086 205.629 393.598 205.652 396.621V405H203.484V396.609C203.477 395.695 203.266 395.02 202.852 394.582C202.445 394.145 201.809 393.926 200.941 393.926C200.238 393.926 199.621 394.113 199.09 394.488C198.559 394.863 198.145 395.355 197.848 395.965V405H195.68V392.32H197.73ZM211.863 389.25V392.32H214.23V393.996H211.863V401.859C211.863 402.367 211.969 402.75 212.18 403.008C212.391 403.258 212.75 403.383 213.258 403.383C213.508 403.383 213.852 403.336 214.289 403.242V405C213.719 405.156 213.164 405.234 212.625 405.234C211.656 405.234 210.926 404.941 210.434 404.355C209.941 403.77 209.695 402.938 209.695 401.859V393.996H207.387V392.32H209.695V389.25H211.863ZM215.965 398.543C215.965 397.301 216.207 396.184 216.691 395.191C217.184 394.199 217.863 393.434 218.73 392.895C219.605 392.355 220.602 392.086 221.719 392.086C223.445 392.086 224.84 392.684 225.902 393.879C226.973 395.074 227.508 396.664 227.508 398.648V398.801C227.508 400.035 227.27 401.145 226.793 402.129C226.324 403.105 225.648 403.867 224.766 404.414C223.891 404.961 222.883 405.234 221.742 405.234C220.023 405.234 218.629 404.637 217.559 403.441C216.496 402.246 215.965 400.664 215.965 398.695V398.543ZM218.145 398.801C218.145 400.207 218.469 401.336 219.117 402.188C219.773 403.039 220.648 403.465 221.742 403.465C222.844 403.465 223.719 403.035 224.367 402.176C225.016 401.309 225.34 400.098 225.34 398.543C225.34 397.152 225.008 396.027 224.344 395.168C223.688 394.301 222.812 393.867 221.719 393.867C220.648 393.867 219.785 394.293 219.129 395.145C218.473 395.996 218.145 397.215 218.145 398.801ZM239.121 389.25V392.32H241.488V393.996H239.121V401.859C239.121 402.367 239.227 402.75 239.438 403.008C239.648 403.258 240.008 403.383 240.516 403.383C240.766 403.383 241.109 403.336 241.547 403.242V405C240.977 405.156 240.422 405.234 239.883 405.234C238.914 405.234 238.184 404.941 237.691 404.355C237.199 403.77 236.953 402.938 236.953 401.859V393.996H234.645V392.32H236.953V389.25H239.121ZM246.199 393.855C247.16 392.676 248.41 392.086 249.949 392.086C252.629 392.086 253.98 393.598 254.004 396.621V405H251.836V396.609C251.828 395.695 251.617 395.02 251.203 394.582C250.797 394.145 250.16 393.926 249.293 393.926C248.59 393.926 247.973 394.113 247.441 394.488C246.91 394.863 246.496 395.355 246.199 395.965V405H244.031V387H246.199V393.855ZM262.512 405.234C260.793 405.234 259.395 404.672 258.316 403.547C257.238 402.414 256.699 400.902 256.699 399.012V398.613C256.699 397.355 256.938 396.234 257.414 395.25C257.898 394.258 258.57 393.484 259.43 392.93C260.297 392.367 261.234 392.086 262.242 392.086C263.891 392.086 265.172 392.629 266.086 393.715C267 394.801 267.457 396.355 267.457 398.379V399.281H258.867C258.898 400.531 259.262 401.543 259.957 402.316C260.66 403.082 261.551 403.465 262.629 403.465C263.395 403.465 264.043 403.309 264.574 402.996C265.105 402.684 265.57 402.27 265.969 401.754L267.293 402.785C266.23 404.418 264.637 405.234 262.512 405.234ZM262.242 393.867C261.367 393.867 260.633 394.188 260.039 394.828C259.445 395.461 259.078 396.352 258.938 397.5H265.289V397.336C265.227 396.234 264.93 395.383 264.398 394.781C263.867 394.172 263.148 393.867 262.242 393.867ZM97.957 425.395C96.0273 424.84 94.6211 424.16 93.7383 423.355C92.8633 422.543 92.4258 421.543 92.4258 420.355C92.4258 419.012 92.9609 417.902 94.0312 417.027C95.1094 416.145 96.5078 415.703 98.2266 415.703C99.3984 415.703 100.441 415.93 101.355 416.383C102.277 416.836 102.988 417.461 103.488 418.258C103.996 419.055 104.25 419.926 104.25 420.871H101.988C101.988 419.84 101.66 419.031 101.004 418.445C100.348 417.852 99.4219 417.555 98.2266 417.555C97.1172 417.555 96.25 417.801 95.625 418.293C95.0078 418.777 94.6992 419.453 94.6992 420.32C94.6992 421.016 94.9922 421.605 95.5781 422.09C96.1719 422.566 97.1758 423.004 98.5898 423.402C100.012 423.801 101.121 424.242 101.918 424.727C102.723 425.203 103.316 425.762 103.699 426.402C104.09 427.043 104.285 427.797 104.285 428.664C104.285 430.047 103.746 431.156 102.668 431.992C101.59 432.82 100.148 433.234 98.3438 433.234C97.1719 433.234 96.0781 433.012 95.0625 432.566C94.0469 432.113 93.2617 431.496 92.707 430.715C92.1602 429.934 91.8867 429.047 91.8867 428.055H94.1484C94.1484 429.086 94.5273 429.902 95.2852 430.504C96.0508 431.098 97.0703 431.395 98.3438 431.395C99.5312 431.395 100.441 431.152 101.074 430.668C101.707 430.184 102.023 429.523 102.023 428.688C102.023 427.852 101.73 427.207 101.145 426.754C100.559 426.293 99.4961 425.84 97.957 425.395ZM109.781 417.25V420.32H112.148V421.996H109.781V429.859C109.781 430.367 109.887 430.75 110.098 431.008C110.309 431.258 110.668 431.383 111.176 431.383C111.426 431.383 111.77 431.336 112.207 431.242V433C111.637 433.156 111.082 433.234 110.543 433.234C109.574 433.234 108.844 432.941 108.352 432.355C107.859 431.77 107.613 430.938 107.613 429.859V421.996H105.305V420.32H107.613V417.25H109.781ZM122.52 433C122.395 432.75 122.293 432.305 122.215 431.664C121.207 432.711 120.004 433.234 118.605 433.234C117.355 433.234 116.328 432.883 115.523 432.18C114.727 431.469 114.328 430.57 114.328 429.484C114.328 428.164 114.828 427.141 115.828 426.414C116.836 425.68 118.25 425.312 120.07 425.312H122.18V424.316C122.18 423.559 121.953 422.957 121.5 422.512C121.047 422.059 120.379 421.832 119.496 421.832C118.723 421.832 118.074 422.027 117.551 422.418C117.027 422.809 116.766 423.281 116.766 423.836H114.586C114.586 423.203 114.809 422.594 115.254 422.008C115.707 421.414 116.316 420.945 117.082 420.602C117.855 420.258 118.703 420.086 119.625 420.086C121.086 420.086 122.23 420.453 123.059 421.188C123.887 421.914 124.316 422.918 124.348 424.199V430.035C124.348 431.199 124.496 432.125 124.793 432.812V433H122.52ZM118.922 431.348C119.602 431.348 120.246 431.172 120.855 430.82C121.465 430.469 121.906 430.012 122.18 429.449V426.848H120.48C117.824 426.848 116.496 427.625 116.496 429.18C116.496 429.859 116.723 430.391 117.176 430.773C117.629 431.156 118.211 431.348 118.922 431.348ZM129.797 420.32L129.867 421.914C130.836 420.695 132.102 420.086 133.664 420.086C136.344 420.086 137.695 421.598 137.719 424.621V433H135.551V424.609C135.543 423.695 135.332 423.02 134.918 422.582C134.512 422.145 133.875 421.926 133.008 421.926C132.305 421.926 131.688 422.113 131.156 422.488C130.625 422.863 130.211 423.355 129.914 423.965V433H127.746V420.32H129.797ZM140.461 426.555C140.461 424.609 140.922 423.047 141.844 421.867C142.766 420.68 143.973 420.086 145.465 420.086C146.949 420.086 148.125 420.594 148.992 421.609V415H151.16V433H149.168L149.062 431.641C148.195 432.703 146.988 433.234 145.441 433.234C143.973 433.234 142.773 432.633 141.844 431.43C140.922 430.227 140.461 428.656 140.461 426.719V426.555ZM142.629 426.801C142.629 428.238 142.926 429.363 143.52 430.176C144.113 430.988 144.934 431.395 145.98 431.395C147.355 431.395 148.359 430.777 148.992 429.543V423.719C148.344 422.523 147.348 421.926 146.004 421.926C144.941 421.926 144.113 422.336 143.52 423.156C142.926 423.977 142.629 425.191 142.629 426.801ZM162.363 433C162.238 432.75 162.137 432.305 162.059 431.664C161.051 432.711 159.848 433.234 158.449 433.234C157.199 433.234 156.172 432.883 155.367 432.18C154.57 431.469 154.172 430.57 154.172 429.484C154.172 428.164 154.672 427.141 155.672 426.414C156.68 425.68 158.094 425.312 159.914 425.312H162.023V424.316C162.023 423.559 161.797 422.957 161.344 422.512C160.891 422.059 160.223 421.832 159.34 421.832C158.566 421.832 157.918 422.027 157.395 422.418C156.871 422.809 156.609 423.281 156.609 423.836H154.43C154.43 423.203 154.652 422.594 155.098 422.008C155.551 421.414 156.16 420.945 156.926 420.602C157.699 420.258 158.547 420.086 159.469 420.086C160.93 420.086 162.074 420.453 162.902 421.188C163.73 421.914 164.16 422.918 164.191 424.199V430.035C164.191 431.199 164.34 432.125 164.637 432.812V433H162.363ZM158.766 431.348C159.445 431.348 160.09 431.172 160.699 430.82C161.309 430.469 161.75 430.012 162.023 429.449V426.848H160.324C157.668 426.848 156.34 427.625 156.34 429.18C156.34 429.859 156.566 430.391 157.02 430.773C157.473 431.156 158.055 431.348 158.766 431.348ZM173.719 422.266C173.391 422.211 173.035 422.184 172.652 422.184C171.23 422.184 170.266 422.789 169.758 424V433H167.59V420.32H169.699L169.734 421.785C170.445 420.652 171.453 420.086 172.758 420.086C173.18 420.086 173.5 420.141 173.719 420.25V422.266ZM174.961 426.555C174.961 424.609 175.422 423.047 176.344 421.867C177.266 420.68 178.473 420.086 179.965 420.086C181.449 420.086 182.625 420.594 183.492 421.609V415H185.66V433H183.668L183.562 431.641C182.695 432.703 181.488 433.234 179.941 433.234C178.473 433.234 177.273 432.633 176.344 431.43C175.422 430.227 174.961 428.656 174.961 426.719V426.555ZM177.129 426.801C177.129 428.238 177.426 429.363 178.02 430.176C178.613 430.988 179.434 431.395 180.48 431.395C181.855 431.395 182.859 430.777 183.492 429.543V423.719C182.844 422.523 181.848 421.926 180.504 421.926C179.441 421.926 178.613 422.336 178.02 423.156C177.426 423.977 177.129 425.191 177.129 426.801ZM197.59 431.16H205.676V433H195.328V415.938H197.59V431.16ZM210.258 433H208.09V420.32H210.258V433ZM207.914 416.957C207.914 416.605 208.02 416.309 208.23 416.066C208.449 415.824 208.77 415.703 209.191 415.703C209.613 415.703 209.934 415.824 210.152 416.066C210.371 416.309 210.48 416.605 210.48 416.957C210.48 417.309 210.371 417.602 210.152 417.836C209.934 418.07 209.613 418.188 209.191 418.188C208.77 418.188 208.449 418.07 208.23 417.836C208.02 417.602 207.914 417.309 207.914 416.957ZM224.473 426.801C224.473 428.738 224.027 430.297 223.137 431.477C222.246 432.648 221.051 433.234 219.551 433.234C217.949 433.234 216.711 432.668 215.836 431.535L215.73 433H213.738V415H215.906V421.715C216.781 420.629 217.988 420.086 219.527 420.086C221.066 420.086 222.273 420.668 223.148 421.832C224.031 422.996 224.473 424.59 224.473 426.613V426.801ZM222.305 426.555C222.305 425.078 222.02 423.938 221.449 423.133C220.879 422.328 220.059 421.926 218.988 421.926C217.559 421.926 216.531 422.59 215.906 423.918V429.402C216.57 430.73 217.605 431.395 219.012 431.395C220.051 431.395 220.859 430.992 221.438 430.188C222.016 429.383 222.305 428.172 222.305 426.555ZM233.344 422.266C233.016 422.211 232.66 422.184 232.277 422.184C230.855 422.184 229.891 422.789 229.383 424V433H227.215V420.32H229.324L229.359 421.785C230.07 420.652 231.078 420.086 232.383 420.086C232.805 420.086 233.125 420.141 233.344 420.25V422.266ZM242.707 433C242.582 432.75 242.48 432.305 242.402 431.664C241.395 432.711 240.191 433.234 238.793 433.234C237.543 433.234 236.516 432.883 235.711 432.18C234.914 431.469 234.516 430.57 234.516 429.484C234.516 428.164 235.016 427.141 236.016 426.414C237.023 425.68 238.438 425.312 240.258 425.312H242.367V424.316C242.367 423.559 242.141 422.957 241.688 422.512C241.234 422.059 240.566 421.832 239.684 421.832C238.91 421.832 238.262 422.027 237.738 422.418C237.215 422.809 236.953 423.281 236.953 423.836H234.773C234.773 423.203 234.996 422.594 235.441 422.008C235.895 421.414 236.504 420.945 237.27 420.602C238.043 420.258 238.891 420.086 239.812 420.086C241.273 420.086 242.418 420.453 243.246 421.188C244.074 421.914 244.504 422.918 244.535 424.199V430.035C244.535 431.199 244.684 432.125 244.98 432.812V433H242.707ZM239.109 431.348C239.789 431.348 240.434 431.172 241.043 430.82C241.652 430.469 242.094 430.012 242.367 429.449V426.848H240.668C238.012 426.848 236.684 427.625 236.684 429.18C236.684 429.859 236.91 430.391 237.363 430.773C237.816 431.156 238.398 431.348 239.109 431.348ZM254.062 422.266C253.734 422.211 253.379 422.184 252.996 422.184C251.574 422.184 250.609 422.789 250.102 424V433H247.934V420.32H250.043L250.078 421.785C250.789 420.652 251.797 420.086 253.102 420.086C253.523 420.086 253.844 420.141 254.062 420.25V422.266ZM260.426 429.824L263.379 420.32H265.699L260.602 434.957C259.812 437.066 258.559 438.121 256.84 438.121L256.43 438.086L255.621 437.934V436.176L256.207 436.223C256.941 436.223 257.512 436.074 257.918 435.777C258.332 435.48 258.672 434.938 258.938 434.148L259.418 432.859L254.895 420.32H257.262L260.426 429.824Z" fill="white"/>
86 | <path d="M244.186 479V471.891H246.51C247.281 471.891 247.861 472.05 248.248 472.369C248.639 472.688 248.834 473.16 248.834 473.785C248.834 474.117 248.74 474.412 248.551 474.669C248.362 474.923 248.105 475.12 247.779 475.26C248.163 475.367 248.466 475.572 248.688 475.875C248.912 476.174 249.024 476.533 249.024 476.949C249.024 477.587 248.818 478.089 248.404 478.453C247.991 478.818 247.407 479 246.651 479H244.186ZM245.123 475.675V478.233H246.671C247.107 478.233 247.451 478.121 247.701 477.896C247.955 477.669 248.082 477.356 248.082 476.959C248.082 476.103 247.617 475.675 246.686 475.675H245.123ZM245.123 474.923H246.539C246.949 474.923 247.276 474.82 247.521 474.615C247.768 474.41 247.892 474.132 247.892 473.78C247.892 473.39 247.778 473.106 247.55 472.931C247.322 472.752 246.975 472.662 246.51 472.662H245.123V474.923ZM251.256 479H250.353V471.5H251.256V479ZM255.968 479C255.916 478.896 255.873 478.71 255.841 478.443C255.421 478.88 254.92 479.098 254.337 479.098C253.816 479.098 253.388 478.951 253.053 478.658C252.721 478.362 252.555 477.988 252.555 477.535C252.555 476.985 252.763 476.559 253.18 476.256C253.6 475.95 254.189 475.797 254.947 475.797H255.826V475.382C255.826 475.066 255.732 474.815 255.543 474.63C255.354 474.441 255.076 474.347 254.708 474.347C254.386 474.347 254.116 474.428 253.897 474.591C253.679 474.754 253.57 474.951 253.57 475.182H252.662C252.662 474.918 252.755 474.664 252.94 474.42C253.129 474.173 253.383 473.977 253.702 473.834C254.024 473.691 254.378 473.619 254.762 473.619C255.37 473.619 255.847 473.772 256.192 474.078C256.537 474.381 256.716 474.799 256.729 475.333V477.765C256.729 478.25 256.791 478.635 256.915 478.922V479H255.968ZM254.469 478.312C254.752 478.312 255.021 478.238 255.274 478.092C255.528 477.945 255.712 477.755 255.826 477.521V476.437H255.118C254.011 476.437 253.458 476.76 253.458 477.408C253.458 477.691 253.552 477.913 253.741 478.072C253.93 478.232 254.173 478.312 254.469 478.312ZM261.222 477.599C261.222 477.354 261.129 477.166 260.943 477.032C260.761 476.896 260.44 476.778 259.981 476.681C259.526 476.583 259.163 476.466 258.893 476.329C258.626 476.192 258.427 476.03 258.297 475.841C258.17 475.652 258.106 475.427 258.106 475.167C258.106 474.734 258.289 474.368 258.653 474.068C259.021 473.769 259.49 473.619 260.06 473.619C260.659 473.619 261.144 473.774 261.515 474.083C261.889 474.392 262.076 474.788 262.076 475.27H261.168C261.168 475.022 261.062 474.809 260.851 474.63C260.642 474.451 260.379 474.361 260.06 474.361C259.731 474.361 259.474 474.433 259.288 474.576C259.103 474.719 259.01 474.907 259.01 475.138C259.01 475.356 259.096 475.52 259.269 475.631C259.441 475.742 259.752 475.847 260.201 475.948C260.654 476.049 261.02 476.17 261.3 476.31C261.58 476.45 261.786 476.619 261.92 476.817C262.057 477.013 262.125 477.252 262.125 477.535C262.125 478.007 261.936 478.386 261.559 478.673C261.181 478.956 260.691 479.098 260.089 479.098C259.666 479.098 259.291 479.023 258.966 478.873C258.64 478.723 258.385 478.515 258.199 478.248C258.017 477.978 257.926 477.687 257.926 477.374H258.829C258.845 477.677 258.966 477.918 259.19 478.097C259.418 478.272 259.718 478.36 260.089 478.36C260.431 478.36 260.704 478.292 260.909 478.155C261.118 478.015 261.222 477.83 261.222 477.599ZM268.531 476.124H266.861V479H265.919V471.891H268.272C269.073 471.891 269.688 472.073 270.118 472.438C270.551 472.802 270.768 473.333 270.768 474.029C270.768 474.472 270.647 474.858 270.406 475.187C270.169 475.515 269.837 475.761 269.41 475.924L271.08 478.941V479H270.074L268.531 476.124ZM266.861 475.357H268.302C268.767 475.357 269.137 475.237 269.41 474.996C269.687 474.755 269.825 474.433 269.825 474.029C269.825 473.59 269.693 473.253 269.43 473.019C269.169 472.784 268.792 472.665 268.297 472.662H266.861V475.357ZM271.705 476.31C271.705 475.792 271.806 475.326 272.008 474.913C272.213 474.5 272.496 474.181 272.857 473.956C273.222 473.731 273.637 473.619 274.103 473.619C274.822 473.619 275.403 473.868 275.846 474.366C276.292 474.864 276.515 475.527 276.515 476.354V476.417C276.515 476.931 276.415 477.394 276.217 477.804C276.021 478.211 275.74 478.528 275.372 478.756C275.007 478.984 274.588 479.098 274.112 479.098C273.396 479.098 272.815 478.849 272.369 478.351C271.926 477.853 271.705 477.193 271.705 476.373V476.31ZM272.613 476.417C272.613 477.003 272.748 477.473 273.019 477.828C273.292 478.183 273.657 478.36 274.112 478.36C274.571 478.36 274.936 478.181 275.206 477.823C275.476 477.462 275.611 476.957 275.611 476.31C275.611 475.73 275.473 475.261 275.196 474.903C274.923 474.542 274.558 474.361 274.103 474.361C273.657 474.361 273.297 474.539 273.023 474.894C272.75 475.248 272.613 475.756 272.613 476.417ZM277.428 476.314C277.428 475.504 277.62 474.853 278.004 474.361C278.388 473.867 278.891 473.619 279.513 473.619C280.131 473.619 280.621 473.831 280.982 474.254V471.5H281.886V479H281.056L281.012 478.434C280.65 478.876 280.147 479.098 279.503 479.098C278.891 479.098 278.391 478.847 278.004 478.346C277.62 477.844 277.428 477.19 277.428 476.383V476.314ZM278.331 476.417C278.331 477.016 278.455 477.485 278.702 477.823C278.95 478.162 279.291 478.331 279.728 478.331C280.3 478.331 280.719 478.074 280.982 477.56V475.133C280.712 474.635 280.297 474.386 279.737 474.386C279.295 474.386 278.95 474.557 278.702 474.898C278.455 475.24 278.331 475.746 278.331 476.417ZM285.846 474.527C285.709 474.505 285.561 474.493 285.401 474.493C284.809 474.493 284.407 474.745 284.195 475.25V479H283.292V473.717H284.171L284.186 474.327C284.482 473.855 284.902 473.619 285.445 473.619C285.621 473.619 285.755 473.642 285.846 473.688V474.527ZM287.662 479H286.759V473.717H287.662V479ZM286.686 472.315C286.686 472.169 286.729 472.045 286.817 471.944C286.909 471.843 287.042 471.793 287.218 471.793C287.394 471.793 287.527 471.843 287.618 471.944C287.709 472.045 287.755 472.169 287.755 472.315C287.755 472.462 287.709 472.584 287.618 472.682C287.527 472.779 287.394 472.828 287.218 472.828C287.042 472.828 286.909 472.779 286.817 472.682C286.729 472.584 286.686 472.462 286.686 472.315ZM288.897 476.314C288.897 475.491 289.088 474.837 289.469 474.352C289.85 473.863 290.354 473.619 290.982 473.619C291.627 473.619 292.13 473.847 292.491 474.303L292.535 473.717H293.36V478.873C293.36 479.557 293.157 480.095 292.75 480.489C292.346 480.883 291.803 481.08 291.119 481.08C290.738 481.08 290.366 480.999 290.001 480.836C289.636 480.673 289.358 480.45 289.166 480.167L289.635 479.625C290.022 480.104 290.496 480.343 291.056 480.343C291.495 480.343 291.837 480.219 292.081 479.972C292.328 479.724 292.452 479.376 292.452 478.927V478.473C292.091 478.889 291.598 479.098 290.973 479.098C290.354 479.098 289.853 478.849 289.469 478.351C289.088 477.853 288.897 477.174 288.897 476.314ZM289.806 476.417C289.806 477.013 289.928 477.481 290.172 477.823C290.416 478.162 290.758 478.331 291.197 478.331C291.767 478.331 292.185 478.072 292.452 477.555V475.143C292.175 474.638 291.76 474.386 291.207 474.386C290.768 474.386 290.424 474.557 290.177 474.898C289.929 475.24 289.806 475.746 289.806 476.417ZM297.989 478.478C297.638 478.891 297.122 479.098 296.441 479.098C295.878 479.098 295.449 478.935 295.152 478.609C294.859 478.281 294.711 477.796 294.708 477.154V473.717H295.611V477.13C295.611 477.931 295.937 478.331 296.588 478.331C297.278 478.331 297.737 478.074 297.965 477.56V473.717H298.868V479H298.009L297.989 478.478ZM302.438 479.098C301.721 479.098 301.139 478.863 300.689 478.395C300.24 477.923 300.016 477.293 300.016 476.505V476.339C300.016 475.815 300.115 475.348 300.313 474.938C300.515 474.524 300.795 474.202 301.153 473.971C301.515 473.736 301.905 473.619 302.325 473.619C303.012 473.619 303.546 473.845 303.927 474.298C304.308 474.75 304.498 475.398 304.498 476.241V476.617H300.919C300.932 477.138 301.083 477.56 301.373 477.882C301.666 478.201 302.037 478.36 302.486 478.36C302.805 478.36 303.076 478.295 303.297 478.165C303.518 478.035 303.712 477.862 303.878 477.647L304.43 478.077C303.987 478.757 303.323 479.098 302.438 479.098ZM302.325 474.361C301.961 474.361 301.655 474.495 301.407 474.762C301.16 475.025 301.007 475.396 300.948 475.875H303.595V475.807C303.569 475.348 303.445 474.993 303.224 474.742C303.002 474.488 302.703 474.361 302.325 474.361ZM306.397 478.263H309.488V479H305.294V478.336L308.209 474.464H305.338V473.717H309.342V474.356L306.397 478.263ZM314.137 479H313.199V471.891H314.137V479ZM318.268 474.527C318.131 474.505 317.983 474.493 317.823 474.493C317.231 474.493 316.829 474.745 316.617 475.25V479H315.714V473.717H316.593L316.607 474.327C316.904 473.855 317.324 473.619 317.867 473.619C318.043 473.619 318.176 473.642 318.268 473.688V474.527ZM320.084 479H319.181V473.717H320.084V479ZM319.107 472.315C319.107 472.169 319.151 472.045 319.239 471.944C319.33 471.843 319.464 471.793 319.64 471.793C319.815 471.793 319.949 471.843 320.04 471.944C320.131 472.045 320.177 472.169 320.177 472.315C320.177 472.462 320.131 472.584 320.04 472.682C319.949 472.779 319.815 472.828 319.64 472.828C319.464 472.828 319.33 472.779 319.239 472.682C319.151 472.584 319.107 472.462 319.107 472.315ZM322.384 478.263H325.475V479H321.28V478.336L324.195 474.464H321.324V473.717H325.328V474.356L322.384 478.263ZM329.757 479C329.705 478.896 329.662 478.71 329.63 478.443C329.21 478.88 328.709 479.098 328.126 479.098C327.605 479.098 327.177 478.951 326.842 478.658C326.51 478.362 326.344 477.988 326.344 477.535C326.344 476.985 326.552 476.559 326.969 476.256C327.389 475.95 327.978 475.797 328.736 475.797H329.615V475.382C329.615 475.066 329.521 474.815 329.332 474.63C329.143 474.441 328.865 474.347 328.497 474.347C328.175 474.347 327.905 474.428 327.687 474.591C327.468 474.754 327.359 474.951 327.359 475.182H326.451C326.451 474.918 326.544 474.664 326.729 474.42C326.918 474.173 327.172 473.977 327.491 473.834C327.813 473.691 328.167 473.619 328.551 473.619C329.16 473.619 329.636 473.772 329.981 474.078C330.326 474.381 330.506 474.799 330.519 475.333V477.765C330.519 478.25 330.58 478.635 330.704 478.922V479H329.757ZM328.258 478.312C328.541 478.312 328.81 478.238 329.063 478.092C329.317 477.945 329.501 477.755 329.615 477.521V476.437H328.907C327.8 476.437 327.247 476.76 327.247 477.408C327.247 477.691 327.341 477.913 327.53 478.072C327.719 478.232 327.962 478.312 328.258 478.312ZM334.488 474.527C334.352 474.505 334.203 474.493 334.044 474.493C333.451 474.493 333.049 474.745 332.838 475.25V479H331.935V473.717H332.813L332.828 474.327C333.124 473.855 333.544 473.619 334.088 473.619C334.264 473.619 334.397 473.642 334.488 473.688V474.527Z" fill="white"/>
87 | </svg>
88 | 


--------------------------------------------------------------------------------
/src/io-intro.md:
--------------------------------------------------------------------------------
 1 | ## IO
 2 | 
 3 | > Package io provides basic interfaces to I/O primitives.
 4 | > Its primary job is to wrap existing implementations of such primitives,
 5 | > such as those in package os, into shared public interfaces that abstract
 6 | > the functionality, plus some other related primitives.
 7 | 
 8 | `io` is a very important package in Go. It provides a set of primitives
 9 | and interfaces that every developer needs to understand in order to work
10 | properly with bytes, standard input, output, error and pipes among others.
11 | 
12 | An important note is that these primitives are not thread safe by default.
13 | This means that they shouldn't be used by multiple goroutines at the same time.
14 | 


--------------------------------------------------------------------------------
/src/io-pipe-in-depth.md:
--------------------------------------------------------------------------------
 1 | # Pipe
 2 | 
 3 | In Go a pipe is **synchronous in-memory pipe**. `pipe` is a type that
 4 | is not publicly exposed. However, `io` allows us to interact with
 5 | it through `PipeWriter` and `PipeReader`. In order to create
 6 | these two halves of the `pipe`, `io` has a function:
 7 | 
 8 | ```go
 9 | func Pipe() (*PipeReader, *PipeWriter)
10 | ```
11 | 
12 | Just for having the full picture, and to see how it works under the hood, this
13 | is how `pipe` is defined:
14 | 
15 | ```go
16 | // A pipe is the shared pipe structure underlying PipeReader and PipeWriter.
17 | type pipe struct {
18 | 	wrMu sync.Mutex // Serializes Write operations
19 | 	wrCh chan []byte
20 | 	rdCh chan int
21 | 	once sync.Once // Protects closing done
22 | 	done chan struct{}
23 | 	rerr onceError
24 | 	werr onceError
25 | }
26 | ```
27 | 
28 | Again, as consumers of `pipe` we only care about `PipeReader` and `PipeWriter`.
29 | 
30 | > It can be used to connect code expecting an `io.Reader` with code expecting
31 | > an `io.Writer`.
32 | 
33 | Sometimes it can happen that we hold an `io.Reader`, but we need to call a function
34 | that expects an `io.Writer`. `Pipe` is a really good tool for achieving it.
35 | 
36 | > The data is copied directly from the `io.Write` to the corresponding `io.Read`
37 | > (or Reads) there is no internal buffering.
38 | 
39 | ## Video about pipes
40 | 
41 | I really suggest anyone to visit [this video](https://www.youtube.com/watch?v=LHZ2CAZE6Gs)
42 | to get a deeper understanding on
43 | how to use pipes.
44 | 


--------------------------------------------------------------------------------
/src/io-reader-and-writer.md:
--------------------------------------------------------------------------------
  1 | ## Writer
  2 | 
  3 | Writer is the interface that wraps the basic Write method. `io` package makes
  4 | extensive use of this interface. `Writer` is implemented by `os.File`. Which
  5 | in the `io` package is used to reference to `Stdin`, `StdOut`, and `StdErr`:
  6 | 
  7 | ```go
  8 | var (
  9 |     Stdin  = NewFile(uintptr(syscall.Stdin), "/dev/stdin")
 10 |     Stdout = NewFile(uintptr(syscall.Stdout), "/dev/stdout")
 11 |     Stderr = NewFile(uintptr(syscall.Stderr), "/dev/stderr")
 12 | )
 13 | ```
 14 | 
 15 | ### How does writer works?
 16 | 
 17 | > Write writes len(p) bytes from p to the underlying data stream.
 18 | > It returns the number of bytes written from p (0 <= n <= len(p))
 19 | > and any error encountered that caused `write` function to stop
 20 | > early. Write must return a non-nil error if it returns n < len(p).
 21 | > `Write` must not modify the slice data, even temporarily.
 22 | 
 23 | Implementations must not retain p.
 24 | 
 25 | ```go
 26 | type Writer interface {
 27 |     Write(p []byte) (n int, err error)
 28 | }
 29 | ```
 30 | 
 31 | To see an implementation, we can check the one for `os.File`. There
 32 | are some OS dependent helper functions that help `Write` doing their
 33 | job. But essentially it is a transparent copy of its description.
 34 | 
 35 | Check a fragment of the POSIX implementation of `Write` from the source
 36 | code in the `os` package:
 37 | 
 38 | ```go
 39 | // Write writes len(b) bytes to the File.
 40 | // It returns the number of bytes written and an error, if any.
 41 | // Write returns a non-nil error when n != len(b).
 42 | 
 43 | func (f *File) Write(b []byte) (n int, err error) {
 44 |     // for posix f.checkValid returns nil unless f is nil
 45 | 	if err := f.checkValid("write"); err != nil {
 46 | 		return 0, err
 47 | 	}
 48 | 	n, e := f.write(b)
 49 | 	if n < 0 {
 50 | 		n = 0
 51 | 	}
 52 | 	if n != len(b) {
 53 | 		err = io.ErrShortWrite
 54 | 	}
 55 | 	epipecheck(f, e)
 56 | 
 57 | if e != nil {
 58 | 		err = f.wrapErr("write", e)
 59 | 	}
 60 | 	return n, err
 61 | }
 62 | ```
 63 | 
 64 | Side note: it's important to see that `write` will block the thread. There's
 65 | an ongoing [discussion](https://github.com/golang/go/issues/6817) to provide
 66 | an async API for files, but it's still being considered.
 67 | 
 68 | ## Reader
 69 | 
 70 | Similarly, `Reader` is the reading counterpart. It is also an interface that wraps
 71 | the `Read` method.
 72 | 
 73 | > `Read` reads up to len(p) bytes into p. It returns the number of bytes
 74 | > read (0 <= n <= len(p)) and any error encountered. Even if `Read` returns
 75 | > n < len(p), it may use all of p as scratch space during the call.
 76 | > If some data is available but not len(p) bytes, `Read` conventionally
 77 | > returns what is available instead of waiting for more.
 78 | 
 79 | It is defined as:
 80 | 
 81 | ```go
 82 | type Reader interface {
 83 |     Read(p []byte) (n int, err error)
 84 | }
 85 | ```
 86 | 
 87 | As an implementor of `Read`, when there is nothing else to read, the Standard
 88 | Library suggest to return 0, `EOF` instead. 0, nil is only acceptable when
 89 | `p` length is equal to zero. But that's not happening very often.
 90 | 
 91 | Additionally, the Standard Library suggest first reading the `n` bytes, and then
 92 | handling the error if there was any. It adds that:
 93 | 
 94 | > Doing so correctly handles I/O errors that happen after reading some bytes and
 95 | > also both of the allowed EOF behaviors.
 96 | 
 97 | `Read` implementation for type `os.File` relies on a helper function `read` that
 98 | does all the work (except error handling). `read` itself relies on `poll.FD` (on \*nix),
 99 | which is in charge of checking whether there is anything to be read on that
100 | file descriptor. For the very curious reader, go and check its implementation of
101 | `FD`'s `Read` [here](https://golang.org/src/internal/poll/fd_unix.go?s=4169:4210#L135).
102 | 
103 | ```go
104 | func (f *File) Read(b []byte) (n int, err error) {
105 | 	if err := f.checkValid("read"); err != nil {
106 | 		return 0, err
107 | 	}
108 | 
109 | 	n, e := f.read(b)
110 | 	return n, f.wrapErr("read", e)
111 | }
112 | ```
113 | 


--------------------------------------------------------------------------------
/src/notes-about-godocs.md:
--------------------------------------------------------------------------------
 1 | # Notes about Go docs
 2 | 
 3 | When visiting any of the packages in [Go Std Library](https://golang.org/pkg/),
 4 | there is a certain pattern that is being kept through. It helps to dissect it,
 5 | so that we know what to expect from these docs, and also where to get extra
 6 | information. First, there is an **Overview**, which is a simple paragraph that
 7 | explains the scope of the package. It essentially tells the reader what to
 8 | expect from the package in question. Additionally, in some cases, it can make
 9 | some references to other packages when this helps to understand some design
10 | choices. This can, for example, happen when the API of two packages is very
11 | similar (i.e. bytes and strings).
12 | 
13 | The **Index** lists all the contents of the package. It outlines all the constants,
14 | variables, functions, structs, methods, and interfaces exported by the package.
15 | It's important to note that everything that is being listed in the docs is
16 | public elements. That means, that the author of the package has deliberately
17 | chosen to let the user of the API call. But there are other elements, that are
18 | not public. And these help to build functionality, but the author has chosen not
19 | to expose them out of the package. It is sometimes useful to go through the
20 | private items of the package. This can help to get some understanding of the
21 | design choices and trade-offs of some implementation. These private blocks are
22 | found directly in the source code of the package, which is found at the bottom
23 | of the index and examples, with the title of **package files**.
24 | 
25 | ## Go Specification
26 | 
27 | It's important to note that, while the scope of this book is the Standard Library,
28 | there is a lot of useful information in the [Go Spec](https://golang.org/ref/spec).
29 | This is a resource that needs to be considered and reviewed almost every time,
30 | when in doubt of how internal things work in the language.
31 | 


--------------------------------------------------------------------------------
/src/preface.md:
--------------------------------------------------------------------------------
 1 | # Preface
 2 | 
 3 | Welcome, traveler! This is a set of notes of my journey into part of Go's
 4 | standard library, comprised into a book. I hope you enjoy it!
 5 | Each chapter provides a dive into some packages. I will provide a brief
 6 | introduction of what is the main purpose of the package, and some examples to
 7 | help to understand. In some cases, I will add some references to external
 8 | content that work either as a complementary view to the topic, or even to extend
 9 | the coverage of the subject.
10 | 
11 | ## Who is this book for?
12 | 
13 | Ideally you are a software developer, or someone with great interest in how to write
14 | code. Having an understanding on the syntax and certain command of the Go programming
15 | language will certainly help. However, I will try to keep the explanations as
16 | simple as possible in order to be able to reach to a larger audience. And
17 | hopefully, this will still be found interesting for those looking for getting
18 | a deeper understanding of what tools the language and its runtime has to offer.
19 | 
20 | ## Feedback and comments
21 | 
22 | This book is built entirely using markdown. And it's also hosted publicly on GitHub.
23 | For comments, issues, or any kind of feedback, please use the
24 | [Spaceship Go](https://github.com/blasrodri/spaceship-go) repository. PR's are more
25 | than welcome, of any type!
26 | 
27 | ## Special thanks
28 | 
29 | Most of the book is just my interpretation of the Go's standard library. Besides this, I've
30 | found that the Go Blog is an extremely useful resource. Big thanks especially
31 | to Andrew Gerrand, for all the great contributions he has in that space.
32 | 
33 | There is also a YouTube channel called **just for func**, which I also highly
34 | recommend. It was particularly useful to prepare the groundwork for the `Context`
35 | chapter. Thanks to its creator, Francesc Campoy.
36 | 
37 | The cover of the book is based on original work from [egonelbre gophers repo](https://github.com/egonelbre/gophers)
38 | 


--------------------------------------------------------------------------------
/src/sync-cond.md:
--------------------------------------------------------------------------------
 1 | ## Cond
 2 | > Cond implements a condition variable, a rendezvous point for goroutines
 3 | > waiting for or announcing the occurrence of an event. 
 4 | 
 5 | 
 6 | ## Broadcast
 7 | A typical use case for `Broacast` is when multiple goroutines are waiting
 8 | for something to happen. In order to let all of them that a certain event
 9 | happened using channels, then we would need to have one channel for each
10 | of them. And then send each of them a message. This is what `Broadcast`
11 | is about. Broadcast wakes all goroutines waiting on that `Cond`so that
12 | they can continue working.
13 | 
14 | Inside a `Cond` type, there is an attribute called `notify` of type `notifyList`.
15 | `notify` is used by a function called `runtime_notifyListNotifyAll` in order to wake
16 | up all goroutines.
17 | 
18 | func (c *Cond) Broadcast() {
19 | 	c.checker.check()
20 | 	runtime_notifyListNotifyAll(&c.notify)
21 | }
22 | 
23 | And even when it's not necessary to understand how `Broadcast`works, if we peek
24 | at runtime_notifyListNotifyAll implementation, we can actually verify that it
25 | _readies_ all the outstanding goroutines by calling `goready`.
26 | 
27 | ```go
28 | 
29 | // notifyListNotifyAll notifies all entries in the list.
30 | 
31 | //go:linkname notifyListNotifyAll sync.runtime_notifyListNotifyAll
32 | 
33 | func notifyListNotifyAll(l *notifyList) {
34 | 	// Fast-path: if there are no new waiters since the last notification
35 | 	// we don't need to acquire the lock.
36 | 	if atomic.Load(&l.wait) == atomic.Load(&l.notify) {
37 | 		return
38 | 	}
39 |     /* 
40 |     omitted code
41 |     */
42 |     s := l.head
43 |     /* 
44 |     omitted code
45 |     */
46 | 	for s != nil {
47 | 		next := s.next
48 | 		s.next = nil
49 | 		readyWithTime(s, 4) // this function calls goready
50 | 		s = next
51 | 	}
52 | }
53 | ```
54 | 
55 | ## Signal
56 | Signal will only wake **one** goroutine, if there was at least one waiting.
57 | 
58 | The implementation is similar to the one for `Broadcast`. This time, it relies
59 | on a helper function called `notifyListNotifyOne`.
60 | 
61 | ## Wait
62 | 
63 | Cond has an associated `Locker` (which normally is a *Mutex or *RWMutex). This
64 | `Locker` must be held when calling the Wait method.
65 | 
66 | If there's a goroutine that needs to be awaken to do some work,
67 | it can be modelled as follows:
68 | 
69 | ```go
70 | go func(c *sync.Cond) {
71 |     // hold the Locker when calling the wait method
72 |     c.L.Lock()
73 |     for !condition() {
74 |         c.Wait()
75 |     }
76 |     // ... make use of condition ...
77 |     c.L.Unlock()
78 |     // Unlock the Locker when it's done
79 | }
80 | ```
81 | 
82 | For completeness, a `Locker` is just an interface that defines two methods: `Lock` and `Unlock`.
83 | 


--------------------------------------------------------------------------------
/src/sync-do.md:
--------------------------------------------------------------------------------
 1 | ## Once - Do
 2 | 
 3 | A very simple - but sometimes useful - method is `Do`. Its role is simply to
 4 | guarantee that a function run through it won't run more than once. This means
 5 | that if we have:
 6 | 
 7 | ```go
 8 | var once sync.Once
 9 | a := make([]int, 0)
10 | once.Do(func() {a = append(a, 1)})
11 | once.Do(func() {a = append(a, 2)})
12 | fmt.Print(a) // [1] and not [1 2]
13 | ```
14 | `Once` is the right type, when it's important that a certain resource gets
15 | called or initialized only once. In order to be able to call it again, and
16 | that the function is actually run, another instance of `Once` needs to be
17 | defined. And `Do` called from that new instance.


--------------------------------------------------------------------------------
/src/sync-intro.md:
--------------------------------------------------------------------------------
 1 | # Sync
 2 | 
 3 | When working on a concurrent setup, Go's capabilities shine. It exposes natively
 4 | channels and goroutines. It makes it really easy to get off the ground with a
 5 | program that can -in many cases- run much faster.
 6 | 
 7 | The hard part of concurrency stems from having moving parts, which need
 8 | to communicate with each other and where **sequence** of that exchange really
 9 | matters. There are times when channels fall short. And that's why resorting
10 | to the `sync` package can be a really good option.
11 | 
12 | Normally, I only pick a selection of functions, types, methods and interfaces to
13 | cover from each package. But `sync`is an exception. I will cover everything from
14 | it, because I really believe it's a critical package. And mastering makes a
15 | difference.
16 | 


--------------------------------------------------------------------------------
/src/sync-mutex.md:
--------------------------------------------------------------------------------
 1 | ## Mutex
 2 | 
 3 | A `Mutex` is a flag that can be held by at most one goroutine at at time. Its
 4 | name is derived from _mutually exclusive_, which indicates its purpose. The
 5 | _raison d’etre_ of a `Mutex` is synchronization, by preventing that no other
 6 | goroutine can perform an operation over the resources that are being mutexed.
 7 | 
 8 | It fulfills the `Locker` interface, thus it defines `Lock` and `Unlock`.
 9 | 
10 | It's important to note that a lock doesn't belong to a particular goroutine.
11 | Thus, it's allowed for a goroutine to lock the `Mutex` and another to `Unlock`
12 | it. Therefore, it's still important how the different goroutines interact with
13 | the resource in order both to avoid deadlocks but also to avoid accessing to
14 | a resource when it's not locked.
15 | 
16 | ## Lock
17 | 
18 | This is how `Lock` is implemented. But the real meat lies in `lockSlow`, which
19 | we won't cover here. I'm mostly copying the definition just to see how the pieces
20 | are put together. The complete implementation is quite complicated, and it involves
21 | assembly code in the very end.
22 | 
23 | ```go
24 | func (m *Mutex) Lock() {
25 | 	// Fast path: grab unlocked mutex.
26 | 	if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
27 | 		if race.Enabled {
28 | 			race.Acquire(unsafe.Pointer(m))
29 | 		}
30 | 		return
31 | 	}
32 | 	m.lockSlow()
33 | }
34 | ```
35 | 
36 | If the `Mutex` is already locked, then the goroutine that calls `Lock` will block
37 | until the `Mutex` gets released, and can be locked by it. 
38 | 
39 | ## Unlock 
40 | This method is responsible for unlocking the `Mutex`. It can be called from any
41 | goroutine, and it's not necessary that is the one that locked it. However, if
42 | it's unlocked, it cannot be unlocked right away. Otherwise, it panics. 
43 | The implementation of this behavior is as follows:
44 | 
45 | ```go
46 | const (
47 |     mutexLocked = 1 << iota // mutex is locked
48 | )
49 | 
50 | func (m *Mutex) unlockSlow(new int32) {
51 | 	if (new+mutexLocked)&mutexLocked == 0 {
52 | 		throw("sync: unlock of unlocked mutex")
53 |     }
54 |     /*
55 |     ...
56 |     */
57 | }
58 | ```


--------------------------------------------------------------------------------
/src/sync-pool.md:
--------------------------------------------------------------------------------
 1 | ## Pool
 2 | > A Pool is a set of temporary objects that may be individually saved and retrieved.
 3 | 
 4 | `Pool` provides a way to amortize allocation overhead. It serves for when there
 5 | are multiple users of a resource, and we would like to avoid having to create
 6 | a new time every time we need to.
 7 | 
 8 | `Pool` caches allocated but unused items so that they can be available for later
 9 | use. It relieves pressure from the garbage collector. However, 
10 | **Any item stored in the Pool may be removed automatically at**
11 | **any time without notification**.
12 | 
13 | 
14 | ```go
15 | type Pool struct {
16 | 
17 |     // New optionally specifies a function to generate
18 |     // a value when Get would otherwise return nil.
19 |     // It may not be changed concurrently with calls to Get.
20 |     New func() interface{}
21 |     // contains filtered or unexported fields
22 | }
23 | ```
24 | The important bit from the definition is that, whenever we call
25 | `Get`, and there are no items left in the pool, then it creates
26 | a new one by calling `New`. 
27 | 
28 | Once an item has been used, it can be returned to the `Pool` by
29 | calling `Put`. `Put` adds an item back into the `Pool`.
30 | 
31 | 
32 | 


--------------------------------------------------------------------------------
/src/sync-waitgroup.md:
--------------------------------------------------------------------------------
 1 | ## WaitGroup
 2 | 
 3 | > A WaitGroup waits for a collection of goroutines to finish.
 4 | > The main goroutine calls `Add` to set the number of goroutines to wait for.
 5 | > Then each of the goroutines runs and calls `Done` when finished.
 6 | > At the same time, `Wait` can be used to block until all goroutines have finished. 
 7 | 
 8 | It's possible to have another goroutine also to wait on this group. The only
 9 | real constraint is that `Add` can only be called by the main one.
10 | 
11 | ### Add
12 | 
13 | ```go
14 | func (wg *WaitGroup) Add(delta int)
15 | ```
16 | 
17 | The **delta** defines how many more - or less - goroutines, the goroutines
18 | waiting need to actually wait for. When the counter gets to zero, then
19 | all the waiting goroutines get released. If the counter is negative, then
20 | `Add` panics.
21 | 
22 | ### Done
23 | 
24 | It decrements the counter by one.
25 | 
26 | ### Wait
27 | 
28 | Blocks the goroutine until the counter of the `WaitGroup` gets to zero.


--------------------------------------------------------------------------------