removing all downloaded devdocs files

1 files changed, 0 insertions, 106 deletions

diff --git a/devdocs/go/encoding%2Fhex%2Findex.html b/devdocs/go/encoding%2Fhex%2Findex.html
deleted file mode 100644
index 57e8bc67..00000000
--- a/devdocs/go/encoding%2Fhex%2Findex.html
+++ /dev/null
@@ -1,106 +0,0 @@
-<h1> Package hex  </h1>     <ul id="short-nav">
-<li><code>import "encoding/hex"</code></li>
-<li><a href="#pkg-overview" class="overviewLink">Overview</a></li>
-<li><a href="#pkg-index" class="indexLink">Index</a></li>
-<li><a href="#pkg-examples" class="examplesLink">Examples</a></li>
-</ul>     <h2 id="pkg-overview">Overview </h2> <p>Package hex implements hexadecimal encoding and decoding. </p>     <h2 id="pkg-index">Index </h2>  <ul id="manual-nav">
-<li><a href="#pkg-variables">Variables</a></li>
-<li><a href="#AppendDecode">func AppendDecode(dst, src []byte) ([]byte, error)</a></li>
-<li><a href="#AppendEncode">func AppendEncode(dst, src []byte) []byte</a></li>
-<li><a href="#Decode">func Decode(dst, src []byte) (int, error)</a></li>
-<li><a href="#DecodeString">func DecodeString(s string) ([]byte, error)</a></li>
-<li><a href="#DecodedLen">func DecodedLen(x int) int</a></li>
-<li><a href="#Dump">func Dump(data []byte) string</a></li>
-<li><a href="#Dumper">func Dumper(w io.Writer) io.WriteCloser</a></li>
-<li><a href="#Encode">func Encode(dst, src []byte) int</a></li>
-<li><a href="#EncodeToString">func EncodeToString(src []byte) string</a></li>
-<li><a href="#EncodedLen">func EncodedLen(n int) int</a></li>
-<li><a href="#NewDecoder">func NewDecoder(r io.Reader) io.Reader</a></li>
-<li><a href="#NewEncoder">func NewEncoder(w io.Writer) io.Writer</a></li>
-<li><a href="#InvalidByteError">type InvalidByteError</a></li>
-<li> <a href="#InvalidByteError.Error">func (e InvalidByteError) Error() string</a>
-</li>
-</ul> <div id="pkg-examples"> <h3>Examples</h3>  <dl> <dd><a class="exampleLink" href="#example_Decode">Decode</a></dd> <dd><a class="exampleLink" href="#example_DecodeString">DecodeString</a></dd> <dd><a class="exampleLink" href="#example_Dump">Dump</a></dd> <dd><a class="exampleLink" href="#example_Dumper">Dumper</a></dd> <dd><a class="exampleLink" href="#example_Encode">Encode</a></dd> <dd><a class="exampleLink" href="#example_EncodeToString">EncodeToString</a></dd> </dl> </div> <h3>Package files</h3> <p>  <span>hex.go</span>  </p>   <h2 id="pkg-variables">Variables</h2> <p>ErrLength reports an attempt to decode an odd-length input using <a href="#Decode">Decode</a> or <a href="#DecodeString">DecodeString</a>. The stream-based Decoder returns <span>io.ErrUnexpectedEOF</span> instead of ErrLength. </p>
-<pre data-language="go">var ErrLength = errors.New("encoding/hex: odd length hex string")</pre> <h2 id="AppendDecode">func <span>AppendDecode</span>  <span title="Added in Go 1.22">1.22</span> </h2> <pre data-language="go">func AppendDecode(dst, src []byte) ([]byte, error)</pre> <p>AppendDecode appends the hexadecimally decoded src to dst and returns the extended buffer. If the input is malformed, it returns the partially decoded src and an error. </p>
-<h2 id="AppendEncode">func <span>AppendEncode</span>  <span title="Added in Go 1.22">1.22</span> </h2> <pre data-language="go">func AppendEncode(dst, src []byte) []byte</pre> <p>AppendEncode appends the hexadecimally encoded src to dst and returns the extended buffer. </p>
-<h2 id="Decode">func <span>Decode</span>  </h2> <pre data-language="go">func Decode(dst, src []byte) (int, error)</pre> <p>Decode decodes src into <a href="#DecodedLen">DecodedLen</a>(len(src)) bytes, returning the actual number of bytes written to dst. </p>
-<p>Decode expects that src contains only hexadecimal characters and that src has even length. If the input is malformed, Decode returns the number of bytes decoded before the error. </p>   <h4 id="example_Decode"> <span class="text">Example</span>
-</h4> <p>Code:</p> <pre class="code" data-language="go">src := []byte("48656c6c6f20476f7068657221")
-
-dst := make([]byte, hex.DecodedLen(len(src)))
-n, err := hex.Decode(dst, src)
-if err != nil {
-    log.Fatal(err)
-}
-
-fmt.Printf("%s\n", dst[:n])
-
-</pre> <p>Output:</p> <pre class="output" data-language="go">Hello Gopher!
-</pre>   <h2 id="DecodeString">func <span>DecodeString</span>  </h2> <pre data-language="go">func DecodeString(s string) ([]byte, error)</pre> <p>DecodeString returns the bytes represented by the hexadecimal string s. </p>
-<p>DecodeString expects that src contains only hexadecimal characters and that src has even length. If the input is malformed, DecodeString returns the bytes decoded before the error. </p>   <h4 id="example_DecodeString"> <span class="text">Example</span>
-</h4> <p>Code:</p> <pre class="code" data-language="go">const s = "48656c6c6f20476f7068657221"
-decoded, err := hex.DecodeString(s)
-if err != nil {
-    log.Fatal(err)
-}
-
-fmt.Printf("%s\n", decoded)
-
-</pre> <p>Output:</p> <pre class="output" data-language="go">Hello Gopher!
-</pre>   <h2 id="DecodedLen">func <span>DecodedLen</span>  </h2> <pre data-language="go">func DecodedLen(x int) int</pre> <p>DecodedLen returns the length of a decoding of x source bytes. Specifically, it returns x / 2. </p>
-<h2 id="Dump">func <span>Dump</span>  </h2> <pre data-language="go">func Dump(data []byte) string</pre> <p>Dump returns a string that contains a hex dump of the given data. The format of the hex dump matches the output of `hexdump -C` on the command line. </p>   <h4 id="example_Dump"> <span class="text">Example</span>
-</h4> <p>Code:</p> <pre class="code" data-language="go">content := []byte("Go is an open source programming language.")
-
-fmt.Printf("%s", hex.Dump(content))
-
-</pre> <p>Output:</p> <pre class="output" data-language="go">00000000  47 6f 20 69 73 20 61 6e  20 6f 70 65 6e 20 73 6f  |Go is an open so|
-00000010  75 72 63 65 20 70 72 6f  67 72 61 6d 6d 69 6e 67  |urce programming|
-00000020  20 6c 61 6e 67 75 61 67  65 2e                    | language.|
-</pre>   <h2 id="Dumper">func <span>Dumper</span>  </h2> <pre data-language="go">func Dumper(w io.Writer) io.WriteCloser</pre> <p>Dumper returns a <span>io.WriteCloser</span> that writes a hex dump of all written data to w. The format of the dump matches the output of `hexdump -C` on the command line. </p>   <h4 id="example_Dumper"> <span class="text">Example</span>
-</h4> <p>Code:</p> <pre class="code" data-language="go">lines := []string{
-    "Go is an open source programming language.",
-    "\n",
-    "We encourage all Go users to subscribe to golang-announce.",
-}
-
-stdoutDumper := hex.Dumper(os.Stdout)
-
-defer stdoutDumper.Close()
-
-for _, line := range lines {
-    stdoutDumper.Write([]byte(line))
-}
-
-</pre> <p>Output:</p> <pre class="output" data-language="go">00000000  47 6f 20 69 73 20 61 6e  20 6f 70 65 6e 20 73 6f  |Go is an open so|
-00000010  75 72 63 65 20 70 72 6f  67 72 61 6d 6d 69 6e 67  |urce programming|
-00000020  20 6c 61 6e 67 75 61 67  65 2e 0a 57 65 20 65 6e  | language..We en|
-00000030  63 6f 75 72 61 67 65 20  61 6c 6c 20 47 6f 20 75  |courage all Go u|
-00000040  73 65 72 73 20 74 6f 20  73 75 62 73 63 72 69 62  |sers to subscrib|
-00000050  65 20 74 6f 20 67 6f 6c  61 6e 67 2d 61 6e 6e 6f  |e to golang-anno|
-00000060  75 6e 63 65 2e                                    |unce.|
-</pre>   <h2 id="Encode">func <span>Encode</span>  </h2> <pre data-language="go">func Encode(dst, src []byte) int</pre> <p>Encode encodes src into <a href="#EncodedLen">EncodedLen</a>(len(src)) bytes of dst. As a convenience, it returns the number of bytes written to dst, but this value is always <a href="#EncodedLen">EncodedLen</a>(len(src)). Encode implements hexadecimal encoding. </p>   <h4 id="example_Encode"> <span class="text">Example</span>
-</h4> <p>Code:</p> <pre class="code" data-language="go">src := []byte("Hello Gopher!")
-
-dst := make([]byte, hex.EncodedLen(len(src)))
-hex.Encode(dst, src)
-
-fmt.Printf("%s\n", dst)
-
-</pre> <p>Output:</p> <pre class="output" data-language="go">48656c6c6f20476f7068657221
-</pre>   <h2 id="EncodeToString">func <span>EncodeToString</span>  </h2> <pre data-language="go">func EncodeToString(src []byte) string</pre> <p>EncodeToString returns the hexadecimal encoding of src. </p>   <h4 id="example_EncodeToString"> <span class="text">Example</span>
-</h4> <p>Code:</p> <pre class="code" data-language="go">src := []byte("Hello")
-encodedStr := hex.EncodeToString(src)
-
-fmt.Printf("%s\n", encodedStr)
-
-</pre> <p>Output:</p> <pre class="output" data-language="go">48656c6c6f
-</pre>   <h2 id="EncodedLen">func <span>EncodedLen</span>  </h2> <pre data-language="go">func EncodedLen(n int) int</pre> <p>EncodedLen returns the length of an encoding of n source bytes. Specifically, it returns n * 2. </p>
-<h2 id="NewDecoder">func <span>NewDecoder</span>  <span title="Added in Go 1.10">1.10</span> </h2> <pre data-language="go">func NewDecoder(r io.Reader) io.Reader</pre> <p>NewDecoder returns an <span>io.Reader</span> that decodes hexadecimal characters from r. NewDecoder expects that r contain only an even number of hexadecimal characters. </p>
-<h2 id="NewEncoder">func <span>NewEncoder</span>  <span title="Added in Go 1.10">1.10</span> </h2> <pre data-language="go">func NewEncoder(w io.Writer) io.Writer</pre> <p>NewEncoder returns an <span>io.Writer</span> that writes lowercase hexadecimal characters to w. </p>
-<h2 id="InvalidByteError">type <span>InvalidByteError</span>  </h2> <p>InvalidByteError values describe errors resulting from an invalid byte in a hex string. </p>
-<pre data-language="go">type InvalidByteError byte</pre> <h3 id="InvalidByteError.Error">func (InvalidByteError) <span>Error</span>  </h3> <pre data-language="go">func (e InvalidByteError) Error() string</pre><div class="_attribution">
-  <p class="_attribution-p">
-    &copy; Google, Inc.<br>Licensed under the Creative Commons Attribution License 3.0.<br>
-    <a href="http://golang.org/pkg/encoding/hex/" class="_attribution-link">http://golang.org/pkg/encoding/hex/</a>
-  </p>
-</div>